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

siglab_py/util/module_util.py

@@ -0,0 +1,40 @@
+import os
+import glob
+import importlib.util
+import inspect
+
+def load_module_class(strategy_name: str):
+    if not strategy_name:
+        return None
+
+    caller_frame = inspect.stack()[1] # [0] = here, [1] = direct caller
+    caller_file = caller_frame.filename
+    folder = os.path.dirname(caller_file)
+    print(f"folder searched: {folder}")
+
+    pattern = os.path.join(folder, "*.py")
+
+    for filepath in glob.glob(pattern):
+        filename = os.path.basename(filepath)
+        print(f"filename: {filename}")
+        
+        if filename.startswith('_') or filename == 'strategy_executor.py':
+            continue
+
+        module_name = filename[:-3]
+
+        try:
+            spec = importlib.util.spec_from_file_location(module_name, filepath)
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+
+            if hasattr(module, strategy_name):
+                cls = getattr(module, strategy_name)
+                if isinstance(cls, type):
+                    print(f"Loaded strategy: {strategy_name} from {filename}")
+                    return cls
+        except Exception as e:
+            print(f"Skipping {filename} – error: {e}")
+
+    print(f"{strategy_name} not found.")
+    return None

siglab_py/util/notification_util.py

@@ -0,0 +1,78 @@
+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.slack_notification_util import slack_dispatch_notification
+
+from siglab_py.constants import LogLevel
+
+def dispatch_notification(
+        title : str,
+        message : Union[str, Dict, pd.DataFrame],
+        footer : str,
+        params : Dict[str, Any],
+        log_level : LogLevel = LogLevel.INFO,
+        logger = None
+        ):
+    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
+
+        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 for {str(title)}: {any_notification_error}")
+
+if __name__ == '__main__':
+    params : Dict[str, Any] = {
+        "slack" : {
+            "info" : {
+                "webhook_url" : "https://hooks.slack.com/services/xxx"
+            },
+            "critical" : {
+                "webhook_url" : "https://hooks.slack.com/services/xxx"
+            },
+            "alert" : {
+                "webhook_url" : "https://hooks.slack.com/services/xxx"
+            }
+      },
+    }
+
+    log_level : LogLevel = LogLevel.CRITICAL
+
+    title : str = "Test message"
+    footer : str = "... some footer .."
+
+    message1 : str = "Testing 1"
+    dispatch_notification(title=title, message=message1, footer=footer, params=params, log_level=log_level)
+
+    message2 : Dict[str, Any] = {
+        'aaa' : 123,
+        'bbb' : 456,
+        'ccc' : {
+            'ddd' : 789
+        }
+    }
+    dispatch_notification(title=title, message=message2, footer=footer, params=params, log_level=log_level)
+
+    start_date = pd.to_datetime('2024-01-01 00:00:00')
+    datetimes = pd.date_range(start=start_date, periods=20, freq='H')
+    np.random.seed(42)
+    close_prices = np.random.uniform(80000, 90000, size=20).round(2)
+    data : pd.DataFrame = pd.DataFrame({
+        'datetime': datetimes,
+        'close': close_prices
+    })
+    data['timestamp_ms'] = data['datetime'].astype('int64')
+    message3 = data
+    dispatch_notification(title=title, message=message3, footer=footer, params=params, log_level=log_level)

siglab_py/util/retry_util.py

@@ -1,15 +1,28 @@
-def retry(num_attempts : int = 1):
+import time
+
+def retry(
+        num_attempts : int = 1,
+        pause_between_retries_ms : int = 1000,
+        logger = None
+        ):
     def decorator(method):
         def wrapper(*args, **kw):
             for i in range(num_attempts):
                 try:
                     result = method(*args, **kw)
                     if i>0:
-                        print(f"retry_gizmo.retry succeeded: {method.__name__} on #{i+1} invocation. {args} {kw}")
+                        print(f"retry_util.retry done {method.__name__} on #{i+1} call. {args} {kw}")
                     return result
                 except Exception as retry_error:
                     if i==(num_attempts-1):
