siglab-py 0.3.8__tar.gz → 0.3.10__tar.gz

{siglab_py-0.3.8 → siglab_py-0.3.10}/PKG-INFO

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

{siglab_py-0.3.8 → siglab_py-0.3.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "siglab_py"
-version = "0.3.8"
+version = "0.3.10"
 description = "Market data fetches, TA calculations and generic order gateway."
 authors = [{name = "r0bbarh00d", email = "r0bbarh00d@gmail.com"}]
 license = {text = "MIT"}

{siglab_py-0.3.8 → siglab_py-0.3.10}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = siglab_py
-version = 0.3.8
+version = 0.3.10
 description = Market data fetches, TA calculations and generic order gateway.
 author = r0bbarh00d
 author_email = r0bbarh00d@gmail.com

{siglab_py-0.3.8 → siglab_py-0.3.10}/siglab_py/util/analytic_util.py

@@ -894,4 +894,11 @@ def compute_pair_stats(
     pd_candles['close_spread_std'] = std
     pd_candles['zscore_close_spread'] = (pd_candles['close_spread'] - mean)/std
     pd_candles['zscore_close_spread_min'] = pd_candles['zscore_close_spread'].rolling(how_many_candles).min()
-    pd_candles['zscore_close_spread_max'] = pd_candles['zscore_close_spread'].rolling(how_many_candles).max()
+    pd_candles['zscore_close_spread_max'] = pd_candles['zscore_close_spread'].rolling(how_many_candles).max()
+
+    calculate_slope(
+        pd_data=pd_candles,
+        src_col_name='zscore_close_spread',
+        slope_col_name='zscore_slope',
+        sliding_window_how_many_candles=how_many_candles
+    )

{siglab_py-0.3.8 → siglab_py-0.3.10}/siglab_py/util/market_data_util.py

@@ -516,55 +516,56 @@ def _fetch_candles_ccxt(
     candle_size : str,
     num_candles_limit : int = 100
 ) -> Dict[str, Union[pd.DataFrame, None]]:
-    ticker = normalized_symbols[0]
+    rsp = {}
 
-    def _fetch_ohlcv(exchange, symbol, timeframe, since, limit, params) -> Union[List, NoReturn]:
-            one_timeframe = f"1{timeframe[-1]}"
-            candles = exchange.fetch_ohlcv(symbol=symbol, timeframe=one_timeframe, since=since, limit=limit, params=params)
-            if candles and len(candles)>0:
-                candles.sort(key=lambda x : x[0], reverse=False)
+    for ticker in normalized_symbols:
+        def _fetch_ohlcv(exchange, symbol, timeframe, since, limit, params) -> Union[List, NoReturn]:
+                one_timeframe = f"1{timeframe[-1]}"
+                candles = exchange.fetch_ohlcv(symbol=symbol, timeframe=one_timeframe, since=since, limit=limit, params=params)
+                if candles and len(candles)>0:
+                    candles.sort(key=lambda x : x[0], reverse=False)
 
-            return candles
-        
-    def _calc_increment(candle_size):
-        increment = 1
-        num_intervals = int(candle_size[0])
-        interval_type = candle_size[-1]
-        if interval_type == "m":
-            increment = 60
-        elif interval_type == "h":
-            increment = 60*60
-        elif interval_type == "d":
-            increment = 60*60*24
-        else:
-            raise ValueError(f"Invalid candle_size {candle_size}")
-        return num_intervals * increment
-    
-    all_candles = []
-    params = {}
-    this_cutoff = start_ts
-    while this_cutoff<end_ts:
-        candles = _fetch_ohlcv(exchange=exchange, symbol=ticker, timeframe=candle_size, since=int(this_cutoff * 1000), limit=num_candles_limit, params=params)
-        if candles and len(candles)>0:
-            all_candles = all_candles + [[ int(x[0]), float(x[1]), float(x[2]), float(x[3]), float(x[4]), float(x[5]) ] for x in candles if x[1] and x[2] and x[3] and x[4] and x[5] ]
-
-            record_ts = max([int(record[0]) for record in candles])
-            record_ts_str : str = str(record_ts)
-            if len(record_ts_str)==13:
-                record_ts = int(int(record_ts_str)/1000) # Convert from milli-seconds to seconds
+                return candles
             
-            this_cutoff = record_ts  + _calc_increment(candle_size)
-        else:
-            this_cutoff += _calc_increment(candle_size)
+        def _calc_increment(candle_size):
+            increment = 1
+            num_intervals = int(candle_size[0])
+            interval_type = candle_size[-1]
+            if interval_type == "m":
+                increment = 60
+            elif interval_type == "h":
+                increment = 60*60
+            elif interval_type == "d":
+                increment = 60*60*24
+            else:
+                raise ValueError(f"Invalid candle_size {candle_size}")
+            return num_intervals * increment
+        
+        all_candles = []
+        params = {}
+        this_cutoff = start_ts
+        while this_cutoff<end_ts:
+            candles = _fetch_ohlcv(exchange=exchange, symbol=ticker, timeframe=candle_size, since=int(this_cutoff * 1000), limit=num_candles_limit, params=params)
+            if candles and len(candles)>0:
+                all_candles = all_candles + [[ int(x[0]), float(x[1]), float(x[2]), float(x[3]), float(x[4]), float(x[5]) ] for x in candles if x[1] and x[2] and x[3] and x[4] and x[5] ]
+
+                record_ts = max([int(record[0]) for record in candles])
+                record_ts_str : str = str(record_ts)
+                if len(record_ts_str)==13:
+                    record_ts = int(int(record_ts_str)/1000) # Convert from milli-seconds to seconds
+                
+                this_cutoff = record_ts  + _calc_increment(candle_size)
+            else:
+                this_cutoff += _calc_increment(candle_size)
 
-    columns = ['exchange', 'symbol', 'timestamp_ms', 'open', 'high', 'low', 'close', 'volume']
-    pd_all_candles = pd.DataFrame([ [ exchange.name, ticker, x[0], x[1], x[2], x[3], x[4], x[5] ] for x in all_candles], columns=columns)
-    fix_column_types(pd_all_candles)
-    pd_all_candles['pct_chg_on_close'] = pd_all_candles['close'].pct_change()
+        columns = ['exchange', 'symbol', 'timestamp_ms', 'open', 'high', 'low', 'close', 'volume']
+        pd_all_candles = pd.DataFrame([ [ exchange.name, ticker, x[0], x[1], x[2], x[3], x[4], x[5] ] for x in all_candles], columns=columns)
+        fix_column_types(pd_all_candles)
+        pd_all_candles['pct_chg_on_close'] = pd_all_candles['close'].pct_change()
 
-    return {
-        ticker : pd_all_candles
-    }
+        rsp[ticker] = pd_all_candles
+
+    return rsp
 
 def fetch_deribit_btc_option_expiries(
     market: str = 'BTC'

{siglab_py-0.3.8 → siglab_py-0.3.10}/siglab_py.egg-info/PKG-INFO

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

{siglab_py-0.3.8 → siglab_py-0.3.10}/siglab_py.egg-info/SOURCES.txt

@@ -38,5 +38,4 @@ siglab_py/util/market_data_util.py
 siglab_py/util/notification_util.py
 siglab_py/util/retry_util.py
 siglab_py/util/slack_notification_util.py
-siglab_py/util/test_market_data_analytic_util.py
 siglab_py/util/trading_util.py

siglab_py-0.3.8/siglab_py/util/test_market_data_analytic_util.py

@@ -1,64 +0,0 @@
-from datetime import datetime
-import time
-from typing import Union
-import pandas as pd
-
-from ccxt.okx import okx
-
-from market_data_util import fetch_candles
-from analytic_util import compute_candles_stats
-
-base_ccy : str = "BTC"
-# ticker = "GRIFFAIN/USDT:USDT"
-# ticker = "OL/USDT:USDT"
-ticker = f"{base_ccy}/USDT:USDT"
-
-reload_raw_candles : bool = True
-raw_candles_file : str = f"{base_ccy}_raw_candles.csv"
-candles_with_ta_file : str = f"{base_ccy}_candles_ta.csv"
-
-param = {
-        'rateLimit' : 100,    # In ms
-        'options' : {
-            'defaultType': 'swap', # Should test linear instead
-        }
-    }
-exchange = okx(param) # type: ignore
-
-start_date : datetime = datetime(2024,1,1)
-end_date : datetime = datetime(2025,4,22)
-candle_size : str = '1h'
-ma_long_intervals : int = 24*30
-ma_short_intervals : int = 24
-boillenger_std_multiples : int = 2
-pypy_compatible : bool = False
-
-markets = exchange.load_markets()
-assert(ticker in markets)
-
-start = time.time()
-
-if reload_raw_candles:
-    pd_candles: Union[pd.DataFrame, None] = fetch_candles(
-                start_ts=int(start_date.timestamp()),
-                end_ts=int(end_date.timestamp()),
-                exchange=exchange,
-                normalized_symbols=[ ticker ],
-                candle_size=candle_size
-            )[ ticker ]
-
-    pd_candles.to_csv(raw_candles_file) # type: ignore
-else:
-    pd_candles = pd.read_csv(raw_candles_file) # type: ignore
-
-compute_candles_stats(
-                                    pd_candles=pd_candles, # type: ignore
-                                    boillenger_std_multiples=boillenger_std_multiples, 
-                                    sliding_window_how_many_candles=ma_long_intervals, 
-                                    slow_fast_interval_ratio=(ma_long_intervals/ma_short_intervals),
-                                    pypy_compat=pypy_compatible
-                                ) 
-pd_candles.to_csv(candles_with_ta_file) # type: ignore
-
-compute_candles_stats_elapsed_ms = int((time.time() - start) *1000)
-print(f"elapsed (ms): {compute_candles_stats_elapsed_ms}")