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

siglab_py/ordergateway/test_ordergateway.py

@@ -12,7 +12,7 @@ from constants import JSON_SERIALIZABLE_TYPES
 
 '''
 set PYTHONPATH=%PYTHONPATH%;D:\dev\siglab\siglab_py
-python test_ordergateway.py --gateway_id bybit_03
+python test_ordergateway.py --gateway_id hyperliquid_01
 '''
 
 param : Dict[str, str] = {
@@ -91,27 +91,28 @@ if __name__ == '__main__':
 
     positions_3 : List[DivisiblePosition] = [
         DivisiblePosition(
-            ticker = 'BTC/USDT:USDT',
+            ticker = 'BTC/USDC:USDC',
             side = 'sell',
-            amount = 0.01,
+            amount = 0.00100,
             leg_room_bps = 5,
-            reduce_only=False,
+            reduce_only=True,
             order_type = 'limit',
             slices=1,
-            wait_fill_threshold_ms=60000
+            wait_fill_threshold_ms=60000,
+            fees_ccy='USDC'
         )
     ]
 
     
     executed_positions : Union[Dict[JSON_SERIALIZABLE_TYPES, JSON_SERIALIZABLE_TYPES], None] = execute_positions(
         redis_client=redis_client,
-        positions=positions_2,
+        positions=positions_3,
         ordergateway_pending_orders_topic=ordergateway_pending_orders_topic,
         ordergateway_executions_topic=ordergateway_executions_topic
         )
     if executed_positions:
         for position in executed_positions:
-            print(f"{position['ticker']} {position['side']} amount: {position['amount']} leg_room_bps: {position['leg_room_bps']} slices: {position['slices']}, filled_amount: {position['filled_amount']}, average_cost: {position['average_cost']}, # executions: {len(position['executions'])}") # type: ignore
+            print(f"{position['ticker']} {position['side']} amount: {position['amount']} leg_room_bps: {position['leg_room_bps']} slices: {position['slices']}, filled_amount: {position['filled_amount']}, average_cost: {position['average_cost']}, # executions: {len(position['executions'])}, done: {position['done']}, execution_err: {position['execution_err']}") # type: ignore
         
         
 

siglab_py/tests/integration/market_data_util_tests.py

@@ -1,6 +1,8 @@
 import unittest
 from datetime import datetime, timedelta
 from typing import Union
+import json
+import logging
 from pathlib import Path
 
 from util.market_data_util import *
@@ -36,7 +38,7 @@ class MarketDataUtilTests(unittest.TestCase):
 
         if pd_candles is not None:
             assert len(pd_candles) > 0, "No candles returned."
-            expected_columns = {'exchange', 'symbol', 'timestamp_ms', 'open', 'high', 'low', 'close', 'volume', 'datetime_utc', 'datetime', 'year', 'month', 'day', 'hour', 'minute'}
+            expected_columns = {'exchange', 'symbol', 'timestamp_ms', 'open', 'high', 'low', 'close', 'volume', 'datetime_utc', 'datetime', 'year', 'month', 'day', 'hour', 'minute', 'week_of_month', 'apac_trading_hr', 'emea_trading_hr', 'amer_trading_hr'}
             assert set(pd_candles.columns) >= expected_columns, "Missing expected columns."
             assert pd_candles['timestamp_ms'].notna().all(), "timestamp_ms column contains NaN values."
             assert pd_candles['timestamp_ms'].is_monotonic_increasing, "Timestamps are not in ascending order."
@@ -81,7 +83,7 @@ class MarketDataUtilTests(unittest.TestCase):
 
         if pd_candles is not None:
             assert len(pd_candles) > 0, "No candles returned."
-            expected_columns = {'exchange', 'symbol', 'timestamp_ms', 'open', 'high', 'low', 'close', 'volume', 'datetime_utc', 'datetime', 'year', 'month', 'day', 'hour', 'minute'}
+            expected_columns = {'exchange', 'symbol', 'timestamp_ms', 'open', 'high', 'low', 'close', 'volume', 'datetime_utc', 'datetime', 'year', 'month', 'day', 'hour', 'minute', 'week_of_month', 'apac_trading_hr', 'emea_trading_hr', 'amer_trading_hr'}
             assert set(pd_candles.columns) >= expected_columns, "Missing expected columns."
             assert pd_candles['timestamp_ms'].notna().all(), "timestamp_ms column contains NaN values."
             assert pd_candles['timestamp_ms'].is_monotonic_increasing, "Timestamps are not in ascending order."
@@ -100,26 +102,98 @@ class MarketDataUtilTests(unittest.TestCase):
                 'defaultType': 'swap'            }
         }
 
