siglab-py 0.5.48__py3-none-any.whl → 0.5.51__py3-none-any.whl

siglab_py/tests/unit/simple_math_tests.py

@@ -1,7 +1,7 @@
 import unittest
-from typing import List
+from typing import List, Dict, Union
 
-from util.simple_math import generate_rand_nums
+from util.simple_math import generate_rand_nums, round_to_level, bucket_series, bucketize_val
 
 class SimpleMathTests(unittest.TestCase):
 
@@ -84,4 +84,152 @@ class SimpleMathTests(unittest.TestCase):
         
         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)
+        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/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/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/util/simple_math.py

@@ -1,5 +1,6 @@
+import math
 import random
-from typing import List
+from typing import List, Dict, Union
 
 def generate_rand_nums(
         range_min : float = 0,
@@ -8,7 +9,7 @@ def generate_rand_nums(
         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:
@@ -16,7 +17,7 @@ def generate_rand_nums(
     if abs_max<range_max:
         abs_max = range_max
 
-    result = []
+    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)):
@@ -28,3 +29,177 @@ def generate_rand_nums(
     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/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.dist-info → siglab_py-0.5.51.dist-info}/METADATA

@@ -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.dist-info → siglab_py-0.5.51.dist-info}/RECORD

@@ -24,18 +24,18 @@ siglab_py/tests/integration/market_data_util_tests.py,sha256=p-RWIJZLyj0lAdfi4QT
 siglab_py/tests/unit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 siglab_py/tests/unit/analytic_util_tests.py,sha256=K7jtuKJLynW8EFyNgjOVHA2e2d6Gl2f0ONggFy9tD7g,5780
 siglab_py/tests/unit/market_data_util_tests.py,sha256=A1y83itISmMJdn6wLpfwcr4tGola8wTf1D1xbelMvgw,2026
-siglab_py/tests/unit/simple_math_tests.py,sha256=nM7RZyFGNpMpAXattrO-K5gnlhYXF1trWRbETWRQiqU,3643
-siglab_py/tests/unit/trading_util_tests.py,sha256=9DZmTZlW55lPtNfTCukgDdiyBiMYv9R4mEFWJIJiTNg,3870
+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=dlmaf4QZ95JPGNN0LgOG8njpYE9nek4g9QVA51KvM6s,61306
+siglab_py/util/analytic_util.py,sha256=2TXBnxoO2dUNtVv_YAq_1zKEuGpVGIWKLyHF0nLd4JU,61697
 siglab_py/util/aws_util.py,sha256=KGmjHrr1rpnnxr33nXHNzTul4tvyyxl9p6gpwNv0Ygc,2557
 siglab_py/util/market_data_util.py,sha256=mUXg4uaiX3b6_klgJWIEgnUQU4IUd6CwTOqKLiQWRlU,31307
 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=LUZVMEl-EA_jMgIYcqOFPgMEDRDJxFU4n_KCN1qznyw,827
+siglab_py/util/simple_math.py,sha256=kVBa-h7sH6IrDJOSxd0LtrLAe0ROMiIEg4fc53XO-IA,7416
 siglab_py/util/slack_notification_util.py,sha256=G27n-adbT3Q6oaHSMvu_Nom794rrda5PprSF-zvmzkM,1912
-siglab_py/util/trading_util.py,sha256=-TGNgJdy4HMDPgq31KQn_lRawFxuXnFU5NnLRb1XM5o,5757
-siglab_py-0.5.48.dist-info/METADATA,sha256=kg-ba09DtS7X-RWGzHjRRhz6xmmjWy-PhS4ZYhdZzoU,829
-siglab_py-0.5.48.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
-siglab_py-0.5.48.dist-info/top_level.txt,sha256=AbD4VR9OqmMOGlMJLkAVPGQMtUPIQv0t1BF5xmcLJSk,10
-siglab_py-0.5.48.dist-info/RECORD,,
+siglab_py/util/trading_util.py,sha256=dlIOzoMGnddLSFODcJ61EBH1Aeruq4IT2MsxIdFkV9I,5252
+siglab_py-0.5.51.dist-info/METADATA,sha256=7tXlpFvkoadF0GXl8R22N9rQpFnqDYGKZ_NiN4F7uXg,829
+siglab_py-0.5.51.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+siglab_py-0.5.51.dist-info/top_level.txt,sha256=AbD4VR9OqmMOGlMJLkAVPGQMtUPIQv0t1BF5xmcLJSk,10
+siglab_py-0.5.51.dist-info/RECORD,,