-                        err_msg = f"retry_gizmo.retry failed: {method.__name__} after {num_attempts} invocations. {args} {kw}. {retry_error}"
+                        err_msg = f"retry_util.retry gave up {method.__name__} after {num_attempts} calls. {args} {kw}. {retry_error}"
+                        if logger:
+                            logger.error(err_msg)
+                        else:
+                            print(err_msg)
                         raise Exception(err_msg) from retry_error
+                finally:
+                    time.sleep(int(pause_between_retries_ms/1000))
+                    
         return wrapper
     return decorator

siglab_py/util/simple_math.py

@@ -0,0 +1,262 @@
+import math
+import random
+from typing import List, Dict, Union
+
+from pandas import isna
+
+def generate_rand_nums(
+        range_min : float = 0,
+        range_max : float = 1,
+        size=100, # list size
+        percent_in_range : float = 100,
+        abs_min : float = 0,
+        abs_max : float = 1
+    ) -> List[float]:
+    assert(range_min<range_max)
+
+    if abs_min>range_min:
+        abs_min = range_min
+    if abs_max<range_max:
+        abs_max = range_max
+
+    result : List[float] = []
+    for _ in range(int(size * percent_in_range/100)):
+        result.append(random.uniform(range_min, range_max))
+    for _ in range(size - len(result)):
+        if random.uniform(0, 1)>0.5:
+            result.append(random.uniform(abs_min, range_min))
+        else:
+            result.append(random.uniform(range_max, abs_max))
+    
+    random.shuffle(result)
+
+    return result
+
+def compute_level_increment(
+    num : float,
+    level_granularity : float = 0.01
+) -> float:
+    if math.isnan(num):
+        return num
+    level_size = num * level_granularity
+    magnitude = math.floor(math.log10(abs(level_size)))
+    base_increment = 10 ** magnitude
+    rounded_level_size = round(level_size / base_increment) * base_increment
+    return rounded_level_size
+
+# https://norman-lm-fung.medium.com/levels-are-psychological-7176cdefb5f2
+def round_to_level(
+            num : float,
+            level_granularity : float = 0.01
+        ) -> float:
+    if math.isnan(num):
+        return num
+    rounded_level_size = compute_level_increment(num, level_granularity)
+    rounded_num = round(num / rounded_level_size) * rounded_level_size
+    return rounded_num
+
+def compute_adjacent_levels(
+            num : float,
+            level_granularity : float = 0.01,
+            num_levels_per_side : int = 1
+        ) -> Union[None, List[float]]:
+    if math.isnan(num):
+        return None
+    rounded_level_size = compute_level_increment(num, level_granularity)
+    rounded_num = round(num / rounded_level_size) * rounded_level_size
+    levels = [ rounded_num ]
+    levels = list(reversed([ rounded_num - (i+1)*rounded_level_size for i in list(range(num_levels_per_side))])) + levels + [ rounded_num + (i+1)*rounded_level_size for i in list(range(num_levels_per_side))]
+    return levels
+
+def bucket_series(
+    values : List[float],
+    outlier_threshold_percent : float = 0,
+    level_granularity : float = 0.1 # 0.1 = 10%
+) -> Dict[
+            str, 
+            Dict[str,Union[float, List[float]]]
+        ]:
+    buckets : Dict[
+            str, 
+            Dict[str,Union[float, List[float]]]
+        ] = {}
+    list_0_to_1 : bool = True if len([x for x in values if x<0 or x>1])/len(values)*100 <= outlier_threshold_percent else False
+    list_m1_to_1 : bool = True if len([x for x in values if x<-1 or x>1])/len(values)*100 <= outlier_threshold_percent else False
+    
+    list_0_to_100 : bool = True if len([x for x in values if x<0 or x>100])/len(values)*100 <= outlier_threshold_percent else False
+    if (
+        list_0_to_100
+        and (
+            not min(values)<100*(outlier_threshold_percent/100) or not max(values)>100*(1-outlier_threshold_percent/100)
+        )
+    ):
+        list_0_to_100 = False
+    list_m100_to_100 : bool = True if len([x for x in values if x<-100 or x>100])/len(values)*100 <= outlier_threshold_percent else False
+    if (
+        list_m100_to_100
+        and (
+            not min(values)<-100*(1-outlier_threshold_percent/100) or not max(values)>100*(1-outlier_threshold_percent/100)
+        )
+    ):
+        list_m100_to_100 = False
+
+    def _generate_sequence(start, stop, step):
+        result = []
+        current = start
+        num_steps = int((stop - start) / step) + 1
+        for i in range(num_steps):
+            result.append(round(start + i * step, 10))
+        return result
+
+    if list_0_to_1:
+        step = round_to_level(
+                1 * level_granularity,
+                level_granularity=level_granularity
+            )
+        intervals = _generate_sequence(0.1, 1, step)
+        last_interval = 0
+        buckets[f"< 0"] = {
+            'min' : float("-inf"),
+            'max' : 0,
+            'values' : [ x for x in values if x<0 ]
+        }
+        for interval in intervals:
+            buckets[f"{last_interval} - {interval}"] = {
+                'min' : last_interval,
+                'max' : interval,
+                'values' : [ x for x in values if x>=last_interval and x<interval ]
+            }
+            last_interval = interval
+        buckets[f">1"] = {
+                'min' : last_interval,
+                'max' : float("inf"),
+                'values' : [ x for x in values if x>=1 ]
+        }
+    
+    elif not list_0_to_1 and list_m1_to_1:
+        step = round_to_level(
+                1 * level_granularity,
+                level_granularity=level_granularity
+            )
+        intervals = _generate_sequence(-0.9, 1, step)
+        last_interval = -1
+        buckets[f"< -1"] = {
+            'min' : float("-inf"),
+            'max' : -1,
+            'values' : [ x for x in values if x<-1 ]
+        }
+        for interval in intervals:
+            buckets[f"{last_interval} - {interval}"] = {
+                'min' : last_interval,
+                'max' : interval,
+                'values' : [ x for x in values if x>=last_interval and x<interval ]
+            }
+            last_interval = interval
+        buckets[f">1"] = {
+                'min' : last_interval,
+                'max' : float("inf"),
+                'values' : [ x for x in values if x>=1 ]
+        }
+
+    elif not list_0_to_1 and not list_m1_to_1 and list_0_to_100:
+        step = round_to_level(
+                100 * level_granularity,
+                level_granularity=level_granularity
+            )
+        intervals = _generate_sequence(10, 100, step)
+        last_interval = 0
+        buckets[f"<0"] = {
+            'min' : float("-inf"),
+            'max' : 0,
+            'values' : [ x for x in values if x<0 ]
+        }
+        for interval in intervals:
+            buckets[f"{last_interval} - {interval}"] = {
+                'min' : last_interval,
+                'max' : interval,
+                'values' : [ x for x in values if x>=last_interval and x<interval ]
+            }
+            last_interval = interval
+        buckets[f">100"] = {
+                'min' : last_interval,
+                'max' : float("inf"),
+                'values' : [ x for x in values if x>=100 ]
+        }
+
+    elif not list_0_to_1 and not list_m1_to_1 and not list_0_to_100 and list_m100_to_100:
+        step = round_to_level(
+                100 * level_granularity,
+                level_granularity=level_granularity
+            )
+        intervals = _generate_sequence(-90, 100, step)
+        last_interval = -100
+        buckets[f"<-100"] = {
+            'min' : float("-inf"),
+            'max' : -100,
+            'values' : [ x for x in values if x<-100 ]
+        }
+        for interval in intervals:
+            buckets[f"{last_interval} - {interval}"] = {
+                'min' : last_interval,
+                'max' : interval,
+                'values' : [ x for x in values if x>=last_interval and x<interval ]
+            }
+            last_interval = interval
+        buckets[f">100"] = {
+                'min' : last_interval,
+                'max' : float("inf"),
+                'values' : [ x for x in values if x>=100 ]
+        }
+
+    else:
+        range_min = round_to_level(
+            min(values),
+            level_granularity=level_granularity
+            )
+        range_max = round_to_level(
+            max(values),
+            level_granularity=level_granularity
+            )
+        step = round_to_level(
+                abs(range_max - range_min) * level_granularity,
+                level_granularity=level_granularity
+            )
+        
+        intervals = _generate_sequence(range_min+step, range_max, step)
+        last_interval = range_min
+        buckets[f"< {range_min}"] = {
+            'min' : float("-inf"),
+            'max' : range_min,
+            'values' : [ x for x in values if x<range_min ]
+        }
+        for interval in intervals:
+            buckets[f"{last_interval} - {interval}"] = {
+                'min' : last_interval,
+                'max' : interval,
+                'values' : [ x for x in values if x>=last_interval and x<interval ]
+            }
+            last_interval = interval
+        buckets[f"> {range_max}"] = {
+                'min' : last_interval,
+                'max' : float("inf"),
+                'values' : [ x for x in values if x>=range_max ]
+        }
+
+    for key in buckets:
+        bucket = buckets[key]
+        assert(len([x for x in bucket['values'] if x<bucket['min'] or x>bucket['max']])==0) # type: ignore
+
+    return buckets
+
+def bucketize_val(
+            x : float,
+            buckets : Dict[
+            str, 
+            Dict[str,Union[float, List[float]]]
+        ]
+    ) -> Union[str,None]:
+        for key in buckets:
+            bucket = buckets[key]
+            if x>=bucket['min'] and x<=bucket['max']: # type: ignore
+                return key
+        return None

