siglab-py 0.2.8__py3-none-any.whl → 0.3.0__py3-none-any.whl

siglab_py/ordergateway/gateway.py

@@ -25,8 +25,10 @@ import ccxt.pro as ccxtpro
 
 from siglab_py.exchanges.any_exchange import AnyExchange
 from siglab_py.ordergateway.client import Order, DivisiblePosition
-from siglab_py.util import notification_util
 from siglab_py.constants import LogLevel # type: ignore
+from util.notification_util import dispatch_notification
+
+current_filename = os.path.basename(__file__)
 
 '''
 Usage:
@@ -114,7 +116,7 @@ To debug from vscode, launch.json:
                 "order_type": "limit",
                 "leg_room_bps": 5,
                 "slices": 5,
-                "wait_fill_threshold_ms": 15000,
+                "wait_fill_threshold_ms": 5000,
                 "executions": {},
                 "filled_amount": 0,
                 "average_cost": 0
@@ -132,7 +134,7 @@ To debug from vscode, launch.json:
                 "order_type": "limit",
                 "leg_room_bps": 5,
                 "slices": 5,
-                "wait_fill_threshold_ms": 15000,
+                "wait_fill_threshold_ms": 5000,
                 "executions": {
                     "xxx": {    <-- order id from exchange
                         "info": { <-- ccxt convention, raw response from exchanges under info tag
@@ -199,6 +201,9 @@ param : Dict = {
     "default_fees_ccy" : None,
     "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,
+
+    'current_filename' : current_filename,
 
     'notification' : {
         'footer' : None,
@@ -284,6 +289,7 @@ def parse_args():
 
     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("--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)
 
     parser.add_argument("--encrypt_decrypt_with_aws_kms", help="Y or N. If encrypt_decrypt_with_aws_kms=N, pass in apikey, secret and passphrase unencrypted (Not recommended, for testing only). If Y, they will be decrypted using AMS KMS key.", default='N')
     parser.add_argument("--aws_kms_key_id", help="AWS KMS key ID", default=None)
@@ -310,6 +316,7 @@ def parse_args():
     param['rate_limit_ms'] = int(args.rate_limit_ms)
     param['default_fees_ccy'] = args.default_fees_ccy
     param['loop_freq_ms'] = int(args.loop_freq_ms)
+    param['wait_fill_threshold_ms'] = int(args.wait_fill_threshold_ms)
 
     if args.encrypt_decrypt_with_aws_kms:
         if args.encrypt_decrypt_with_aws_kms=='Y':
@@ -327,7 +334,8 @@ def parse_args():
     param['notification']['slack']['info']['webhook_url'] = args.slack_info_url
     param['notification']['slack']['critical']['webhook_url'] = args.slack_critial_url
     param['notification']['slack']['alert']['webhook_url'] = args.slack_alert_url
-    param['notification']['footer'] = f"From gateway {param['gateway_id']}"
+
+    param['notification']['footer'] = f"From {param['current_filename']} {param['gateway_id']}"
 
 def init_redis_client() -> StrictRedis:
     redis_client : StrictRedis = StrictRedis(
@@ -451,11 +459,11 @@ async def watch_orders_task(
                 order_id = order_update['id']
                 executions[order_id] = order_update
 
-            log(f"order updates: {order_updates}", log_level=LogLevel.INFO)
+            log(f"order updates: {json.dumps(order_updates, indent=4)}", log_level=LogLevel.INFO)
         except Exception as loop_err:
             print(f"watch_orders_task error: {loop_err}")
         
-        await asyncio.sleep(int(param['loop_freq_ms']/1000))
+        await asyncio.sleep(param['loop_freq_ms']/1000)
 
 async def send_heartbeat(exchange):
 
@@ -489,10 +497,25 @@ async def execute_one_position(
         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}") 
+
         slices : List[Order] = position.to_slices()
+
+        # Residual handling in last slice
+        last_slice = slices[-1]
+        last_slice_rounded_amount_in_base_ccy = exchange.amount_to_precision(position.ticker, last_slice.amount/multiplier) # After divided by multiplier, rounded_slice_amount_in_base_ccy in number of contracts actually (Not in base ccy).
+        last_slice_rounded_amount_in_base_ccy = float(last_slice_rounded_amount_in_base_ccy) if last_slice_rounded_amount_in_base_ccy else 0
+        if last_slice_rounded_amount_in_base_ccy<=min_amount:
+            slices.pop()
+            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}") 
+
         i = 0
         for slice in slices:
             try:
+                log(f"{position.ticker} sending slice# {i}")
+
                 dt_now : datetime = datetime.now()
 
                 slice_amount_in_base_ccy : float = slice.amount
@@ -620,9 +643,9 @@ async def execute_one_position(
                 log(f"Order dispatched: {order_id}. status: {order_status}, filled_amount: {filled_amount}, remaining_amount: {remaining_amount}")
 
                 if not order_status or order_status!='closed':
-                    start_time = time.time()
                     wait_threshold_sec = position.wait_fill_threshold_ms / 1000 
-
+                    
+                    start_time = time.time()
                     elapsed_sec = time.time() - start_time
                     while elapsed_sec < wait_threshold_sec:
                         order_update = None
@@ -637,12 +660,15 @@ async def execute_one_position(
                             position.append_execution(order_id, order_update)
 
                             if remaining_amount <= 0:
-                                log(f"Limit order fully filled: {order_id}", log_level=LogLevel.INFO)
+                                log(f"Limit order fully filled: {order_id}, order_update: {json.dumps(order_update, indent=4)}", log_level=LogLevel.INFO)
                                 break
 
                         loops_random_delay_multiplier : int = random.randint(1, param['loops_random_delay_multiplier']) if param['loops_random_delay_multiplier']!=1 else 1
-                        loop_freq_sec : int = int(param['loop_freq_ms']/1000)
+                        loop_freq_sec : int = max(1, param['loop_freq_ms']/1000)
                         await asyncio.sleep(loop_freq_sec * loops_random_delay_multiplier)
+
+                        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
@@ -653,13 +679,11 @@ async def execute_one_position(
                     filled_amount = order_update['filled']
                     remaining_amount = order_update['remaining']
                     order_update['multiplier'] = multiplier
-                    position.append_execution(order_id, order_update)
 
-                    if order_status!='closed': 
-                        order_status = order_update['status']
-                        filled_amount = order_update['filled']
-                        remaining_amount = order_update['remaining']
+                    position.append_execution(order_id, order_update)
 
+                    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
                         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)
@@ -680,7 +704,11 @@ async def execute_one_position(
                             executed_resent_order['multiplier'] = multiplier
                             position.append_execution(order_id, executed_resent_order)
 
-                            while not order_status or order_status!='closed':
+                            wait_threshold_sec = position.wait_fill_threshold_ms / 1000 
+
+                            start_time = time.time()
+                            elapsed_sec = time.time() - start_time
+                            while (not order_status or order_status!='closed') and (elapsed_sec < wait_threshold_sec):
                                 order_update = None
                                 if order_id in executions:
                                     order_update = executions[order_id]
@@ -691,11 +719,24 @@ async def execute_one_position(
                                     filled_amount = order_update['filled']
                                     remaining_amount = order_update['remaining']
 
-                                log(f"Waiting for resent market order to close {order_id} ...")
+                                elapsed_sec = time.time() - start_time
+                                log(f"Waiting for resent market order to close {order_id} ... elapsed_sec: {elapsed_sec}")
 
-                                await asyncio.sleep(int(param['loop_freq_ms']/1000))
+                                loops_random_delay_multiplier : int = random.randint(1, param['loops_random_delay_multiplier']) if param['loops_random_delay_multiplier']!=1 else 1
+                                loop_freq_sec : int = max(1, param['loop_freq_ms']/1000)
+                                await asyncio.sleep(loop_freq_sec * loops_random_delay_multiplier)
 
-                            log(f"Resent market order{order_id} filled. status: {order_status}, filled_amount: {filled_amount}, remaining_amount: {remaining_amount}")
+                            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_status = order_update['status']
+                                filled_amount = order_update['filled']
+                                remaining_amount = order_update['remaining']
+                                order_update['multiplier'] = multiplier
+
+                            log(f"Resent market order{order_id} filled. status: {order_status}, filled_amount: {filled_amount}, remaining_amount: {remaining_amount} {json.dumps(order_update, indent=4)}")
+                    else:
+                        log(f"{position.ticker} {order_id} status (From REST): {json.dumps(order_update, indent=4)}")
 
                 slice.dispatched_price = rounded_limit_price
                 slice.dispatched_amount = rounded_slice_amount_in_base_ccy
@@ -714,9 +755,16 @@ async def execute_one_position(
                     )
                 raise slice_err
             finally:
+                log(f"{position.ticker} done slice# {i}")
                 i += 1
-
+                
+        log(f"{position.ticker} patch_executions")
         position.patch_executions()
+
+        log(f"Dispatched slices:")
+        for dispatched_slice in position.dispatched_slices:
+            log(f"{json.dumps(dispatched_slice.to_dict(), indent=4)}")
+
         position.filled_amount = position.get_filled_amount()
         position.average_cost = position.get_average_cost()
         position.fees = position.get_fees()
@@ -734,14 +782,28 @@ async def execute_one_position(
         position.done = True
 
         log(f"Executions:")
-        log(f"{json.dumps(position.get_executions(), indent=4)}")
-
-        notification_util.dispatch_notification(title=f"{param['gateway_id']} execute_one_position {position.ticker} {position.side} {position.amount}", message=position.get_executions(), footer=param['notification']['footer'], params=notification_params, log_level=LogLevel.CRITICAL)
+        log(f"{json.dumps(position.to_dict(), indent=4)}")
+
+        notification_summary = {
+            'ticker' : position.ticker,
+            'side' : position.side,
+            'num_executions' : len(position.get_executions()),
+            'filled_amount' : position.filled_amount,
+            'average_cost' : position.average_cost,
+            'pos' : position.pos,
+            'done' : position.done
+        }
+        dispatch_notification(title=f"{param['current_filename']} {param['gateway_id']} execute_one_position done. {position.ticker} {position.side} {position.amount}", message=notification_summary, footer=param['notification']['footer'], params=notification_params, log_level=LogLevel.CRITICAL, logger=logger)
 
     except Exception as position_execution_err:
-        position.done = False
-        position.execution_err = f"Execution failed: {position_execution_err} {str(sys.exc_info()[0])} {str(sys.exc_info()[1])} {traceback.format_exc()}"
+        err_msg = f"Execution failed: {position_execution_err} {str(sys.exc_info()[0])} {str(sys.exc_info()[1])} {traceback.format_exc()}"
+        log(f"Execution failed: {err_msg}")
 
+        dispatch_notification(title=f"{param['current_filename']} {param['gateway_id']} execute_one_position failed!!! {position.ticker} {position.side} {position.amount}", message=position.get_executions(), footer=param['notification']['footer'], params=notification_params, log_level=LogLevel.ERROR, logger=logger) # type: ignore
+
+        position.done = False
+        position.execution_err = err_msg
+        
 async def work(
     param : Dict,
     exchange : AnyExchange,
@@ -788,7 +850,7 @@ async def work(
                                         reduce_only=order['reduce_only'],
                                         fees_ccy=order['fees_ccy'] if 'fees_ccy' in order else param['default_fees_ccy'],
                                         slices=order['slices'],
-                                        wait_fill_threshold_ms=order['wait_fill_threshold_ms']
+                                        wait_fill_threshold_ms=order['wait_fill_threshold_ms'] if order['wait_fill_threshold_ms']>0 else param['wait_fill_threshold_ms']
                                     )
                                     for order in orders
                                 ]
@@ -800,7 +862,7 @@ async def work(
 
                                 i = 0
                                 for position in positions:
-                                    log(f"{i} {position.ticker}, {position.side} # executions: {len(position.get_executions())}, filled_amount: {position.filled_amount}, average_cost: {position.average_cost}, pos: {position.pos}, order_dispatch_elapsed_ms: {order_dispatch_elapsed_ms}")
+                                    log(f"{i} {position.ticker}, {position.side} # executions: {len(position.get_executions())}, filled_amount: {position.filled_amount}, average_cost: {position.average_cost}, pos: {position.pos}, done: {position.done}, error: {position.execution_err}, order_dispatch_elapsed_ms: {order_dispatch_elapsed_ms}")
                                     i += 1
 
                                 start = time.time()
@@ -826,7 +888,7 @@ async def work(
         except Exception as loop_error:
             log(f"Error: {loop_error} {str(sys.exc_info()[0])} {str(sys.exc_info()[1])} {traceback.format_exc()}")
         finally:
-            await asyncio.sleep(int(param['loop_freq_ms']/1000))
+            await asyncio.sleep(param['loop_freq_ms']/1000)
 
 async def main():
     parse_args()
@@ -880,7 +942,7 @@ async def main():
         # Once exchange instantiated, try fetch_balance to confirm connectivity and test credentials.
         balances = await exchange.fetch_balance() # type: ignore
         log(f"{param['gateway_id']}: account balances {balances}")
-        notification_util.dispatch_notification(title=f"{param['gateway_id']} started", message=balances, footer=param['notification']['footer'], params=notification_params, log_level=LogLevel.CRITICAL)
+        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)
 
         await work(param=param, exchange=exchange, redis_client=redis_client, notification_params=notification_params)
 

siglab_py/tests/integration/market_data_util_tests.py

@@ -100,7 +100,7 @@ class MarketDataUtilTests(unittest.TestCase):
                 'defaultType': 'swap'            }
         }
 
-        exchange : Exchange = okx(param)
+        exchange : Exchange = okx(param) # type: ignore
         normalized_symbols = [ 'BTC/USDT:USDT' ]
         pd_candles: Union[pd.DataFrame, None] = fetch_candles(
             start_ts=start_date.timestamp(),

siglab_py/tests/unit/analytic_util_tests.py

@@ -49,7 +49,9 @@ class AnalyticUtilTests(unittest.TestCase):
             'week_of_month', 'apac_trading_hr', 'emea_trading_hr', 'amer_trading_hr', 
             'is_green', 'pct_change_close', 
             'sma_short_periods', 'sma_long_periods', 'ema_short_periods', 'ema_long_periods', 'ema_close', 
-            'std', 'std_percent', 'candle_height_percent', 'candle_height_percent_rounded', 
+            'std', 'std_percent', 
+            'candle_height_percent', 'candle_height_percent_rounded', 
+            'log_return', 'interval_historical_volatility',
             'chop_against_ema', 
             'ema_volume_short_periods', 'ema_volume_long_periods', 
             'max_short_periods', 'max_long_periods', 'idmax_short_periods', 'idmax_long_periods', 'min_short_periods', 'min_long_periods', 'idmin_short_periods', 'idmin_long_periods', 

siglab_py/tests/unit/trading_util_tests.py

@@ -0,0 +1,60 @@
+import unittest
+from datetime import datetime, timedelta
+from typing import Union
+from pathlib import Path
+
+from util.trading_util import *
+
+
+# @unittest.skip("Skip all integration tests.")
+class TradingUtilTests(unittest.TestCase):
+    def test_timestamp_to_active_trading_regions_case1(self):
+        tp_min_percent : float = 1.5
+        tp_max_percent : float = 2.5
+        sl_percent_trailing : float = 50 # Trailing stop loss in percent
+        default_effective_sl_percent_trailing : float = 50
+
+        pnl_percent_notional : float = 0.5 # Trade's current pnl in percent.
+
+        effective_tp_trailing_percent = calc_eff_trailing_sl(
+            tp_min_percent = tp_min_percent,
+            tp_max_percent = tp_max_percent,
+            sl_percent_trailing = sl_percent_trailing,
+            pnl_percent_notional = pnl_percent_notional,
+            default_effective_sl_percent_trailing = default_effective_sl_percent_trailing
+        )
+        assert(effective_tp_trailing_percent==50) # Generous trailing SL when trading starting out and pnl small.
+
+    def test_timestamp_to_active_trading_regions_case2(self):
+        tp_min_percent : float = 1.5
+        tp_max_percent : float = 2.5
+        sl_percent_trailing : float = 50 # Trailing stop loss in percent
+        default_effective_sl_percent_trailing : float = 50
+
+        pnl_percent_notional : float = 2 # Trade's current pnl in percent.
+
+        effective_tp_trailing_percent = calc_eff_trailing_sl(
+            tp_min_percent = tp_min_percent,
+            tp_max_percent = tp_max_percent,
+            sl_percent_trailing = sl_percent_trailing,
+            pnl_percent_notional = pnl_percent_notional,
+            default_effective_sl_percent_trailing = default_effective_sl_percent_trailing
+        )
+        assert(effective_tp_trailing_percent==25) # Intermediate trailing SL
+
+    def test_timestamp_to_active_trading_regions_case3(self):
+        tp_min_percent : float = 1.5
+        tp_max_percent : float = 2.5
+        sl_percent_trailing : float = 50 # Trailing stop loss in percent
+        default_effective_sl_percent_trailing : float = 50
+
+        pnl_percent_notional : float = 2.5 # Trade's current pnl in percent.
+
+        effective_tp_trailing_percent = calc_eff_trailing_sl(
+            tp_min_percent = tp_min_percent,
+            tp_max_percent = tp_max_percent,
+            sl_percent_trailing = sl_percent_trailing,
+            pnl_percent_notional = pnl_percent_notional,
+            default_effective_sl_percent_trailing = default_effective_sl_percent_trailing
+        )
+        assert(effective_tp_trailing_percent==0) # Most tight trailing SL

siglab_py/util/analytic_util.py

@@ -101,9 +101,25 @@ def compute_candles_stats(
     pd_candles['std'] = pd_candles['close'].rolling(window=sliding_window_how_many_candles).std()
 
     pd_candles['std_percent'] = pd_candles['std'] / pd_candles['ema_close'] * 100
+
     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')
 
+    '''
+    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
+        )
+    '''
+    pd_candles['log_return'] = np.log(pd_candles['close'] / pd_candles['close'].shift(1))
+    pd_candles['interval_historical_volatility'] = pd_candles['log_return'].rolling(window=sliding_window_how_many_candles).std()
+
     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

siglab_py/util/notification_util.py

@@ -1,10 +1,11 @@
 import json
 from typing import Any, Dict, Union
+from datetime import datetime, timezone
 import pandas as pd
 import numpy as np
 from tabulate import tabulate
 
-from siglab_py.util import slack_notification_util
+from util.slack_notification_util import slack_dispatch_notification
 
 from siglab_py.constants import LogLevel
 
@@ -13,16 +14,24 @@ def dispatch_notification(
         message : Union[str, Dict, pd.DataFrame],
         footer : str,
         params : Dict[str, Any],
-        log_level : LogLevel = LogLevel.INFO
+        log_level : LogLevel = LogLevel.INFO,
+        logger = None
         ):
-    if isinstance(message, Dict):
-        _message = json.dumps(message, indent=2, separators=(' ', ':'))
-    elif isinstance(message, pd.DataFrame):
-        _message = tabulate(message, headers='keys', tablefmt='orgtbl') # type: ignore
-    else:
-        _message = message
+    try:
+        if isinstance(message, Dict):
+            _message = json.dumps(message, indent=2, separators=(' ', ':'))
+        elif isinstance(message, pd.DataFrame):
+            _message = tabulate(message, headers='keys', tablefmt='orgtbl') # type: ignore
+        else:
+            _message = message
 
-    slack_notification_util.slack_dispatch_notification(title, _message, footer, params, log_level)
+        utc_time = datetime.now(timezone.utc)
+        footer = f"UTC {utc_time} {footer}"
+
+        slack_dispatch_notification(title, _message, footer, params, log_level)
+    except Exception as any_notification_error:
+        if logger:
+            logger.info(f"Failed to dispatch notification: {any_notification_error}")
 
 if __name__ == '__main__':
     params : Dict[str, Any] = {

siglab_py/util/slack_notification_util.py

@@ -13,15 +13,19 @@ def slack_dispatch_notification(
         message : str,
         footer : str,
         params : Dict[str, Any],
-        log_level : LogLevel = LogLevel.INFO
+        log_level : LogLevel = LogLevel.INFO,
+        max_message_len : int = 1800
 ):
     slack_params = params['slack']
 
-    if log_level==LogLevel.INFO or log_level==LogLevel.DEBUG:
+    # Slack slack ... https://stackoverflow.com/questions/60344831/slack-api-invalid-block
+    message = message[:max_message_len]
+
+    if log_level.value==LogLevel.INFO.value or log_level.value==LogLevel.DEBUG.value:
         webhook_url = slack_params['info']['webhook_url']
-    elif log_level==LogLevel.CRITICAL:
+    elif log_level.value==LogLevel.CRITICAL.value:
         webhook_url = slack_params['critical']['webhook_url']
-    elif log_level==LogLevel.ERROR:
+    elif log_level.value==LogLevel.ERROR.value:
         webhook_url = slack_params['alert']['webhook_url']
     else:
         webhook_url = slack_params['info']['webhook_url']
@@ -30,7 +34,7 @@ def slack_dispatch_notification(
         return
 
     data = {
-        "username": "x",
+        "username": "siglab_py",
         "type": "section",
         "blocks": [
             {

siglab_py/util/trading_util.py

@@ -0,0 +1,66 @@
+
+'''
+pnl_percent_notional = Trade's current pnl in percent.
+
+Examples,
+    y-axis:
+        max (i.e most tight) = 0%
+        sl_percent_trailing = 50% (Trailing stop loss in percent)
+
+    x-axis:
+        min TP = 1.5% <-- min TP
+        max TP = 2.5% <-- max TP
+
+    slope = (0-50)/(2.5-1.5) = -50
+    effective_tp_trailing_percent = slope * (pnl_percent_notional - 1.5%) + sl_percent_trailing
+
+Case 1. pnl_percent_notional = 0.5% (Trade starting off, only +50bps pnl. i.e. min TP)
+            effective_tp_trailing_percent = slope * (pnl_percent_notional - 0.5%) + sl_percent_trailing
+                                            = -50 * (1.5-1.5) + 50%
+                                            = 0 + 50
+                                            = 50% (Most loose)
+
+Case 2. pnl_percent_notional = 2% (Deeper into profit, +200bps pnl)
+            effective_tp_trailing_percent = slope * (pnl_percent_notional - 1.5%) + sl_percent_trailing
+                                            = -50 * (2-1.5) +50%
+                                            = -25 + 50
+                                            = 25% (Somewhat tight)
+
+Case 3. pnl_percent_notional = 2.5% (Very deep in profit, +250bps pnl. i.e. max TP)
+            effective_tp_trailing_percent = slope * (pnl_percent_notional - 1.5%) + sl_percent_trailing
+                                            = -50 * (2.5-1.5) +50%
+                                            = -50 + 50
+                                            = 0 (Most tight)
+
+So you see, effective_tp_trailing_percent gets smaller and smaller as pnl approach max TP, finally zero.
+
+How to use it?
+    if loss_trailing>=effective_tp_trailing_percent and pnl_percent_notional > tp_min_percent:
+            Fire trailing stops and take profit.
+
+What's 'loss_trailing'? 'loss_trailing' is essentially pnl drop from max_unrealized_pnl_live.
+
+    Say, when trade started off:
+        unrealized_pnl_live = $80
+        max_unrealized_pnl_live = $100
+        loss_trailing = (1 - unrealized_pnl_live/max_unrealized_pnl_live) = (1-80/100) = 0.2 (Or 20%)
+
+    If pnl worsen:
+        unrealized_pnl_live = $40
+        max_unrealized_pnl_live = $100
+        loss_trailing = (1 - unrealized_pnl_live/max_unrealized_pnl_live) = (1-40/100) = 0.6 (Or 60%)
+'''
+def calc_eff_trailing_sl(
+        tp_min_percent : float,
+        tp_max_percent : float,
+        sl_percent_trailing : float,
+        pnl_percent_notional : float,
+        default_effective_sl_percent_trailing : float = 50
+) -> float:
+    slope = (0 - sl_percent_trailing) / (tp_max_percent - tp_min_percent)
+    effective_sl_percent_trailing = (
+                                        slope * (pnl_percent_notional - tp_min_percent) + sl_percent_trailing 
+                                        if pnl_percent_notional>tp_min_percent 
+                                        else default_effective_sl_percent_trailing
+                                    )
+    return effective_sl_percent_trailing

{siglab_py-0.2.8.dist-info → siglab_py-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: siglab-py
-Version: 0.2.8
+Version: 0.3.0
 Summary: Market data fetches, TA calculations and generic order gateway.
 Author: r0bbarh00d
 Author-email: r0bbarh00d <r0bbarh00d@gmail.com>

{siglab_py-0.2.8.dist-info → siglab_py-0.3.0.dist-info}/RECORD

@@ -15,22 +15,24 @@ siglab_py/market_data_providers/test_provider.py,sha256=wBLCgcWjs7FGZJXWsNyn30lk
 siglab_py/ordergateway/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 siglab_py/ordergateway/client.py,sha256=EwoVKxEcngIs8-b4MThPBdZfFIWJg1OFAKG9bwC5BYw,14826
 siglab_py/ordergateway/encrypt_keys_util.py,sha256=-qi87db8To8Yf1WS1Q_Cp2Ya7ZqgWlRqSHfNXCM7wE4,1339
-siglab_py/ordergateway/gateway.py,sha256=k1VM02F94gRORj6l0GFTrtPnUMXvFkEDxmEZqXZSI-E,41691
+siglab_py/ordergateway/gateway.py,sha256=mRakbgT1SPH1KPGw3_NdOQzbg_mMP2QbK4tSaLHiXWU,45892
 siglab_py/ordergateway/test_ordergateway.py,sha256=4PE2flp_soGcD3DrI7zJOzZndjkb6I5XaDrFNNq4Huo,4009
 siglab_py/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 siglab_py/tests/integration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-siglab_py/tests/integration/market_data_util_tests.py,sha256=X0CiSMDfsafKcmjVKknA03vUUbMV0fAZweb3D01ikYI,7174
+siglab_py/tests/integration/market_data_util_tests.py,sha256=p-RWIJZLyj0lAdfi4QTIeAttCm_e8mEVWFKh4OWuogU,7189
 siglab_py/tests/unit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-siglab_py/tests/unit/analytic_util_tests.py,sha256=BzT__hxfqXMRAKvqtYDVYNrcMGGDF3-gFoXhxiJ0Lew,3703
+siglab_py/tests/unit/analytic_util_tests.py,sha256=gkhapr6Xemq5lq-EjS3Cq-NzH_O2H6E3lFvGIFHsdMg,3778
 siglab_py/tests/unit/market_data_util_tests.py,sha256=A1y83itISmMJdn6wLpfwcr4tGola8wTf1D1xbelMvgw,2026
+siglab_py/tests/unit/trading_util_tests.py,sha256=T1IejsEVmGP2hU9F0RzgGITbNKih0jW44UVna0g1aYs,2689
 siglab_py/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-siglab_py/util/analytic_util.py,sha256=o9MNuOWUhw-r0id10Wjjd7a6rkL6-g3OmvajMSj1JJ4,43838
+siglab_py/util/analytic_util.py,sha256=rFfZsL-qsqL_FgN7zPRL3rQtBe_9Kglh8Linjv-30VM,44600
 siglab_py/util/aws_util.py,sha256=KGmjHrr1rpnnxr33nXHNzTul4tvyyxl9p6gpwNv0Ygc,2557
 siglab_py/util/market_data_util.py,sha256=9Uze8DE5z90H4Qm15R55ZllAi5trUkwCAW-BWYbfaW8,19420
-siglab_py/util/notification_util.py,sha256=6TPyStp-F6g_NTN-sVG18_o35agV6tjayNtJ0A4axyk,2311
+siglab_py/util/notification_util.py,sha256=vySgHjpHgwFDLW0tHSi_AGh9JBbPc25IUgvWxmjAeT8,2658
 siglab_py/util/retry_util.py,sha256=mxYuRFZRZoaQQjENcwPmxhxixtd1TFvbxIdPx4RwfRc,743
-siglab_py/util/slack_notification_util.py,sha256=sHiSKTzeF8tdoqN9l3a8CtU4dn3sWsyBOZPBzO0L9wQ,1682
-siglab_py-0.2.8.dist-info/METADATA,sha256=7xpPcvd-2nRSlQaA5iBcmdpSbzbD56CwAgUJ6E2ehVE,979
-siglab_py-0.2.8.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-siglab_py-0.2.8.dist-info/top_level.txt,sha256=AbD4VR9OqmMOGlMJLkAVPGQMtUPIQv0t1BF5xmcLJSk,10
-siglab_py-0.2.8.dist-info/RECORD,,
+siglab_py/util/slack_notification_util.py,sha256=G27n-adbT3Q6oaHSMvu_Nom794rrda5PprSF-zvmzkM,1912
+siglab_py/util/trading_util.py,sha256=VyxcGkKg1kzR1F_ACNyBeYPKKmVYjWrKRYrfxyGH2og,3038
+siglab_py-0.3.0.dist-info/METADATA,sha256=lCAwa_JFHMWiNYNFd1XKc94BMPgzw8xFTK3K70vJ7vQ,979
+siglab_py-0.3.0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+siglab_py-0.3.0.dist-info/top_level.txt,sha256=AbD4VR9OqmMOGlMJLkAVPGQMtUPIQv0t1BF5xmcLJSk,10
+siglab_py-0.3.0.dist-info/RECORD,,