-        exchange : Exchange = okx(param)
+        exchange : Exchange = okx(param) # type: ignore
         normalized_symbols = [ 'BTC/USDT:USDT' ]
         pd_candles: Union[pd.DataFrame, None] = fetch_candles(
             start_ts=start_date.timestamp(),
             end_ts=end_date.timestamp(),
             exchange=exchange,
             normalized_symbols=normalized_symbols,
-            candle_size='1h'
+            candle_size='1h',
+            logger=logging.getLogger()
         )[normalized_symbols[0]]
 
         assert pd_candles is not None
 
         if pd_candles is not None:
             assert len(pd_candles) > 0, "No candles returned."
-            expected_columns = {'exchange', 'symbol', 'timestamp_ms', 'open', 'high', 'low', 'close', 'volume', 'datetime_utc', 'datetime', 'year', 'month', 'day', 'hour', 'minute'}
+            expected_columns = {'exchange', 'symbol', 'timestamp_ms', 'open', 'high', 'low', 'close', 'volume', 'datetime_utc', 'datetime', 'year', 'month', 'day', 'hour', 'minute', 'week_of_month', 'apac_trading_hr', 'emea_trading_hr', 'amer_trading_hr'}
             assert set(pd_candles.columns) >= expected_columns, "Missing expected columns."
             assert pd_candles['timestamp_ms'].notna().all(), "timestamp_ms column contains NaN values."
             assert pd_candles['timestamp_ms'].is_monotonic_increasing, "Timestamps are not in ascending order."
+
+    def test_fetch_candles_ccxt_with_ticker_change_map(self):
+        ticker_change_map : List[Dict[str, Union[str, int]]] = [
+            {
+                'new_ticker' : 'XAU/USDT:USDT',
+                'old_ticker' : 'XAUT/USDT:USDT',
+                'cutoff_ms' : 1768464300000
+            }
+        ]
+
+        start_date : datetime = datetime(2026,1,13,0,0,0)
+        end_date : datetime = datetime(2026,1,15,18,0,0)
+
+        param = {
+            'apiKey' : None,
+            'secret' : None,
+            'password' : None,
+            'subaccount' : None,
+            'rateLimit' : 100,    # In ms
+            'options' : {
+                'defaultType': 'swap'            }
+        }
+
+        exchange : Exchange = okx(param) # type: ignore
+        normalized_symbols = [ 'XAU/USDT:USDT' ]
+        pd_candles: Union[pd.DataFrame, None] = fetch_candles(
+            start_ts=start_date.timestamp(),
+            end_ts=end_date.timestamp(),
+            exchange=exchange,
+            normalized_symbols=normalized_symbols,
+            candle_size='1h',
+            ticker_change_map=ticker_change_map,
+            logger=logging.getLogger()
+        )[normalized_symbols[0]]
+
+        assert pd_candles is not None
+
+    def test_aggregate_candles(self):
+        end_date : datetime = datetime.today()
+        start_date : datetime = end_date + timedelta(hours=-8)
+
+        param = {
+            'apiKey' : None,
+            'secret' : None,
+            'password' : None,
+            'subaccount' : None,
+            'rateLimit' : 100,    # In ms
+            'options' : {
+                'defaultType': 'swap'            }
+        }
+
+        exchange : Exchange = okx(param) # type: ignore
+        normalized_symbols = [ 'BTC/USDT:USDT' ]
+        pd_candles: Union[pd.DataFrame, None] = fetch_candles(
+            start_ts=start_date.timestamp(),
+            end_ts=end_date.timestamp(),
+            exchange=exchange,
+            normalized_symbols=normalized_symbols,
+            candle_size='15m' # <---- aggregate 1m into 15m candles
+        )[normalized_symbols[0]]
+
+        assert pd_candles is not None
+        pd_candles['timestamp_ms_gap'] = pd_candles['timestamp_ms'].diff()
+        timestamp_ms_gap_median = pd_candles['timestamp_ms_gap'].median()
+        NUM_MS_IN_1HR = 60*60*1000
+        expected_15m_gap_ms = NUM_MS_IN_1HR/4
+        assert(timestamp_ms_gap_median==expected_15m_gap_ms)
+        total_num_rows = pd_candles.shape[0]
+        num_rows_with_15min_gaps = pd_candles[pd_candles.timestamp_ms_gap!=timestamp_ms_gap_median].shape[0]
+        assert(num_rows_with_15min_gaps/total_num_rows <= 0.4) # Why not 100% match? minute bars may have gaps (Also depends on what ticker)
         
     def test_fetch_candles_futubull(self):
