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

siglab_py/ordergateway/gateway.py

@@ -1,3 +1,4 @@
+# type: ignore
 import sys
 import traceback
 import os
@@ -19,15 +20,15 @@ from re import Pattern
 from redis import StrictRedis
 import asyncio
 
-from util.aws_util import AwsKmsUtil
-
 import ccxt.pro as ccxtpro
 
+from siglab_py.util.retry_util import retry
+from siglab_py.util.aws_util import AwsKmsUtil
 from siglab_py.exchanges.any_exchange import AnyExchange
-from util.market_data_util import async_instantiate_exchange
+from siglab_py.util.market_data_util import async_instantiate_exchange
 from siglab_py.ordergateway.client import Order, DivisiblePosition
-from siglab_py.constants import LogLevel # type: ignore
-from util.notification_util import dispatch_notification
+from siglab_py.constants import LogLevel
+from siglab_py.util.notification_util import dispatch_notification
 
 current_filename = os.path.basename(__file__)
 
@@ -41,14 +42,17 @@ if sys.platform == 'win32':
 '''
 Usage:
     set PYTHONPATH=%PYTHONPATH%;D:\dev\siglab\siglab_py
-    python gateway.py --gateway_id hyperliquid_01 --default_type linear --rate_limit_ms 100 --encrypt_decrypt_with_aws_kms Y --aws_kms_key_id xxx --apikey xxx --secret xxxx --slack_info_url=https://hooks.slack.com/services/xxx --slack_critial_url=https://hooks.slack.com/services/xxx --slack_alert_url=https://hooks.slack.com/services/xxx
+    python gateway.py --gateway_id hyperliquid_01 --default_type linear --rate_limit_ms 100 --encrypt_decrypt_with_aws_kms Y --aws_kms_key_id xxx --apikey xxx --secret xxxx --verbose N --slack_info_url=https://hooks.slack.com/services/xxx --slack_critial_url=https://hooks.slack.com/services/xxx --slack_alert_url=https://hooks.slack.com/services/xxx
 
     --default_type defaults to linear
+    --default_sub_type defaults to None (Depends on your exchange/broker, if they requires this)
     --rate_limit_ms defaults to 100
     --encrypt_decrypt_with_aws_kms If you encrypt apikey and secret using AMS KMS, then set to Y. If apikey and secret in unencrypted plain text, set to N.
 	--passphrase is optional, this depends on the exchange.
+    --verbose logging verbosity, Y or N (default)
     --gateway_id contains two parts separated by underscore. Gateway.py will parse 'hyperliquid_01' into two parts: 'hyperliquid' (Exchange name) and '01' (Use this for your sub account ID). Exchange name need be spelt exactly. Please have a look at market_data_util async_instantiate_exchange.
     --slack_info_url, --slack_critical_url and --slack_alert_url are if you want gateway to dispatch Slack notification on events.
+    --order_amount_randomize_max_pct adds small variance to sliced order amount (Default max 10% on sliced amount) to cover your track in order executions, this is useful especially when executing bigger orders during quieter hours.
     How to get Slack webhook urls? https://medium.com/@natalia_assad/how-send-a-table-to-slack-using-python-d1a20b08abe0
 
     Another example:
@@ -106,6 +110,7 @@ To debug from vscode, launch.json:
                     "--apikey", "xxx",
                     "--secret", "xxx",
                     "--passphrase", "xxx",
+                    "--verbose", "N",
 
                     "--slack_info_url", "https://hooks.slack.com/services/xxx",
                     "--slack_critial_url", "https://hooks.slack.com/services/xxx",
@@ -212,6 +217,7 @@ param : Dict = {
     "executions_publish_topic" : r"ordergateway_executions_$GATEWAY_ID$",
 
     "default_fees_ccy" : None,
+    "order_amount_randomize_max_pct" : 0,
     "loop_freq_ms" : 500, # reduce this if you need trade faster
     "loops_random_delay_multiplier" : 1, # Add randomness to time between slices are sent off. Set to 1 if no random delay needed.
     "wait_fill_threshold_ms" : 5000,
@@ -293,14 +299,16 @@ def log(message : str, log_level : LogLevel = LogLevel.INFO):
         logger.error(f"{datetime.now()} {message}")
 
 def parse_args():
-    parser = argparse.ArgumentParser() # type: ignore
+    parser = argparse.ArgumentParser()
 
     parser.add_argument("--gateway_id", help="gateway_id: Where are you sending your order?", default=None)
     parser.add_argument("--dry_run", help="Y or N (default, for testing). If Y, orders won't be dispatched to exchange, gateway will fake reply.", default='N')
     parser.add_argument("--default_type", help="default_type: spot, linear, inverse, futures ...etc", default='linear')
+    parser.add_argument("--default_sub_type", help="default_sub_type", default=None)
     parser.add_argument("--rate_limit_ms", help="rate_limit_ms: Check your exchange rules", default=100)
 
     parser.add_argument("--default_fees_ccy", help="If you're trading crypto, CEX fees USDT, DEX fees USDC in many cases. Default None, in which case gateway won't aggregatge fees from executions for you.", default=None)
+    parser.add_argument("--order_amount_randomize_max_pct", help="Randomize order amount to hide your track? This is max percentage variance applied on sliced amount (not entire order amount)", default=10)
     parser.add_argument("--loop_freq_ms", help="Loop delays. Reduce this if you want to trade faster.", default=500)
     parser.add_argument("--wait_fill_threshold_ms", help="Wait for fills for how long?", default=5000)
 
@@ -309,6 +317,7 @@ def parse_args():
     parser.add_argument("--apikey", help="Exchange apikey", default=None)
     parser.add_argument("--secret", help="Exchange secret", default=None)
     parser.add_argument("--passphrase", help="Exchange passphrase", default=None)
+    parser.add_argument("--verbose", help="logging verbosity, Y or N (default).", default='N')
 
     parser.add_argument("--slack_info_url", help="Slack webhook url for INFO", default=None)
     parser.add_argument("--slack_critial_url", help="Slack webhook url for CRITICAL", default=None)
@@ -326,8 +335,10 @@ def parse_args():
         param['dry_run'] = False
 
     param['default_type'] = args.default_type
+    param['default_sub_type'] = args.default_sub_type
     param['rate_limit_ms'] = int(args.rate_limit_ms)
     param['default_fees_ccy'] = args.default_fees_ccy
+    param['order_amount_randomize_max_pct'] = float(args.order_amount_randomize_max_pct)
     param['loop_freq_ms'] = int(args.loop_freq_ms)
     param['wait_fill_threshold_ms'] = int(args.wait_fill_threshold_ms)
 
@@ -343,6 +354,13 @@ def parse_args():
     param['apikey'] = args.apikey
     param['secret'] = args.secret
     param['passphrase'] = args.passphrase
+    if args.verbose:
+        if args.verbose=='Y':
+            param['verbose'] = True
+        else:
+            param['verbose'] = False
+    else:
+        param['verbose'] = False
 
     param['notification']['slack']['info']['webhook_url'] = args.slack_info_url
     param['notification']['slack']['critical']['webhook_url'] = args.slack_critial_url
@@ -371,7 +389,7 @@ async def watch_orders_task(
 ):
     while True:
         try:
-            order_updates = await exchange.watch_orders() # type: ignore
+            order_updates = await exchange.watch_orders()
             for order_update in order_updates:
                 order_id = order_update['id']
                 executions[order_id] = order_update
@@ -383,6 +401,9 @@ async def watch_orders_task(
         await asyncio.sleep(param['loop_freq_ms']/1000)
 
 async def send_heartbeat(exchange):
+    if not exchange.clients:
+        log(f'Please check https://github.com/ccxt/ccxt/blob/master/python/ccxt/pro/{exchange.name}, exchange.clients empty?')
+        return
 
     await asyncio.sleep(10)
 
@@ -390,11 +411,15 @@ async def send_heartbeat(exchange):
         try:
             first_ws_url = next(iter(exchange.clients))
             client = exchange.clients[first_ws_url]
-            message = exchange.ping(client)
-            await client.send(message)
-            log('Heartbeat sent')
+            if exchange.ping:
+                message = exchange.ping(client)
+                await client.send(message)
+                log('Heartbeat sent')
+            else:
+                log(f'Please check https://github.com/ccxt/ccxt/blob/master/python/ccxt/pro/{exchange.name} if ping was implemented')
+        
         except Exception as hb_error:
-            log(f'Failed to send heartbeat: {hb_error}')
+            log(f'Failed to send heartbeat: {hb_error} {str(sys.exc_info()[0])} {str(sys.exc_info()[1])} {traceback.format_exc()}')
         finally:
             await asyncio.sleep(20)
 
@@ -406,15 +431,17 @@ async def execute_one_position(
     notification_params : Dict[str, Any]
 ):
     try:
-        market : Dict[str, Any] = exchange.markets[position.ticker] if position.ticker in exchange.markets else None # type: ignore
+        market : Dict[str, Any] = exchange.markets[position.ticker] if position.ticker in exchange.markets else None
         if not market:
-            raise ArgumentError(f"Market not found for {position.ticker} under {exchange.name}") # type: ignore
+            raise ArgumentError(f"Market not found for {position.ticker} under {exchange.name}")
 
-        min_amount = float(market['limits']['amount']['min']) if market['limits']['amount']['min'] else 0 # type: ignore
+        min_amount = float(market['limits']['amount']['min']) if market['limits']['amount']['min'] else 0
         multiplier = market['contractSize'] if 'contractSize' in market and market['contractSize'] else 1
         position.multiplier = multiplier
 
-        log(f"{position.ticker} min_amount: {min_amount}, multiplier: {multiplier}") 
+        order_amount_randomize_max_pct : float = param['order_amount_randomize_max_pct']
+
+        log(f"{position.ticker} min_amount: {min_amount}, multiplier: {multiplier}, order_amount_randomize_max_pct: {order_amount_randomize_max_pct}") 
 
         slices : List[Order] = position.to_slices()
 
@@ -428,7 +455,19 @@ async def execute_one_position(
                 slices[-1].amount += last_slice.amount
 
                 log(f"{position.ticker} Last slice residual smaller than min_amount. Amount is added to prev slice instead. last_slice_amount: {last_slice.amount/multiplier}, last_slice_rounded_amount: {last_slice_rounded_amount_in_base_ccy}") 
-
+        
+        @retry(num_attempts=3, pause_between_retries_ms=3000)
+        async def _fetch_order(
+            order_id : str, 
+            ticker : str,
+            exchange : AnyExchange,
+        ):
+            order_update = await exchange.fetch_order(order_id, ticker)
+            return order_update
+        
+        randomized_order_amount : float = 0
+        last_randomized_order_amount : float = 0
+        apply_last_randomized_amount : bool = False # False: Apply new variance, True: Apply -1 * last_randomized_order_amount
         i = 0
         for slice in slices:
             try:
@@ -436,9 +475,21 @@ async def execute_one_position(
 
                 dt_now : datetime = datetime.now()
 
-                slice_amount_in_base_ccy : float = slice.amount
+                if len(slices)>1:
+                    if not apply_last_randomized_amount and i<len(slices):
+                        randomized_order_amount = slice.amount * (order_amount_randomize_max_pct * random.uniform(-1, 1)) /100
+                        last_randomized_order_amount = randomized_order_amount
+                        
+                    else:
+                        randomized_order_amount = -1 * last_randomized_order_amount # Apply the opposite of last slice's variance
+                        last_randomized_order_amount = 0 # If # slices == 5, last slice don't apply random amount, so reset last_randomized_order_amount to zero.
+                
+                slice_amount_in_base_ccy : float = slice.amount + randomized_order_amount
+
+                apply_last_randomized_amount = not apply_last_randomized_amount
+                    
                 rounded_slice_amount_in_base_ccy = slice_amount_in_base_ccy / multiplier # After divided by multiplier, rounded_slice_amount_in_base_ccy in number of contracts actually (Not in base ccy).
-                rounded_slice_amount_in_base_ccy = exchange.amount_to_precision(position.ticker, rounded_slice_amount_in_base_ccy) # type: ignore
+                rounded_slice_amount_in_base_ccy = exchange.amount_to_precision(position.ticker, rounded_slice_amount_in_base_ccy)
                 rounded_slice_amount_in_base_ccy = float(rounded_slice_amount_in_base_ccy) if rounded_slice_amount_in_base_ccy else 0
                 rounded_slice_amount_in_base_ccy = rounded_slice_amount_in_base_ccy if rounded_slice_amount_in_base_ccy>min_amount else min_amount
 
@@ -446,7 +497,7 @@ async def execute_one_position(
                     log(f"{position.ticker} Slice amount rounded to zero?! slice amount before rounding: {slice.amount}") 
                     continue
 
-                orderbook = await exchange.fetch_order_book(symbol=position.ticker, limit=3) # type: ignore
+                orderbook = await exchange.fetch_order_book(symbol=position.ticker, limit=3)
                 if position.side=='buy':
                     asks = [ ask[0] for ask in orderbook['asks'] ]
                     best_asks = min(asks)
@@ -456,7 +507,7 @@ async def execute_one_position(
                     best_bid = max(bids)
                     limit_price : float = best_bid * (1 - position.leg_room_bps/10000)
                     
-                rounded_limit_price : float = exchange.price_to_precision(position.ticker, limit_price) # type: ignore
+                rounded_limit_price : float = exchange.price_to_precision(position.ticker, limit_price)
                 rounded_limit_price = float(rounded_limit_price)
                 
                 order_params = {
@@ -472,7 +523,7 @@ async def execute_one_position(
                             )
 
                     if not param['dry_run']:
-                        executed_order = await exchange.create_order( # type: ignore
+                        executed_order = await exchange.create_order(
                             symbol = position.ticker,
                             type = position.order_type,
                             amount = rounded_slice_amount_in_base_ccy,
@@ -499,7 +550,7 @@ async def execute_one_position(
 
                 else:
                     if not param['dry_run']:
-                        executed_order = await exchange.create_order( # type: ignore
+                        executed_order = await exchange.create_order(
                             symbol = position.ticker,
                             type = position.order_type,
                             amount = rounded_slice_amount_in_base_ccy,
@@ -596,11 +647,10 @@ async def execute_one_position(
                         elapsed_sec = time.time() - start_time
                         log(f"{position.ticker} waiting for order update ... elapsed_sec: {elapsed_sec}")
                 
-                
                 # Cancel hung limit order, resend as market
                 if order_status!='closed':
                     # If no update from websocket, do one last fetch via REST
-                    order_update = await exchange.fetch_order(order_id, position.ticker) # type: ignore 
+                    order_update = await _fetch_order(order_id, position.ticker, exchange) 
                     order_status = order_update['status']
                     filled_amount = order_update['filled']
                     remaining_amount = order_update['remaining']
@@ -610,15 +660,15 @@ async def execute_one_position(
 
                     if order_status!='closed':
                         log(f"Final order_update before cancel+resend: {json.dumps(order_update, indent=4)}", log_level=LogLevel.INFO)
-                        await exchange.cancel_order(order_id, position.ticker)  # type: ignore
+                        await exchange.cancel_order(order_id, position.ticker)
                         position.get_execution(order_id)['status'] = 'canceled'
                         log(f"Canceled unfilled/partial filled order: {order_id}. Resending remaining_amount: {remaining_amount} as market order.", log_level=LogLevel.INFO)
                         
-                        rounded_slice_amount_in_base_ccy = exchange.amount_to_precision(position.ticker, remaining_amount) # type: ignore
+                        rounded_slice_amount_in_base_ccy = exchange.amount_to_precision(position.ticker, remaining_amount)
                         rounded_slice_amount_in_base_ccy = float(rounded_slice_amount_in_base_ccy)
                         rounded_slice_amount_in_base_ccy = rounded_slice_amount_in_base_ccy if rounded_slice_amount_in_base_ccy>min_amount else min_amount
                         if rounded_slice_amount_in_base_ccy>0:
-                            executed_resent_order = await exchange.create_order(  # type: ignore
+                            executed_resent_order = await exchange.create_order(
                                 symbol=position.ticker,
                                 type='market',
                                 amount=remaining_amount,
@@ -654,7 +704,7 @@ async def execute_one_position(
 
                             if (not order_status or order_status!='closed'):
                                 # If no update from websocket, do one last fetch via REST
-                                order_update = await exchange.fetch_order(order_id, position.ticker) # type: ignore 
+                                order_update = await _fetch_order(order_id, position.ticker, exchange) 
                                 order_status = order_update['status']
                                 filled_amount = order_update['filled']
                                 remaining_amount = order_update['remaining']
@@ -691,13 +741,17 @@ async def execute_one_position(
         for dispatched_slice in position.dispatched_slices:
             log(f"{json.dumps(dispatched_slice.to_dict(), indent=4)}")
 
+        position_from_exchange = await exchange.fetch_position(position.ticker)
+        log(f"position update:")
+        log(f"{json.dumps(position_from_exchange, indent=4)}")
+
         position.filled_amount = position.get_filled_amount()
         position.average_cost = position.get_average_cost()
         position.fees = position.get_fees()
 
-        balances = await exchange.fetch_balance() # type: ignore
+        balances = await exchange.fetch_balance()
         if param['default_type']!='spot':
-            updated_position = await exchange.fetch_position(symbol=position.ticker) # type: ignore
+            updated_position = await exchange.fetch_position(symbol=position.ticker)
             # After position closed, 'updated_position' can be an empty dict. hyperliquid for example.
             amount = (updated_position['contracts'] if updated_position else 0) * position.multiplier # in base ccy
         else:
@@ -725,7 +779,7 @@ async def execute_one_position(
         err_msg = f"{position.ticker}  Execution failed: {position_execution_err} {str(sys.exc_info()[0])} {str(sys.exc_info()[1])} {traceback.format_exc()}"
         log(err_msg)
 
-        dispatch_notification(title=f"{param['current_filename']} {param['gateway_id']} {position.ticker} execute_one_position failed!!!", message=err_msg, footer=param['notification']['footer'], params=notification_params, log_level=LogLevel.ERROR, logger=logger) # type: ignore
+        dispatch_notification(title=f"{param['current_filename']} {param['gateway_id']} {position.ticker} execute_one_position failed!!!", message=err_msg, footer=param['notification']['footer'], params=notification_params, log_level=LogLevel.ERROR, logger=logger)
 
         position.done = False
         position.execution_err = err_msg
@@ -750,6 +804,7 @@ async def work(
 
     asyncio.create_task(send_heartbeat(exchange))
 
+    loop_i : int = 0
     while True:
         try:
             keys = redis_client.keys()
@@ -811,9 +866,14 @@ async def work(
                         log_level=LogLevel.ERROR
                         )
 
+            if loop_i%10==0:
+                balances = await exchange.fetch_balance()
+                log(f"{param['gateway_id']}: account balances {balances}")
+
         except Exception as loop_error:
             log(f"Error: {loop_error} {str(sys.exc_info()[0])} {str(sys.exc_info()[1])} {traceback.format_exc()}")
         finally:
+            loop_i += 1
             await asyncio.sleep(param['loop_freq_ms']/1000)
 
 async def main():
@@ -862,13 +922,15 @@ async def main():
         secret=secret,
         passphrase=passphrase,
         default_type=param['default_type'],
-        rate_limit_ms=param['rate_limit_ms']
+        default_sub_type=param['default_sub_type'],
+        rate_limit_ms=param['rate_limit_ms'],
+        verbose=param['verbose']
     )
     if exchange:
         # Once exchange instantiated, try fetch_balance to confirm connectivity and test credentials.
-        balances = await exchange.fetch_balance() # type: ignore
+        balances = await exchange.fetch_balance()
         log(f"{param['gateway_id']}: account balances {balances}")
-        dispatch_notification(title=f"{param['current_filename']} {param['gateway_id']} started", message=balances, footer=param['notification']['footer'], params=notification_params, log_level=LogLevel.CRITICAL, logger=logger)
+        dispatch_notification(title=f"{param['current_filename']} {param['gateway_id']} started", message=balances['total'], footer=param['notification']['footer'], params=notification_params, log_level=LogLevel.CRITICAL, logger=logger)
 
         await work(param=param, exchange=exchange, redis_client=redis_client, notification_params=notification_params)
 

siglab_py/tests/integration/market_data_util_tests.py

@@ -1,6 +1,7 @@
 import unittest
 from datetime import datetime, timedelta
 from typing import Union
+import logging
 from pathlib import Path
 
 from util.market_data_util import *
@@ -107,7 +108,8 @@ class MarketDataUtilTests(unittest.TestCase):
             end_ts=end_date.timestamp(),
             exchange=exchange,
             normalized_symbols=normalized_symbols,
-            candle_size='1h'
+            candle_size='1h',
+            logger=logging.getLogger()
         )[normalized_symbols[0]]
 
         assert pd_candles is not None
@@ -118,6 +120,40 @@ class MarketDataUtilTests(unittest.TestCase):
             assert set(pd_candles.columns) >= expected_columns, "Missing expected columns."
             assert pd_candles['timestamp_ms'].notna().all(), "timestamp_ms column contains NaN values."
             assert pd_candles['timestamp_ms'].is_monotonic_increasing, "Timestamps are not in ascending order."
+
+    def test_aggregate_candles(self):
+        end_date : datetime = datetime.today()
+        start_date : datetime = end_date + timedelta(hours=-8)
+
+        param = {
+            'apiKey' : None,
+            'secret' : None,
+            'password' : None,
+            'subaccount' : None,
+            'rateLimit' : 100,    # In ms
+            'options' : {
+                'defaultType': 'swap'            }
+        }
+
+        exchange : Exchange = okx(param) # type: ignore
+        normalized_symbols = [ 'BTC/USDT:USDT' ]
+        pd_candles: Union[pd.DataFrame, None] = fetch_candles(
+            start_ts=start_date.timestamp(),
+            end_ts=end_date.timestamp(),
+            exchange=exchange,
+            normalized_symbols=normalized_symbols,
+            candle_size='15m' # <---- aggregate 1m into 15m candles
+        )[normalized_symbols[0]]
+
+        assert pd_candles is not None
+        pd_candles['timestamp_ms_gap'] = pd_candles['timestamp_ms'].diff()
+        timestamp_ms_gap_median = pd_candles['timestamp_ms_gap'].median()
+        NUM_MS_IN_1HR = 60*60*1000
+        expected_15m_gap_ms = NUM_MS_IN_1HR/4
+        assert(timestamp_ms_gap_median==expected_15m_gap_ms)
+        total_num_rows = pd_candles.shape[0]
+        num_rows_with_15min_gaps = pd_candles[pd_candles.timestamp_ms_gap!=timestamp_ms_gap_median].shape[0]
+        assert(num_rows_with_15min_gaps/total_num_rows <= 0.4) # Why not 100% match? minute bars may have gaps (Also depends on what ticker)
         
     def test_fetch_candles_futubull(self):
         # You need Futu OpenD running and you need entitlements

siglab_py/tests/unit/analytic_util_tests.py

@@ -2,7 +2,7 @@ import unittest
 from typing import List
 from pathlib import Path
 
-from util.analytic_util import compute_candles_stats
+from util.analytic_util import compute_candles_stats, lookup_fib_target
 
 import pandas as pd
 
@@ -38,25 +38,27 @@ class AnalyticUtilTests(unittest.TestCase):
             pd_candles=pd_candles,
             boillenger_std_multiples=2,
             sliding_window_how_many_candles=20,
-            pypy_compat=True
+            pypy_compat=True # Slopes calculation? Set pypy_compat to False
         )
 
         expected_columns : List[str] = [
             'exchange', 'symbol', 'timestamp_ms', 
             'open', 'high', 'low', 'close', 'volume', 
             'datetime', 'datetime_utc', 'year', 'month', 'day', 'hour', 'minute', 'dayofweek', 
-            'pct_chg_on_close', 'candle_height', 
+            'pct_chg_on_close', 'candle_height', 'candle_body_height',
             'week_of_month', 'apac_trading_hr', 'emea_trading_hr', 'amer_trading_hr', 
-            'is_green', 'pct_change_close', 
+            'is_green', 'candle_class', 'pct_change_close', 
             'sma_short_periods', 'sma_long_periods', 'ema_short_periods', 'ema_long_periods', 'ema_close', 
             'std', 'std_percent', 
             'vwap_short_periods', 'vwap_long_periods',
-            'candle_height_percent', 'candle_height_percent_rounded', 
+            'candle_height_percent', 'candle_height_percent_rounded', 'candle_body_height_percent', 'candle_body_height_percent_rounded',
             'log_return', 'interval_hist_vol', 'annualized_hist_vol',
             'chop_against_ema', 
             'ema_volume_short_periods', 'ema_volume_long_periods', 
             'ema_cross', 'ema_cross_last', 'ema_bullish_cross_last_id', 'ema_bearish_cross_last_id',
             'max_short_periods', 'max_long_periods', 'idmax_short_periods', 'idmax_long_periods', 'min_short_periods', 'min_long_periods', 'idmin_short_periods', 'idmin_long_periods', 
+            'max_candle_body_height_percent_long_periods', 'idmax_candle_body_height_percent_long_periods',
+            'min_candle_body_height_percent_long_periods', 'idmin_candle_body_height_percent_long_periods',
             'price_swing_short_periods', 'price_swing_long_periods',
             'trend_from_highs_long_periods', 'trend_from_lows_long_periods', 'trend_from_highs_short_periods', 'trend_from_lows_short_periods',
             'h_l', 'h_pc', 'l_pc', 'tr', 'atr', 'atr_avg_short_periods', 'atr_avg_long_periods',
@@ -65,12 +67,12 @@ class AnalyticUtilTests(unittest.TestCase):
             'aggressive_up', 'aggressive_up_index', 'aggressive_up_candle_height', 'aggressive_up_candle_high', 'aggressive_up_candle_low', 'aggressive_down', 'aggressive_down_index', 'aggressive_down_candle_height', 'aggressive_down_candle_high', 'aggressive_down_candle_low', 
             'fvg_low', 'fvg_high', 'fvg_gap', 'fvg_mitigated', 
             'close_delta', 'close_delta_percent', 'up', 'down', 
-            'rsi', 'ema_rsi', 'rsi_max', 'rsi_idmax', 'rsi_min', 'rsi_idmin', 'rsi_trend', 'rsi_trend_from_highs', 'rsi_trend_from_lows', 'rsi_divergence',
+            'rsi', 'rsi_bucket', 'ema_rsi', 'rsi_max', 'rsi_idmax', 'rsi_min', 'rsi_idmin', 'rsi_trend', 'rsi_trend_from_highs', 'rsi_trend_from_lows', 'rsi_divergence',
             'typical_price', 
-            'money_flow', 'money_flow_positive', 'money_flow_negative', 'positive_flow_sum', 'negative_flow_sum', 'money_flow_ratio', 'mfi', 
-            'macd', 'signal', 'macd_minus_signal', 
+            'money_flow', 'money_flow_positive', 'money_flow_negative', 'positive_flow_sum', 'negative_flow_sum', 'money_flow_ratio', 'mfi', 'mfi_bucket',
+            'macd', 'signal', 'macd_minus_signal', 'macd_cross', 'macd_bullish_cross_last_id', 'macd_bearish_cross_last_id', 'macd_cross_last',
             'fib_0.618_short_periods', 'fib_0.618_long_periods', 
-            'gap_close_vs_ema', 
+            'gap_close_vs_ema', 'gap_close_vs_ema_percent',
             'close_above_or_below_ema', 
             'close_vs_ema_inflection'
         ]
@@ -78,4 +80,29 @@ class AnalyticUtilTests(unittest.TestCase):
         missing_columns = [ expected for expected in expected_columns if expected not in pd_candles.columns.to_list() ]
         unexpected_columns = [ actual for actual in pd_candles.columns.to_list() if actual not in expected_columns ]
 
-        assert(pd_candles.columns.to_list()==expected_columns)
+        assert(pd_candles.columns.to_list()==expected_columns)
+
+    def test_lookup_fib_target(self):
+        data_dir = Path(__file__).parent.parent.parent.parent / "data"
+        csv_path = data_dir / "sample_btc_candles.csv"
+        pd_candles : pd.DataFrame = pd.read_csv(csv_path)
+        target_fib_level : float = 0.618
+        compute_candles_stats(
+            pd_candles=pd_candles,
+            boillenger_std_multiples=2,
+            sliding_window_how_many_candles=20,
+            target_fib_level=target_fib_level,
+            pypy_compat=True # Slopes calculation? Set pypy_compat to False
+        )
+
+        last_row = pd_candles.iloc[-1]
+        result = lookup_fib_target(
+            row=last_row, 
+            pd_candles=pd_candles,
+            target_fib_level=target_fib_level
+            )
+        if result:
+            assert(result['short_periods']['min']<result['short_periods']['fib_target']<result['short_periods']['max'])
+            assert(result['long_periods']['min']<result['long_periods']['fib_target']<result['long_periods']['max'])
+        
+