siglab-py 0.5.48__tar.gz → 0.5.51__tar.gz

{siglab_py-0.5.48 → siglab_py-0.5.51}/PKG-INFO

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

{siglab_py-0.5.48 → siglab_py-0.5.51}/pyproject.toml

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

{siglab_py-0.5.48 → siglab_py-0.5.51}/setup.cfg

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

siglab_py-0.5.51/siglab_py/tests/unit/simple_math_tests.py

@@ -0,0 +1,235 @@
+import unittest
+from typing import List, Dict, Union
+
+from util.simple_math import generate_rand_nums, round_to_level, bucket_series, bucketize_val
+
+class SimpleMathTests(unittest.TestCase):
+
+    def test_generate_rand_nums(self):
+        range_min : float = 0
+        range_max : float = 1
+        size : int = 100
+        percentage_in_range : float = 91
+        abs_min : float = -0.5
+        abs_max : float = 1.1
+
+        rand_nums : List[float] = generate_rand_nums(
+                                        range_min = range_min,
+                                        range_max = range_max,
+                                        size = size, 
+                                        percent_in_range = percentage_in_range,
+                                        abs_min = abs_min,
+                                        abs_max = abs_max
+                                    )
+        
+        assert(len(rand_nums)==size)
+        assert(len([x for x in rand_nums if x>=range_min and x<=range_max]) == (percentage_in_range/100) * size)
+        assert(len([x for x in rand_nums if x<abs_min or x>abs_max]) == 0)
+
+
+        range_min = -1
+        range_max  = 1
+        percentage_in_range = 91
+        abs_min = -1.5
+        abs_max = 1.5
+
+        rand_nums : List[float] = generate_rand_nums(
+                                        range_min = range_min,
+                                        range_max = range_max,
+                                        size = size, 
+                                        percent_in_range = percentage_in_range,
+                                        abs_min = abs_min,
+                                        abs_max = abs_max
+                                    )
+        
+        assert(len(rand_nums)==size)
+        assert(len([x for x in rand_nums if x>=range_min and x<=range_max]) == (percentage_in_range/100) * size)
+        assert(len([x for x in rand_nums if x<abs_min or x>abs_max]) == 0)
+
+
+        range_min = 0
+        range_max  = 100
+        percentage_in_range = 91
+        abs_min = -150
+        abs_max = 150
+
+        rand_nums : List[float] = generate_rand_nums(
+                                        range_min = range_min,
+                                        range_max = range_max,
+                                        size = size, 
+                                        percent_in_range = percentage_in_range,
+                                        abs_min = abs_min,
+                                        abs_max = abs_max
+                                    )
+        
+        assert(len(rand_nums)==size)
+        assert(len([x for x in rand_nums if x>=range_min and x<=range_max]) == (percentage_in_range/100) * size)
+        assert(len([x for x in rand_nums if x<abs_min or x>abs_max]) == 0)
+
+
+        range_min = -100
+        range_max  = 100
+        percentage_in_range = 91
+        abs_min = -150
+        abs_max = 150
+
+        rand_nums : List[float] = generate_rand_nums(
+                                        range_min = range_min,
+                                        range_max = range_max,
+                                        size = size, 
+                                        percent_in_range = percentage_in_range,
+                                        abs_min = abs_min,
+                                        abs_max = abs_max
+                                    )
+        
+        assert(len(rand_nums)==size)
+        assert(len([x for x in rand_nums if x>=range_min and x<=range_max]) == (percentage_in_range/100) * size)
+        assert(len([x for x in rand_nums if x<abs_min or x>abs_max]) == 0)
+
+    def test_round_to_level(self):
+        prices = [ 
+            { 'price' : 15080, 'rounded' : 15000}, 
+            { 'price' : 15180, 'rounded' : 15200}, 
+            { 'price' : 25080, 'rounded' : 25200}, 
+            { 'price' : 25180, 'rounded' : 25200}, 
+            { 'price' : 25380, 'rounded' : 25500}, 
+            { 'price' : 95332, 'rounded' : 95000}, 
+            { 'price' : 95878, 'rounded' : 96000}, 
+            { 'price' : 103499, 'rounded' : 103000}, 
+            { 'price' : 103500, 'rounded' : 104000}, 
+            { 'price' : 150800, 'rounded' : 150000}, 
+            { 'price' : 151800, 'rounded' : 152000}
+        ]
+        for entry in prices:
+            price = entry['price']
+            expected = entry['rounded']
+            rounded_price = round_to_level(price, level_granularity=0.01)
+            print(f"{price} rounded to: {rounded_price}")
+            assert(rounded_price==expected)
+
+    def test_bucket_series(self):
+
+        level_granularity : float = 0.1
+
+        range_min : float = 0
+        range_max : float = 1
+        size : int = 100
+        percentage_in_range : float = 91
+        abs_min : float = -0.5
+        abs_max : float = 1.1
+
+        rand_nums : List[float] = generate_rand_nums(
+                                        range_min = range_min,
+                                        range_max = range_max,
+                                        size = size, 
+                                        percent_in_range = percentage_in_range,
+                                        abs_min = abs_min,
+                                        abs_max = abs_max
+                                    )
+
+        buckets : Dict[
+            str, 
+            Dict[str,Union[float, List[float]]]
+        ] = bucket_series(
+                                                values = rand_nums,
+                                                outlier_threshold_percent = 10,
+                                                level_granularity=level_granularity
+                                            )
+        
+        bucketized = []
+        for num in rand_nums:
+            bucketized.append(
+                bucketize_val(num, buckets=buckets)
+            )
+
+        
+        range_min = -1
+        range_max = 1
+        size : int = 100
+        percentage_in_range = 91
+        abs_min = -1.5
+        abs_max = 1.5
+
+        rand_nums : List[float] = generate_rand_nums(
+                                        range_min = range_min,
+                                        range_max = range_max,
+                                        size = size, 
+                                        percent_in_range = percentage_in_range,
+                                        abs_min = abs_min,
+                                        abs_max = abs_max
+                                    )
+
+        buckets = bucket_series(
+                                    values = rand_nums,
+                                    outlier_threshold_percent = 10,
+                                    level_granularity=level_granularity
+                                )
+        
+
+        range_min = 0
+        range_max = 100
+        size : int = 100
+        percentage_in_range = 91
+        abs_min = -0.5
+        abs_max = 150
+
+        rand_nums : List[float] = generate_rand_nums(
+                                        range_min = range_min,
+                                        range_max = range_max,
+                                        size = size, 
+                                        percent_in_range = percentage_in_range,
+                                        abs_min = abs_min,
+                                        abs_max = abs_max
+                                    )
+
+        buckets = bucket_series(
+                                    values = rand_nums,
+                                    outlier_threshold_percent = 10,
+                                    level_granularity=level_granularity
+                                )
+        
+
+        range_min = -100
+        range_max = 100
+        size : int = 100
+        percentage_in_range = 91
+        abs_min = -150
+        abs_max = 150
+
+        rand_nums : List[float] = generate_rand_nums(
+                                        range_min = range_min,
+                                        range_max = range_max,
+                                        size = size, 
+                                        percent_in_range = percentage_in_range,
+                                        abs_min = abs_min,
+                                        abs_max = abs_max
+                                    )
+
+        buckets = bucket_series(
+                                    values = rand_nums,
+                                    outlier_threshold_percent = 10,
+                                    level_granularity=level_granularity
+                                )
+        
+
+        range_min = 20_000
+        range_max = 120_000
+        size : int = 100
+        percentage_in_range = 91
+        abs_min = 15_000
+        abs_max = 130_000
+
+        rand_nums : List[float] = generate_rand_nums(
+                                        range_min = range_min,
+                                        range_max = range_max,
+                                        size = size, 
+                                        percent_in_range = percentage_in_range,
+                                        abs_min = abs_min,
+                                        abs_max = abs_max
+                                    )
+
+        buckets = bucket_series(
+                                    values = rand_nums,
+                                    outlier_threshold_percent = 10,
+                                    level_granularity=level_granularity
+                                )