siglab_py/util/slack_notification_util.py

@@ -0,0 +1,59 @@
+'''
+https://medium.com/@natalia_assad/how-send-a-table-to-slack-using-python-d1a20b08abe0
+'''
+import sys
+from typing import Any, Dict
+import json
+import requests
+
+from siglab_py.constants import LogLevel
+
+def slack_dispatch_notification(
+        title : str,
+        message : str,
+        footer : str,
+        params : Dict[str, Any],
+        log_level : LogLevel = LogLevel.INFO,
+        max_message_len : int = 1800
+):
+    slack_params = params['slack']
+
+    # 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.value==LogLevel.CRITICAL.value:
+        webhook_url = slack_params['critical']['webhook_url']
+    elif log_level.value==LogLevel.ERROR.value:
+        webhook_url = slack_params['alert']['webhook_url']
+    else:
+        webhook_url = slack_params['info']['webhook_url']
+
+    if not webhook_url:
+        return
+
+    data = {
+        "username": "siglab_py",
+        "type": "section",
+        "blocks": [
+            {
+                "type": "header",
+                "text": { "type": "plain_text", "text": f"{title}" }
+            },
+            {
+                "type": "section",
+                "text": { "type": "mrkdwn", "text": message }
+            },
+            {
+                "type": "section",
+                "text": { "type": "plain_text", "text": footer }
+            }
+        ]
+    }
+
+    byte_size = str(sys.getsizeof(data, 2000))
+    req_headers = { 'Content-Length': byte_size, 'Content-Type': "application/json"}
+    rsp = requests.post(webhook_url, headers=req_headers, data=json.dumps(data))
+    if rsp.status_code != 200:
+        raise Exception(rsp.status_code, rsp.text)