+        # You need Futu OpenD running and you need entitlements
         end_date : datetime = datetime.today()
         start_date : datetime = end_date - timedelta(days=365*3)
 
@@ -148,7 +222,7 @@ class MarketDataUtilTests(unittest.TestCase):
 
         if pd_candles is not None:
             assert len(pd_candles) > 0, "No candles returned."
-            expected_columns = {'exchange', 'symbol', 'timestamp_ms', 'open', 'high', 'low', 'close', 'volume', 'datetime_utc', 'datetime', 'year', 'month', 'day', 'hour', 'minute'}
+            expected_columns = {'exchange', 'symbol', 'timestamp_ms', 'open', 'high', 'low', 'close', 'volume', 'datetime_utc', 'datetime', 'year', 'month', 'day', 'hour', 'minute', 'week_of_month', 'apac_trading_hr', 'emea_trading_hr', 'amer_trading_hr'}
             assert set(pd_candles.columns) >= expected_columns, "Missing expected columns."
             assert pd_candles['timestamp_ms'].notna().all(), "timestamp_ms column contains NaN values."
             assert pd_candles['timestamp_ms'].is_monotonic_increasing, "Timestamps are not in ascending order."

siglab_py/tests/unit/analytic_util_tests.py

@@ -2,7 +2,7 @@ import unittest
 from typing import List
 from pathlib import Path
 
-from util.analytic_util import compute_candles_stats
+from util.analytic_util import compute_candles_stats, lookup_fib_target
 
 import pandas as pd
 
@@ -38,8 +38,71 @@ class AnalyticUtilTests(unittest.TestCase):
             pd_candles=pd_candles,
             boillenger_std_multiples=2,
             sliding_window_how_many_candles=20,
-            pypy_compat=True
+            pypy_compat=True # Slopes calculation? Set pypy_compat to False
         )
 