{siglab_py-0.5.48 → siglab_py-0.5.51}/siglab_py/tests/unit/trading_util_tests.py

@@ -63,24 +63,3 @@ class TradingUtilTests(unittest.TestCase):
             default_effective_tp_trailing_percent = default_effective_tp_trailing_percent
         )
         assert(effective_tp_trailing_percent==0) # Most tight trailing SL
-
-    def test_round_to_level(self):
-        prices = [ 
-            { 'price' : 15080, 'rounded' : 15000}, 
-            { 'price' : 15180, 'rounded' : 15200}, 
-            { 'price' : 25080, 'rounded' : 25200}, 
-            { 'price' : 25180, 'rounded' : 25200}, 
-            { 'price' : 25380, 'rounded' : 25500}, 
-            { 'price' : 95332, 'rounded' : 95000}, 
-            { 'price' : 95878, 'rounded' : 96000}, 
-            { 'price' : 103499, 'rounded' : 103000}, 
-            { 'price' : 103500, 'rounded' : 104000}, 
-            { 'price' : 150800, 'rounded' : 150000}, 
-            { 'price' : 151800, 'rounded' : 152000}
-        ]
-        for entry in prices:
-            price = entry['price']
-            expected = entry['rounded']
-            rounded_price = round_to_level(price, level_granularity=0.01)
-            print(f"{price} rounded to: {rounded_price}")
-            assert(rounded_price==expected)