siglab_py/util/trading_util.py

@@ -0,0 +1,118 @@
+import math
+
+'''
+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/+1 = -50
+    effective_tp_trailing_percent = slope * (pnl_percent_notional - 1.5%) + sl_percent_trailing
+
+Case 1. pnl_percent_notional = 1.5% (Trade starting off, only +50bps pnl. i.e. min TP)
+            effective_tp_trailing_percent = slope * (pnl_percent_notional - 1.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%)
+
+Have a look at this for a visual explaination how "Gradually tightened stops" works:
+    https://github.com/r0bbar/siglab/blob/master/siglab_py/tests/manual/trading_util_tests.ipynb
+    https://norman-lm-fung.medium.com/gradually-tightened-trailing-stops-f7854bf1e02b
+'''
+def calc_eff_trailing_sl(
+        tp_min_percent : float,
+        tp_max_percent : float,
+        sl_percent_trailing : float,
+        pnl_percent_notional : float,
+        default_effective_tp_trailing_percent : float = float('inf'), # inf: essentially saying, don't fire off trailing stop.
+        linear : bool = True,
+        pow : float = 5 # This is for non-linear trailing stops
+) -> float:
+    if pnl_percent_notional>tp_max_percent:
+        return 0
+    if pnl_percent_notional<tp_min_percent:
+         return default_effective_tp_trailing_percent
+    
+    if linear:
+        slope = (0 - sl_percent_trailing) / (tp_max_percent - tp_min_percent)
+        effective_tp_trailing_percent = (
+                                            slope * (pnl_percent_notional - tp_min_percent) + sl_percent_trailing 
+                                            if pnl_percent_notional>=tp_min_percent 
+                                            else default_effective_tp_trailing_percent
+                                        )
+    else:    
+        def y(
+				x : float,
+				x_shift : float,
+				pow : float
+				) -> float:
+            return -1 * ( (x+x_shift)**pow)
+        
+        y_min = y(
+												x=tp_min_percent,
+												x_shift=tp_min_percent,
+												pow=pow
+												)
+        y_max = y(
+												x=tp_max_percent,
+												x_shift=tp_min_percent,
+												pow=pow
+												)
+        y_shift = abs(y_max) - abs(y_min)
+        
+        if y_shift!=0:
+            y_normalized = y(
+                                                        x=pnl_percent_notional,
+                                                        x_shift=tp_min_percent,
+                                                        pow=pow
+                                                    ) / y_shift
+            effective_tp_trailing_percent = (
+                                                y_normalized * sl_percent_trailing + sl_percent_trailing
+                                                if pnl_percent_notional>=tp_min_percent 
+                                                else default_effective_tp_trailing_percent
+                                            )
+        else:
+            '''
+            y_shift = 0 when tp_max_percent==tp_min_percent.
+            If default_effective_tp_trailing_percent==float('inf'), essentially it means trailing stops won't fire.
+            Client side needs handle this.
+            '''
+            effective_tp_trailing_percent = default_effective_tp_trailing_percent
+
+    return effective_tp_trailing_percent

