siglab-py 0.1.29__py3-none-any.whl → 0.6.12__py3-none-any.whl

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: {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,23 @@
-def retry(num_attempts : int = 1):
+import time
+
+def retry(
+        num_attempts : int = 1,
+        pause_between_retries_ms : int = 1000
+        ):
     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}"
                         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,240 @@
+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
+
+# 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
+    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
+    rounded_num = round(num / rounded_level_size) * rounded_level_size
+    return rounded_num
+
+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.29.dist-info → siglab_py-0.6.12.dist-info}/METADATA

@@ -1,22 +1,19 @@
-Metadata-Version: 2.1
-Name: siglab-py
-Version: 0.1.29
+Metadata-Version: 2.4
+Name: siglab_py
+Version: 0.6.12
 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
@@ -29,4 +26,3 @@ Requires-Dist: hurst
 Requires-Dist: redis
 Requires-Dist: redis-py-cluster
 Requires-Dist: kafka-python
-

siglab_py-0.6.12.dist-info/RECORD

@@ -0,0 +1,44 @@
+siglab_py/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+siglab_py/constants.py,sha256=RlWh0-_sXHanfPIVLgDPLNbn9ljv3aZJYMv92Zd0jZI,701
+siglab_py/exchanges/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+siglab_py/exchanges/any_exchange.py,sha256=Y-zue75ZSmu9Ga1fONbjBGLNH5pDHQI01hCSjuLBkAk,889
+siglab_py/exchanges/binance.py,sha256=3hLeU5t4AXVLS2u6V8wlqsvdo3Uh00ebgx4MONy8X6k,1394
+siglab_py/exchanges/deribit.py,sha256=gI5ezORDeu-Z1S8yxJj1Kj43OroK3ga9BckNijkuk8A,3361
+siglab_py/exchanges/futubull.py,sha256=i0jNgl9BGJvgEIDeOkTfD52FaK77vX8axCKNYwJHwSI,21144
+siglab_py/market_data_providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+siglab_py/market_data_providers/aggregated_orderbook_provider.py,sha256=FZRobEBNRzcNGlOG3u38OVhmOZYlkNm8dVvR-S7Ii2g,23342
+siglab_py/market_data_providers/candles_provider.py,sha256=FXvciwU7ONC0VdX-fggELIl2yqd7mRB2CjDeUsDzr-A,14145
+siglab_py/market_data_providers/candles_ta_provider.py,sha256=az3tVjR4g0vhOCc8S5kGvjuNIpwxnXarUhMi62Z5Pzc,12013
+siglab_py/market_data_providers/ccxt_candles_ta_to_csv.py,sha256=DHj51QTbkCmEd9RFNVhWWpsSPz1aLd6zTLqkUUbEkK0,11158
+siglab_py/market_data_providers/deribit_options_expiry_provider.py,sha256=e9Ee8TmC8pXaid8-jouSLKIpuW6_JBBgwRTieI665yQ,8684
+siglab_py/market_data_providers/futu_candles_ta_to_csv.py,sha256=SCWlI_mOuErpGP8Kxh5WKEoff9cqqxO19oLFLd04bTs,10964
+siglab_py/market_data_providers/google_monitor.py,sha256=B08Aj1urL4M9hVUfjubVwTsFhfsj5-eFaf36lYqZ8-o,14028
+siglab_py/market_data_providers/orderbooks_provider.py,sha256=b1XgPVSTU3y0Dxm5DOKjeldK-0ZrP15_iG3fzjBBBG8,16376
+siglab_py/market_data_providers/tg_monitor.py,sha256=LY4oRm5qQ_XiuLk0RMVDc0Vdsi6CKE6O9hgeGm3VXBM,21995
+siglab_py/market_data_providers/trigger_provider.py,sha256=b9B1RSBI8bFyGsM4DVXhEY8w08iTy8sPZkTqoy72VJE,2505
+siglab_py/ordergateway/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+siglab_py/ordergateway/client.py,sha256=LvtrYirrdFOcKgTkvuqwdEN7r3nurjX320ESnk7tHE0,15095
+siglab_py/ordergateway/encrypt_keys_util.py,sha256=U_M-jPrPYOTO_sU0bMVkO5ruNXge5vek8yUGa8jaE-g,1349
+siglab_py/ordergateway/gateway.py,sha256=KAulWLZf8UYFo0esWwb4H8NmGnylkkckx4xBcF6-IZQ,47343
+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=XKO8CX9AF7xRjRvt4lb938v_s89d2IBLAXKfZDdUxdY,8705
+siglab_py/tests/unit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+siglab_py/tests/unit/analytic_util_tests.py,sha256=tV7MsItlidwqdAQ_kD1000PsG4zIoQyQY1RdOn5XQAQ,5942
+siglab_py/tests/unit/market_data_util_tests.py,sha256=A1y83itISmMJdn6wLpfwcr4tGola8wTf1D1xbelMvgw,2026
+siglab_py/tests/unit/simple_math_tests.py,sha256=rWqq93W4Vlqmu0UeZCmSOfLirr0gPh2ASVIZ8O77qXY,9653
+siglab_py/tests/unit/trading_util_tests.py,sha256=LiflZrduWXyLMbpSFQCaydA7jdJx3vFR-3KuKRRGhjQ,2927
+siglab_py/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+siglab_py/util/analytic_util.py,sha256=KoRDlesLuYKkr0V0ytJLEqaDHh6Tyfr6GhaPQYFCU2U,65225
+siglab_py/util/aws_util.py,sha256=KGmjHrr1rpnnxr33nXHNzTul4tvyyxl9p6gpwNv0Ygc,2557
+siglab_py/util/market_data_util.py,sha256=zTvOaUUF2vmwQRcpQPq0c2Ix1gFAhx22Vps9pzJsOXI,36290
+siglab_py/util/notification_util.py,sha256=tNZMUkkjz4q1CKqcQq62oEmZgHgNIwz2Iw9J22V22Zw,2668
+siglab_py/util/retry_util.py,sha256=g-UU6pkPouWZZRZEqP99R2Z0lX5xzckYkzjwqqSDpVQ,922
+siglab_py/util/simple_math.py,sha256=F7vGj0O2Y9EAGcMFR6SN1tTjBWO_a7YZeiTzk3eHaVI,8518
+siglab_py/util/slack_notification_util.py,sha256=G27n-adbT3Q6oaHSMvu_Nom794rrda5PprSF-zvmzkM,1912
+siglab_py/util/trading_util.py,sha256=dlIOzoMGnddLSFODcJ61EBH1Aeruq4IT2MsxIdFkV9I,5252
+siglab_py-0.6.12.dist-info/METADATA,sha256=J4m8p-webGGFtNwcc9s9W5sE3vZFPkkGwxYj23CLWnI,829
+siglab_py-0.6.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+siglab_py-0.6.12.dist-info/top_level.txt,sha256=AbD4VR9OqmMOGlMJLkAVPGQMtUPIQv0t1BF5xmcLJSk,10
+siglab_py-0.6.12.dist-info/RECORD,,