{siglab_py-0.5.48 → siglab_py-0.5.51}/siglab_py/util/analytic_util.py

@@ -11,6 +11,7 @@ from hurst import compute_Hc # compatible with pypy
 from ccxt.base.exchange import Exchange as CcxtExchange
 from ccxt import deribit
 
+from siglab_py.util.simple_math import bucket_series
 from siglab_py.util.market_data_util import fix_column_types
 from siglab_py.constants import TrendDirection
 
@@ -473,6 +474,15 @@ def compute_candles_stats(
         
     lo_rs = lo_ma_up / lo_ma_down
     pd_candles.loc[:,'rsi'] = 100 - (100/(1 + lo_rs))
+    rsi_buckets = bucket_series(
+        values = pd_candles['rsi'].to_list(),
+        outlier_threshold_percent=10,
+        level_granularity=0.1
+    )
+    
+    pd_candles['rsi_bucket'] = pd_candles['rsi'].rolling(
+        window=sliding_window_how_many_candles
+        ).apply(lambda x: bucketize_val(x, buckets=rsi_buckets))
     pd_candles['ema_rsi'] = pd_candles['rsi'].ewm(
         span=rsi_sliding_window_how_many_candles, 
         adjust=False).mean()

siglab_py-0.5.51/siglab_py/util/simple_math.py

@@ -0,0 +1,205 @@
+import math
+import random
+from typing import List, Dict, Union
+
+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:
+    level_size = num * level_granularity
+    magnitude = math.floor(math.log10(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
+    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
+
+    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:
+        intervals = _generate_sequence(0.1, 1, 0.1)
+        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:
+        intervals = _generate_sequence(-0.9, 1, 0.1)
+        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:
+        intervals = _generate_sequence(10, 100, 10)
+        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:
+        intervals = _generate_sequence(-90, 100, 10)
+        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-0.5.48 → siglab_py-0.5.51}/siglab_py/util/trading_util.py

@@ -116,15 +116,3 @@ def calc_eff_trailing_sl(
             effective_tp_trailing_percent = default_effective_tp_trailing_percent
 
     return effective_tp_trailing_percent
-
-# https://norman-lm-fung.medium.com/levels-are-psychological-7176cdefb5f2
-def round_to_level(
-            price : float,
-            level_granularity : float = 0.01
-        ) -> float:
-    level_size = price * level_granularity
-    magnitude = math.floor(math.log10(level_size))
-    base_increment = 10 ** magnitude
-    rounded_level_size = round(level_size / base_increment) * base_increment
-    rounded_price = round(price / rounded_level_size) * rounded_level_size
-    return rounded_price

{siglab_py-0.5.48 → siglab_py-0.5.51}/siglab_py.egg-info/PKG-INFO

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

siglab_py-0.5.48/siglab_py/tests/unit/simple_math_tests.py

@@ -1,87 +0,0 @@
-import unittest
-from typing import List
-
-from util.simple_math import generate_rand_nums
-
-class SimpleMathTests(unittest.TestCase):
-
-    def test_generate_rand_nums(self):
-        range_min : float = 0
-        range_max : float = 1
-        size : int = 100
-        percentage_in_range : float = 91
-        abs_min : float = -0.5
-        abs_max : float = 1.1
-
-        rand_nums : List[float] = generate_rand_nums(
-                                        range_min = range_min,
-                                        range_max = range_max,
-                                        size = size, 
-                                        percent_in_range = percentage_in_range,
-                                        abs_min = abs_min,
-                                        abs_max = abs_max
-                                    )
-        
-        assert(len(rand_nums)==size)
-        assert(len([x for x in rand_nums if x>=range_min and x<=range_max]) == (percentage_in_range/100) * size)
-        assert(len([x for x in rand_nums if x<abs_min or x>abs_max]) == 0)
-
-
-        range_min = -1
-        range_max  = 1
-        percentage_in_range = 91
-        abs_min = -1.5
-        abs_max = 1.5
-
-        rand_nums : List[float] = generate_rand_nums(
-                                        range_min = range_min,
-                                        range_max = range_max,
-                                        size = size, 
-                                        percent_in_range = percentage_in_range,
-                                        abs_min = abs_min,
-                                        abs_max = abs_max
-                                    )
-        
-        assert(len(rand_nums)==size)
-        assert(len([x for x in rand_nums if x>=range_min and x<=range_max]) == (percentage_in_range/100) * size)
-        assert(len([x for x in rand_nums if x<abs_min or x>abs_max]) == 0)
-
-
-        range_min = 0
-        range_max  = 100
-        percentage_in_range = 91
-        abs_min = -150
-        abs_max = 150
-
-        rand_nums : List[float] = generate_rand_nums(
-                                        range_min = range_min,
-                                        range_max = range_max,
-                                        size = size, 
-                                        percent_in_range = percentage_in_range,
-                                        abs_min = abs_min,
-                                        abs_max = abs_max
-                                    )
-        
-        assert(len(rand_nums)==size)
-        assert(len([x for x in rand_nums if x>=range_min and x<=range_max]) == (percentage_in_range/100) * size)
-        assert(len([x for x in rand_nums if x<abs_min or x>abs_max]) == 0)
-
-
-        range_min = -100
-        range_max  = 100
-        percentage_in_range = 91
-        abs_min = -150
-        abs_max = 150
-
-        rand_nums : List[float] = generate_rand_nums(
-                                        range_min = range_min,
-                                        range_max = range_max,
-                                        size = size, 
-                                        percent_in_range = percentage_in_range,
-                                        abs_min = abs_min,
-                                        abs_max = abs_max
-                                    )
-        
-        assert(len(rand_nums)==size)
-        assert(len([x for x in rand_nums if x>=range_min and x<=range_max]) == (percentage_in_range/100) * size)
-        assert(len([x for x in rand_nums if x<abs_min or x>abs_max]) == 0)

siglab_py-0.5.48/siglab_py/util/simple_math.py

@@ -1,30 +0,0 @@
-import random
-from typing import List
-
-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
-    ):
-    assert(range_min<range_max)
-
-    if abs_min>range_min:
-        abs_min = range_min
-    if abs_max<range_max:
-        abs_max = range_max
-
-    result = []
-    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