{siglab_py-0.1.19.dist-info → siglab_py-0.6.33.dist-info}/METADATA

@@ -1,22 +1,19 @@
-Metadata-Version: 2.1
-Name: siglab-py
-Version: 0.1.19
+Metadata-Version: 2.4
+Name: siglab_py
+Version: 0.6.33
 Summary: Market data fetches, TA calculations and generic order gateway.
 Author: r0bbarh00d
 Author-email: r0bbarh00d <r0bbarh00d@gmail.com>
 License: MIT
 Project-URL: Homepage, https://github.com/r0bbar/siglab/blob/master/siglab_py/README.md
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9.19
 Description-Content-Type: text/markdown
 Requires-Dist: python-dotenv
 Requires-Dist: dotmap
-Requires-Dist: typing-extensions
+Requires-Dist: typing_extensions
 Requires-Dist: arrow
 Requires-Dist: tzlocal
-Requires-Dist: nest-asyncio
+Requires-Dist: nest_asyncio
 Requires-Dist: pandas
 Requires-Dist: numpy
 Requires-Dist: boto3
@@ -25,12 +22,7 @@ Requires-Dist: ccxt
 Requires-Dist: ccxtpro
 Requires-Dist: yfinance
 Requires-Dist: yahoofinancials
-Requires-Dist: scipy
-Requires-Dist: statsmodels
-Requires-Dist: scikit-learn
-Requires-Dist: sklearn.preprocessing
 Requires-Dist: hurst
 Requires-Dist: redis
 Requires-Dist: redis-py-cluster
 Requires-Dist: kafka-python
-