{siglab_py-0.1.29.dist-info → siglab_py-0.6.12.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

siglab_py-0.1.29.dist-info/RECORD

@@ -1,34 +0,0 @@
-siglab_py/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-siglab_py/constants.py,sha256=YGNdEsWtQ99V2oltaynZTjM8VIboSfyIjDXJKSlhv4U,132
-siglab_py/exchanges/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-siglab_py/exchanges/any_exchange.py,sha256=Y-zue75ZSmu9Ga1fONbjBGLNH5pDHQI01hCSjuLBkAk,889
-siglab_py/exchanges/futubull.py,sha256=6M99G8ZYsIyDyoTvvleMT_WPyNYbb6q-t2KXp0Qyi6g,20422
-siglab_py/market_data_providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-siglab_py/market_data_providers/aggregated_orderbook_provider.py,sha256=FZRobEBNRzcNGlOG3u38OVhmOZYlkNm8dVvR-S7Ii2g,23342
-siglab_py/market_data_providers/candles_provider.py,sha256=fqHJjlECsBiBlpgyywrc4gTgxiROPNzZM8KxQBB5cOg,14139
-siglab_py/market_data_providers/candles_ta_provider.py,sha256=uiAhbEZZdTF-YulBHpSLwabos5LHCKU91NTiTmpUc0w,12001
-siglab_py/market_data_providers/ccxt_candles_ta_to_csv.py,sha256=8-cKcZXFBHLX_-KmPXBKv1QNqJYUdDp6iqa1miVlpF8,11139
-siglab_py/market_data_providers/deribit_options_expiry_provider.py,sha256=e9Ee8TmC8pXaid8-jouSLKIpuW6_JBBgwRTieI665yQ,8684
-siglab_py/market_data_providers/futu_candles_ta_to_csv.py,sha256=S4GXaJ7AveEh-Cm9-VhENBdlj_1CfyBTrQO7acTqfUE,10226
-siglab_py/market_data_providers/orderbooks_provider.py,sha256=olt-3LIkoyzQWfNNQRhJtKibLbkTutt_q_rCCTM7i1g,16216
-siglab_py/market_data_providers/test_provider.py,sha256=wBLCgcWjs7FGZJXWsNyn30lkOLa_cgpuvqRakMC0wbA,2221
-siglab_py/ordergateway/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-siglab_py/ordergateway/client.py,sha256=qh4vrCJm8iITKAl07lisZxJ3V4JkbsYlmIBMYihfUaU,9575
-siglab_py/ordergateway/encrypt_keys_util.py,sha256=-qi87db8To8Yf1WS1Q_Cp2Ya7ZqgWlRqSHfNXCM7wE4,1339
-siglab_py/ordergateway/gateway.py,sha256=FoE-OUBrHJ2fdKAfvGue1yQ2P67falWoyoEGCV8ScfA,37219
-siglab_py/ordergateway/test_ordergateway.py,sha256=_Gz2U_VqljogGWqGyNDYYls1INqUiig9veyPttfGRpg,3901
-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/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/market_data_util_tests.py,sha256=A1y83itISmMJdn6wLpfwcr4tGola8wTf1D1xbelMvgw,2026
-siglab_py/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-siglab_py/util/analytic_util.py,sha256=K5YYfvNR5xHjIPUEDJ9c9L9yzolOI2KEYCh6GngtSdk,44042
-siglab_py/util/aws_util.py,sha256=KGmjHrr1rpnnxr33nXHNzTul4tvyyxl9p6gpwNv0Ygc,2557
-siglab_py/util/market_data_util.py,sha256=qRKsFKZMYsaC18ImSWug6dRAOo2_GS1NZM-j0EYMViE,19319
-siglab_py/util/retry_util.py,sha256=mxYuRFZRZoaQQjENcwPmxhxixtd1TFvbxIdPx4RwfRc,743
-siglab_py-0.1.29.dist-info/METADATA,sha256=63E7VJzd54t9AeCaL--o7uHDGBlG4TPB6Ij9_8mHT5Q,980
-siglab_py-0.1.29.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-siglab_py-0.1.29.dist-info/top_level.txt,sha256=AbD4VR9OqmMOGlMJLkAVPGQMtUPIQv0t1BF5xmcLJSk,10
-siglab_py-0.1.29.dist-info/RECORD,,