siglab-py 0.1.0__py3-none-any.whl

siglab_py/ordergateway/test_ordergateway.py

@@ -0,0 +1,140 @@
+from enum import Enum
+import argparse
+import time
+from datetime import datetime
+from typing import Any, Dict, List, Union
+import logging
+import json
+import pandas as pd
+import numpy as np
+from redis import StrictRedis
+
+from ordergateway.client import DivisiblePosition
+
+'''
+set PYTHONPATH=%PYTHONPATH%;D:\dev\siglab\siglab_py
+python test_ordergateway.py --gateway_id bybit_01
+'''
+
+param : Dict[str, str] = {
+    'gateway_id' : '---'
+}
+
+def parse_args():
+    parser = argparse.ArgumentParser() # type: ignore
+    parser.add_argument("--gateway_id", help="gateway_id: Where are you sending your order?", default=None)
+
+    args = parser.parse_args()
+    param['gateway_id'] = args.gateway_id
+
+def init_redis_client() -> StrictRedis:
+    redis_client : StrictRedis = StrictRedis(
+                    host = 'localhost',
+                    port = 6379,
+                    db = 0,
+                    ssl = False
+                )
+    try:
+        redis_client.keys()
+    except ConnectionError as redis_conn_error:
+        err_msg = f"Failed to connect to redis: {'localhost'}, port: {6379}"
+        raise ConnectionError(err_msg)
+    
+    return redis_client
+
+def execute_positions(
+    redis_client : StrictRedis, 
+    positions : List[DivisiblePosition], 
+    ordergateway_pending_orders_topic : str):
+    # https://redis.io/commands/publish/
+    _positions = [ position.to_dict() for position in positions ]
+    redis_client.set(name=ordergateway_pending_orders_topic, value=json.dumps(_positions).encode('utf-8'), ex=60*15)
+
+    print(f"{ordergateway_pending_orders_topic}: Orders sent {_positions}.")
+
+if __name__ == '__main__':
+    parse_args()
+
+    gateway_id : str = param['gateway_id']
+    ordergateway_pending_orders_topic = 'ordergateway_pending_orders_$GATEWAY_ID$'
+    ordergateway_pending_orders_topic = ordergateway_pending_orders_topic.replace("$GATEWAY_ID$", gateway_id)
+    
+    ordergateway_executions_topic = "ordergateway_executions_$GATEWAY_ID$"
+    ordergateway_executions_topic = ordergateway_executions_topic.replace("$GATEWAY_ID$", gateway_id)
+
+    redis_client : StrictRedis = init_redis_client()
+
+    # Example, enter into a pair position long SUSHI, short DYDX
+    positions_1 : List[DivisiblePosition] = [
+        DivisiblePosition(
+            ticker = 'SUSHI/USDT:USDT',
+            side = 'sell',
+            amount = 10,
+            leg_room_bps = 5,
+            order_type = 'limit',
+            slices=5,
+            wait_fill_threshold_ms=15000
+        ),
+        DivisiblePosition(
+            ticker = 'DYDX/USDT:USDT',
+            side = 'buy',
+            amount = 10,
+            leg_room_bps = 5,
+            order_type = 'limit',
+            slices=5,
+            wait_fill_threshold_ms=15000
+        )
+    ]
+
+    positions_2 : List[DivisiblePosition] = [
+        DivisiblePosition(
+            ticker = 'SUSHI/USDT:USDT',
+            side = 'buy',
+            amount = 10,
+            leg_room_bps = 5,
+            order_type = 'limit',
+            slices=5,
+            wait_fill_threshold_ms=15000
+        ),
+    ]
+
+    positions_3 : List[DivisiblePosition] = [
+        DivisiblePosition(
+            ticker = 'BTC/USDT:USDT',
+            side = 'sell',
+            amount = 0.01,
+            leg_room_bps = 5,
+            order_type = 'limit',
+            slices=1,
+            wait_fill_threshold_ms=60000
+        )
+    ]
+    execute_positions(
+        redis_client=redis_client,
+        positions=positions_2,
+        ordergateway_pending_orders_topic=ordergateway_pending_orders_topic)
+
+    # Wait for fills
+    fills_received : bool = False
+    while not fills_received:
+        try:
+            keys = redis_client.keys()
+            for key in keys:
+                s_key : str = key.decode("utf-8")
+                if s_key==ordergateway_executions_topic:
+                    message = redis_client.get(key)
+                    if message:
+                        message = message.decode('utf-8')
+                        positions = json.loads(message)
+
+                        for position in 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'])}")
+                        fills_received = True
+                        break
+
+        except Exception as loop_err:
+            print(f"Oops {loop_err}")
+        finally:
+            time.sleep(1)
+
+    

siglab_py/tests/integration/market_data_util_tests.py

@@ -0,0 +1,123 @@
+import unittest
+from datetime import datetime
+from typing import Union
+from pathlib import Path
+
+from util.market_data_util import *
+
+from ccxt.binance import binance
+from ccxt.bybit import bybit
+from ccxt.okx import okx
+from ccxt.deribit import deribit
+from ccxt.base.exchange import Exchange
+
+# @unittest.skip("Skip all integration tests.")
+class MarketDataGizmoTests(unittest.TestCase):
+
+    def test_fetch_candles_yahoo(self):
+        start_date : datetime = datetime(2024, 1,1)
+        end_date : datetime = datetime(2024,12,31)
+
+        exchange = YahooExchange()
+        normalized_symbols = [ 'AAPL' ]
+        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'
+        )[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'}
+            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_nasdaq(self):
+        start_date : datetime = datetime(2023,1,1)
+        end_date : datetime = datetime(2023,12,31)
+
+        '''
+        Folder structure:
+            \ siglab
+                \ siglab_py	<-- python project root
+                    \ sigab_py
+                        __init__.py
+                        \ util
+                            __init__.py
+                            market_data_util.py
+                        \ tests
+                            \ integration
+                                __init__.py
+                                market_data_util_tests.py <-- Tests here
+                            
+                \ siglab_rs <-- Rust project root
+                \ data	 <-- Data files here!
+        '''
+        data_dir : Union[str, None] = str(Path(__file__).resolve().parents[3] / "data/nasdaq")
+        exchange : NASDAQExchange = NASDAQExchange(data_dir = data_dir)
+
+        # CSV from NASDAQ: https://www.nasdaq.com/market-activity/quotes/historical
+        normalized_symbols = [ 'AAPL' ]
+        # normalized_symbols = [ 'BABA', 'SPY', 'VOO', 'IVV', 'AAPL', 'AMZN', 'GOOG_classC', 'META', 'MSFT', 'MSTR', 'TSLA' ]
+
+        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'
+        )[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'}
+            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(self):
+        start_date : datetime = datetime(2024,1,1)
+        end_date : datetime = datetime(2024,12,31)
+
+        param = {
+            'apiKey' : None,
+            'secret' : None,
+            'password' : None,    # Other exchanges dont require this! This is saved in exchange.password!
+            'subaccount' : None,
+            'rateLimit' : 100,    # In ms
+            'options' : {
+                'defaultType': 'swap', # Should test linear instead
+                'leg_room_bps' : 5,
+                'trade_fee_bps' : 3,
+
+                'list_ts_field' : 'listTime' # list_ts_field: Response field in exchange.markets[symbol] to indiate timestamp of symbol's listing date in ms. For bybit, markets['launchTime'] is list date. For okx, it's markets['listTime'].
+            }
+        }
+
+        exchange : Exchange = okx(param)
+        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'
+        )[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'}
+            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."
+        
+