-        expected_columns : List[str] = ['exchange', 'symbol', 'timestamp_ms', 'open', 'high', 'low', 'close', 'volume', 'datetime', 'datetime_utc', 'year', 'month', 'day', 'hour', 'minute', 'dayofweek', 'pct_chg_on_close', 'candle_height', 'is_green', 'pct_change_close', 'sma_short_periods', 'sma_long_periods', 'ema_short_periods', 'ema_long_periods', 'ema_close', 'std', 'ema_volume_short_periods', 'ema_volume_long_periods', 'max_short_periods', 'max_long_periods', 'idmax_short_periods', 'idmax_long_periods', 'min_short_periods', 'min_long_periods', 'idmin_short_periods', 'idmin_long_periods', 'h_l', 'h_pc', 'l_pc', 'tr', 'atr', 'hurst_exp', 'boillenger_upper', 'boillenger_lower', 'boillenger_channel_height', 'boillenger_upper_agg', 'boillenger_lower_agg', 'boillenger_channel_height_agg', 'aggressive_up', 'aggressive_up_index', 'aggressive_up_candle_height', 'aggressive_up_candle_high', 'aggressive_up_candle_low', 'aggressive_down', 'aggressive_down_index', 'aggressive_down_candle_height', 'aggressive_down_candle_high', 'aggressive_down_candle_low', 'fvg_low', 'fvg_high', 'fvg_gap', 'fvg_mitigated', 'close_delta', 'close_delta_percent', 'up', 'down', 'rsi', 'ema_rsi', 'typical_price', 'money_flow', 'money_flow_positive', 'money_flow_negative', 'positive_flow_sum', 'negative_flow_sum', 'money_flow_ratio', 'mfi', 'macd', 'signal', 'macd_minus_signal', 'fib_618_short_periods', 'fib_618_long_periods', 'gap_close_vs_ema', 'close_above_or_below_ema', 'close_vs_ema_inflection']
-        assert(pd_candles.columns.to_list()==expected_columns)
+        expected_columns : List[str] = [
+            'exchange', 'symbol', 'timestamp_ms', 
+            'open', 'high', 'low', 'close', 'volume', 
+            'datetime', 'datetime_utc', 'year', 'month', 'day', 'hour', 'minute', 'dayofweek', 
+            'pct_chg_on_close', 'candle_height', 'candle_body_height',
+            'week_of_month', 'apac_trading_hr', 'emea_trading_hr', 'amer_trading_hr', 
+            'is_green', 'candle_class', 'pct_change_close', 
+            'sma_short_periods', 'sma_long_periods', 'ema_short_periods', 'ema_long_periods', 'ema_close', 
+            'std', 'std_percent', 
+            'vwap_short_periods', 'vwap_long_periods',
+            'candle_height_percent', 'candle_height_percent_rounded', 'candle_body_height_percent', 'candle_body_height_percent_rounded',
+            'log_return', 'interval_hist_vol', 'annualized_hist_vol',
+            'chop_against_ema', 
+            'ema_volume_short_periods', 'ema_volume_long_periods', 
+            'ema_cross', 'ema_cross_last', 'ema_bullish_cross_last_id', 'ema_bearish_cross_last_id',
+            'max_short_periods', 'max_long_periods', 'idmax_short_periods', 'idmax_long_periods', 'min_short_periods', 'min_long_periods', 'idmin_short_periods', 'idmin_long_periods', 
+            'max_candle_body_height_percent_long_periods', 'idmax_candle_body_height_percent_long_periods',
+            'min_candle_body_height_percent_long_periods', 'idmin_candle_body_height_percent_long_periods',
+            'price_swing_short_periods', 'price_swing_long_periods',
+            'trend_from_highs_long_periods', 'trend_from_lows_long_periods', 'trend_from_highs_short_periods', 'trend_from_lows_short_periods',
+            'h_l', 'h_pc', 'l_pc', 'tr', 'atr', 'atr_avg_short_periods', 'atr_avg_long_periods',
+            'hurst_exp', 
+            'boillenger_upper', 'boillenger_lower', 'boillenger_channel_height', 'boillenger_upper_agg', 'boillenger_lower_agg', 'boillenger_channel_height_agg', 
+            'aggressive_up', 'aggressive_up_index', 'aggressive_up_candle_height', 'aggressive_up_candle_high', 'aggressive_up_candle_low', 'aggressive_down', 'aggressive_down_index', 'aggressive_down_candle_height', 'aggressive_down_candle_high', 'aggressive_down_candle_low', 
+            'fvg_low', 'fvg_high', 'fvg_gap', 'fvg_mitigated', 
+            'close_delta', 'close_delta_percent', 'up', 'down', 
+            'rsi', 'rsi_bucket', 'ema_rsi', 'rsi_max', 'rsi_idmax', 'rsi_min', 'rsi_idmin', 'rsi_trend', 'rsi_trend_from_highs', 'rsi_trend_from_lows', 'rsi_divergence',
+            'typical_price', 
+            'money_flow', 'money_flow_positive', 'money_flow_negative', 'positive_flow_sum', 'negative_flow_sum', 'money_flow_ratio', 'mfi', 'mfi_bucket',
+            'macd', 'signal', 'macd_minus_signal', 'macd_cross', 'macd_bullish_cross_last_id', 'macd_bearish_cross_last_id', 'macd_cross_last',
+            'fib_0.618_short_periods', 'fib_0.618_long_periods', 
+            'gap_close_vs_ema', 'gap_close_vs_ema_percent',
+            'close_above_or_below_ema', 
+            'close_vs_ema_inflection'
+        ]
+
+        missing_columns = [ expected for expected in expected_columns if expected not in pd_candles.columns.to_list() ]
+        unexpected_columns = [ actual for actual in pd_candles.columns.to_list() if actual not in expected_columns ]
+
+        assert(pd_candles.columns.to_list()==expected_columns)
+
+    def test_lookup_fib_target(self):
+        data_dir = Path(__file__).parent.parent.parent.parent / "data"
+        csv_path = data_dir / "sample_btc_candles.csv"
+        pd_candles : pd.DataFrame = pd.read_csv(csv_path)
+        target_fib_level : float = 0.618
+        compute_candles_stats(
+            pd_candles=pd_candles,
+            boillenger_std_multiples=2,
+            sliding_window_how_many_candles=20,
+            target_fib_level=target_fib_level,
+            pypy_compat=True # Slopes calculation? Set pypy_compat to False
+        )
+
+        last_row = pd_candles.iloc[-1]
+        result = lookup_fib_target(
+            row=last_row, 
+            pd_candles=pd_candles,
+            target_fib_level=target_fib_level
+            )
+        if result:
+            assert(result['short_periods']['min']<result['short_periods']['fib_target']<result['short_periods']['max'])
+            assert(result['long_periods']['min']<result['long_periods']['fib_target']<result['long_periods']['max'])
+        
+

siglab_py/tests/unit/market_data_util_tests.py

@@ -0,0 +1,96 @@
+import unittest
+from datetime import datetime, timedelta
+from typing import Union
+import json
+from pathlib import Path
+
+from util.market_data_util import *
+
+from futu import *
+
+
+# @unittest.skip("Skip all integration tests.")
+class MarketDataUtilTests(unittest.TestCase):
+    def test_timestamp_to_week_of_month(self):
+        test_timestamps = [
+            1672531200000,  # 2023-01-01 (Week 0)
+            1673136000000,  # 2023-01-08 (Week 1)
+            1673740800000,  # 2023-01-15 (Week 2)
+            1674345600000,  # 2023-01-22 (Week 3)
+            1674950400000,  # 2023-01-29 (Week 4)
+            1675468800000,  # 2023-02-01 (Week 0)
+            1676073600000,  # 2023-02-08 (Week 1)
+            1676678400000,  # 2023-02-15 (Week 2)
+            1677283200000,  # 2023-02-22 (Week 3)
+            1677888000000,  # 2023-03-01 (Week 0)
+        ]
+
+        expectations = [0, 1, 2, 3, 4, 0, 1, 2, 3, 0]
+        
+        for i, ts in enumerate(test_timestamps):
+            expectation = expectations[i]
+            actual = timestamp_to_week_of_month(ts)
+            assert expectation == actual, f"Test failed for timestamp {ts}. Expected: {expectation}, Actual: {actual}"
+            
+    def test_timestamp_to_active_trading_regions(self):
+        test_timestamps = [
+            1672531200000,  # 2023-01-01 00:00:00 UTC (APAC)
+            1672563600000,  # 2023-01-01 09:00:00 UTC (APAC, EMEA)
+            1672574400000,  # 2023-01-01 12:00:00 UTC (EMEA)
+            1672588800000,  # 2023-01-01 16:00:00 UTC (EMEA, AMER)
+            1672599600000,  # 2023-01-01 19:00:00 UTC (AMER)
+            1672610400000,  # 2023-01-01 22:00:00 UTC (APAC)
+        ]
+
+        expectations = [ ['APAC'], ['APAC', 'EMEA'], ['EMEA'], ['EMEA','AMER'], ['AMER'], ['APAC']]
+
+        i = 0
+        for ts in test_timestamps:
+            expectation = expectations[i]
+            actual = timestamp_to_active_trading_regions(ts)
+            assert(expectation==actual)
+            i+=1
+        
+    def test_ticker_change_map_util(self):
+        '''
+        Example OKX managers decide to give work to customers https://www.okx.com/help/okx-will-rename-xautusdt-perpetual-to-xauusdt-perpetual
+            OKX to rename XAUTUSDT perpetual to XAUUSDT perpetual📣 
+
+                🗓 8:05 am on Jan 15, 2026 (UTC)    --> Timestamp in sec: 1768464300
+                1️⃣Trading of XAUTUSDT perpetual will be suspended from 8:05 am to 8:25 am on Jan 15, 2026 (UTC)
+                2️⃣Following aspects may also be affected:
+                • Margin requirements (if you are using PM mode to trade this perpetual)
+                • Index & funding fee
+                • Trading bots & strategy orders
+                • OpenAPI & WebSocket
+        '''
+        ticker_change_map_file : str = 'ticker_change_map.json'
+
+        ticker_change_map : List[Dict[str, Union[str, int]]] = [
+            {
+                'new_ticker' : 'XAU/USDT:USDT',
+                'old_ticker' : 'XAUT/USDT:USDT',
+                'cutoff_ms' : 1768464300000
+            }
+        ]
+
+        ticker : str = 'XAU/USDT:USDT'
+        old_ticker : Union[None, str] = get_old_ticker(ticker, ticker_change_map)
+        mapping : Union[None, Dict[str, Union[str, int]]] = get_ticker_map(ticker, ticker_change_map)
+        assert(old_ticker)
+        self.assertEqual(old_ticker, "XAUT/USDT:USDT")
+        assert(mapping)
+
+        ticker : str = '???/USDT:USDT'
+        old_ticker = get_old_ticker(ticker, ticker_change_map)
+        self.assertIsNone(old_ticker)
+
+        '''
+        with open(ticker_change_map_file, 'w', encoding='utf-8') as f:
+            json.dump(ticker_change_map, f, indent=2)
+
+        with open(ticker_change_map_file, 'r', encoding='utf-8') as f:
+            ticker_change_map_from_disk : List[Dict[str, Union[str, int]]] = json.load(f)
+        '''
+
+            

siglab_py/tests/unit/simple_math_tests.py

@@ -0,0 +1,252 @@
+import unittest
+from typing import List, Dict, Union
+
+from numpy import equal
+
+from util.simple_math import generate_rand_nums, round_to_level, compute_adjacent_levels, 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_compute_adjacent_levels(self):
+        gold_price = 4450
+        level_granularity = 0.025 # So levels are $100 apart
+        adjacent_levels = compute_adjacent_levels(num=gold_price, level_granularity=level_granularity, num_levels_per_side=3)
+        assert(adjacent_levels)
+        assert(len(adjacent_levels)==7)
+        equal(adjacent_levels, [4100,4200,4300,4400,4500,4600,4700])
+
+        btc_price = 95000
+        level_granularity = 0.01 # So levels are $1000 apart
+        adjacent_levels = compute_adjacent_levels(num=btc_price, level_granularity=level_granularity, num_levels_per_side=3)
+        assert(adjacent_levels)
+        assert(len(adjacent_levels)==7)
+        equal(adjacent_levels, [92000,93000,94000,95000,96000,97000,98000])
+
+    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
+                                )