siglab-py 0.1.38__py3-none-any.whl → 0.1.51__py3-none-any.whl

siglab_py/market_data_providers/ccxt_candles_ta_to_csv.py

@@ -26,7 +26,7 @@ from siglab_py.util.analytic_util import compute_candles_stats
 '''
 Usage:
     set PYTHONPATH=%PYTHONPATH%;D:\dev\siglab\siglab_py
-    python ccxt_candles_ta_to_csv.py --exchange_name bybit --symbol BTC/USDT:USDT --end_date "2025-03-25 0:0:0" --start_date "2021-03-11 0:0:0" --default_type linear --compute_ta Y --pypy_compatible N
+    python ccxt_candles_ta_to_csv.py --exchange_name bybit --symbol BTC/USDT:USDT --end_date "2025-03-11 0:0:0" --start_date "2021-03-11 0:0:0" --default_type linear --compute_ta Y --pypy_compatible N
 
     (Remember: python -mpip install siglab_py)
 
@@ -225,7 +225,6 @@ async def main():
                                     boillenger_std_multiples=param['boillenger_std_multiples'], 
                                     sliding_window_how_many_candles=param['ma_long_intervals'], 
                                     slow_fast_interval_ratio=(param['ma_long_intervals']/param['ma_short_intervals']),
-                                    hurst_exp_window_how_many_candles=param['ma_short_intervals'],
                                     pypy_compat=param['pypy_compatible']
                                 )
         compute_candles_stats_elapsed_ms = int((time.time() - start) *1000)

siglab_py/ordergateway/client.py

@@ -91,6 +91,9 @@ class DivisiblePosition(Order):
         self.fees : Union[float, None] = None
         self.pos : Union[float, None] = None # in base ccy, after execution. (Not in USDT or quote ccy, Not in # contracts)
 
+        self.done : bool = False
+        self.execution_err : str = ""
+
         self.dispatched_slices : List[Order] = []
         self.executions : Dict[str, Dict[str, Any]] = {}
 
@@ -325,6 +328,8 @@ class DivisiblePosition(Order):
         rv['filled_amount'] = self.filled_amount
         rv['average_cost'] = self.average_cost
         rv['pos'] = self.pos
+        rv['done'] = self.done
+        rv['execution_err'] = self.execution_err
         return rv
 
 def execute_positions(

siglab_py/ordergateway/gateway.py

@@ -446,251 +446,258 @@ async def execute_one_position(
     param : Dict,
     executions : Dict[str, Dict[str, Any]]
 ):
-    market : Dict[str, Any] = exchange.markets[position.ticker] if position.ticker in exchange.markets else None # type: ignore
-    if not market:
-        raise ArgumentError(f"Market not found for {position.ticker} under {exchange.name}") # type: ignore
-
-    min_amount = float(market['limits']['amount']['min']) if market['limits']['amount']['min'] else 0 # type: ignore
-    multiplier = market['contractSize'] if 'contractSize' in market and market['contractSize'] else 1
-    position.multiplier = multiplier
-
-    slices : List[Order] = position.to_slices()
-    i = 0
-    for slice in slices:
-        try:
-            dt_now : datetime = datetime.now()
-
-            slice_amount_in_base_ccy : float = slice.amount
-            rounded_slice_amount_in_base_ccy = slice_amount_in_base_ccy / multiplier # After divided by multiplier, rounded_slice_amount_in_base_ccy in number of contracts actually (Not in base ccy).
-            rounded_slice_amount_in_base_ccy = exchange.amount_to_precision(position.ticker, rounded_slice_amount_in_base_ccy) # type: ignore
-            rounded_slice_amount_in_base_ccy = float(rounded_slice_amount_in_base_ccy) if rounded_slice_amount_in_base_ccy else 0
-            rounded_slice_amount_in_base_ccy = rounded_slice_amount_in_base_ccy if rounded_slice_amount_in_base_ccy>min_amount else min_amount
-
-            if rounded_slice_amount_in_base_ccy==0:
-                log(f"{position.ticker} Slice amount rounded to zero?! slice amount before rounding: {slice.amount}") 
-                continue
-
-            orderbook = await exchange.fetch_order_book(symbol=position.ticker, limit=3) # type: ignore
-            if position.side=='buy':
-                asks = [ ask[0] for ask in orderbook['asks'] ]
-                best_asks = min(asks)
-                limit_price : float= best_asks * (1 + position.leg_room_bps/10000)
-            else:
-                bids = [ bid[0] for bid in orderbook['bids'] ]
-                best_bid = max(bids)
-                limit_price : float = best_bid * (1 - position.leg_room_bps/10000)
-                
-            rounded_limit_price : float = exchange.price_to_precision(position.ticker, limit_price) # type: ignore
-            rounded_limit_price = float(rounded_limit_price)
-            
-            order_params = {
-                'reduceOnly': slice.reduce_only
-            }
-            if position.order_type=='limit':
-                if not param['dry_run']:
-                    executed_order = await exchange.create_order( # type: ignore
-                        symbol = position.ticker,
-                        type = position.order_type,
-                        amount = rounded_slice_amount_in_base_ccy,
-                        price = rounded_limit_price,
-                        side = position.side,
-                        params = order_params
-                    )
-                else:
-                    executed_order = DUMMY_EXECUTION.copy()
-                    executed_order['clientOrderId'] = str(uuid.uuid4())
-                    executed_order['timestamp'] = dt_now.timestamp()
-                    executed_order['datetime'] = dt_now
-                    executed_order['symbol'] = position.ticker
-                    executed_order['type'] = position.order_type
-                    executed_order['side'] = position.side
-                    executed_order['price'] = rounded_limit_price
-                    executed_order['average'] = rounded_limit_price
-                    executed_order['cost'] = 0
-                    executed_order['amount'] = rounded_slice_amount_in_base_ccy
-                    executed_order['filled'] = rounded_slice_amount_in_base_ccy
-                    executed_order['remaining'] = 0
-                    executed_order['status'] = 'closed'
-                    executed_order['multiplier'] = position.multiplier
-
-            else:
-                if not param['dry_run']:
-                    executed_order = await exchange.create_order( # type: ignore
-                        symbol = position.ticker,
-                        type = position.order_type,
-                        amount = rounded_slice_amount_in_base_ccy,
-                        side = position.side,
-                        params = order_params
-                    )
+    try:
+        market : Dict[str, Any] = exchange.markets[position.ticker] if position.ticker in exchange.markets else None # type: ignore
+        if not market:
+            raise ArgumentError(f"Market not found for {position.ticker} under {exchange.name}") # type: ignore
+
+        min_amount = float(market['limits']['amount']['min']) if market['limits']['amount']['min'] else 0 # type: ignore
+        multiplier = market['contractSize'] if 'contractSize' in market and market['contractSize'] else 1
+        position.multiplier = multiplier
+
+        slices : List[Order] = position.to_slices()
+        i = 0
+        for slice in slices:
+            try:
+                dt_now : datetime = datetime.now()
+
+                slice_amount_in_base_ccy : float = slice.amount
+                rounded_slice_amount_in_base_ccy = slice_amount_in_base_ccy / multiplier # After divided by multiplier, rounded_slice_amount_in_base_ccy in number of contracts actually (Not in base ccy).
+                rounded_slice_amount_in_base_ccy = exchange.amount_to_precision(position.ticker, rounded_slice_amount_in_base_ccy) # type: ignore
+                rounded_slice_amount_in_base_ccy = float(rounded_slice_amount_in_base_ccy) if rounded_slice_amount_in_base_ccy else 0
+                rounded_slice_amount_in_base_ccy = rounded_slice_amount_in_base_ccy if rounded_slice_amount_in_base_ccy>min_amount else min_amount
+
+                if rounded_slice_amount_in_base_ccy==0:
+                    log(f"{position.ticker} Slice amount rounded to zero?! slice amount before rounding: {slice.amount}") 
+                    continue
+
+                orderbook = await exchange.fetch_order_book(symbol=position.ticker, limit=3) # type: ignore
+                if position.side=='buy':
+                    asks = [ ask[0] for ask in orderbook['asks'] ]
+                    best_asks = min(asks)
+                    limit_price : float= best_asks * (1 + position.leg_room_bps/10000)
                 else:
-                    executed_order = DUMMY_EXECUTION.copy()
-                    executed_order['clientOrderId'] = str(uuid.uuid4())
-                    executed_order['timestamp'] = dt_now.timestamp()
-                    executed_order['datetime'] = dt_now
-                    executed_order['symbol'] = position.ticker
-                    executed_order['type'] = position.order_type
-                    executed_order['side'] = position.side
-                    executed_order['price'] = rounded_limit_price
-                    executed_order['average'] = rounded_limit_price
-                    executed_order['cost'] = 0
-                    executed_order['amount'] = rounded_slice_amount_in_base_ccy
-                    executed_order['filled'] = rounded_slice_amount_in_base_ccy
-                    executed_order['remaining'] = 0
-                    executed_order['status'] = 'closed'
-                    executed_order['multiplier'] = position.multiplier
-
-            executed_order['slice_id'] = i
-
-            '''
-            Format of executed_order:
-                executed_order
-                {'info': {'clOrdId': 'xxx', 'ordId': '2245241151525347328', 'sCode': '0', 'sMsg': 'Order placed', 'tag': 'xxx', 'ts': '1739415800635'}, 'id': '2245241151525347328', 'clientOrderId': 'xxx', 'timestamp': None, 'datetime': None, 'lastTradeTimestamp': None, 'lastUpdateTimestamp': None, 'symbol': 'SUSHI/USDT:USDT', 'type': 'limit', 'timeInForce': None, 'postOnly': None, 'side': 'buy', 'price': None, 'stopLossPrice': None, 'takeProfitPrice': None, 'triggerPrice': None, 'average': None, 'cost': None, 'amount': None, 'filled': None, 'remaining': None, 'status': None, 'fee': None, 'trades': [], 'reduceOnly': False, 'fees': [], 'stopPrice': None}
-                special variables:
-                function variables:
-                'info': {'clOrdId': 'xxx', 'ordId': '2245241151525347328', 'sCode': '0', 'sMsg': 'Order placed', 'tag': 'xxx', 'ts': '1739415800635'}
-                'id': '2245241151525347328'
-                'clientOrderId': 'xxx'
-                'timestamp': None
-                'datetime': None
-                'lastTradeTimestamp': None
-                'lastUpdateTimestamp': None
-                'symbol': 'SUSHI/USDT:USDT'
-                'type': 'limit'
-                'timeInForce': None
-                'postOnly': None
-                'side': 'buy'
-                'price': None
-                'stopLossPrice': None
-                'takeProfitPrice': None
-                'triggerPrice': None
-                'average': None
-                'cost': None
-                'amount': None
-                'filled': None
-                'remaining': None
-                'status': None
-                'fee': None
-                'trades': []
-                'reduceOnly': False
-                'fees': []
-                'stopPrice': None
-            '''
-            order_id = executed_order['id']
-            order_status = executed_order['status']
-            filled_amount = executed_order['filled']
-            remaining_amount = executed_order['remaining']
-            executed_order['multiplier'] = multiplier
-            position.append_execution(order_id, executed_order)
-
-            log(f"Order dispatched: {order_id}. status: {order_status}, filled_amount: {filled_amount}, remaining_amount: {remaining_amount}")
-
-            if not order_status or order_status!='closed':
-                start_time = time.time()
-                wait_threshold_sec = position.wait_fill_threshold_ms / 1000 
-
-                elapsed_sec = time.time() - start_time
-                while elapsed_sec < wait_threshold_sec:
-                    order_update = None
-                    if order_id in executions:
-                        order_update = executions[order_id]
+                    bids = [ bid[0] for bid in orderbook['bids'] ]
+                    best_bid = max(bids)
+                    limit_price : float = best_bid * (1 - position.leg_room_bps/10000)
                     
-                    if order_update:
-                        order_status = order_update['status']
-                        filled_amount = order_update['filled']
-                        remaining_amount = order_update['remaining']
-                        order_update['multiplier'] = multiplier
-                        position.append_execution(order_id, order_update)
-
-                        if remaining_amount <= 0:
-                            log(f"Limit order fully filled: {order_id}", log_level=LogLevel.INFO)
-                            break
+                rounded_limit_price : float = exchange.price_to_precision(position.ticker, limit_price) # type: ignore
+                rounded_limit_price = float(rounded_limit_price)
+                
+                order_params = {
+                    'reduceOnly': slice.reduce_only
+                }
+                if position.order_type=='limit':
+                    if not param['dry_run']:
+                        executed_order = await exchange.create_order( # type: ignore
+                            symbol = position.ticker,
+                            type = position.order_type,
+                            amount = rounded_slice_amount_in_base_ccy,
+                            price = rounded_limit_price,
+                            side = position.side,
+                            params = order_params
+                        )
+                    else:
+                        executed_order = DUMMY_EXECUTION.copy()
+                        executed_order['clientOrderId'] = str(uuid.uuid4())
+                        executed_order['timestamp'] = dt_now.timestamp()
+                        executed_order['datetime'] = dt_now
+                        executed_order['symbol'] = position.ticker
+                        executed_order['type'] = position.order_type
+                        executed_order['side'] = position.side
+                        executed_order['price'] = rounded_limit_price
+                        executed_order['average'] = rounded_limit_price
+                        executed_order['cost'] = 0
+                        executed_order['amount'] = rounded_slice_amount_in_base_ccy
+                        executed_order['filled'] = rounded_slice_amount_in_base_ccy
+                        executed_order['remaining'] = 0
+                        executed_order['status'] = 'closed'
+                        executed_order['multiplier'] = position.multiplier
 
-                    await asyncio.sleep(int(param['loop_freq_ms']/1000))
-            
-            
-            # Cancel hung limit order, resend as market
-            if order_status!='closed':
-                # If no update from websocket, do one last fetch via REST
-                order_update = await exchange.fetch_order(order_id, position.ticker) # type: ignore 
-                order_status = order_update['status']
-                filled_amount = order_update['filled']
-                remaining_amount = order_update['remaining']
-                order_update['multiplier'] = multiplier
-                position.append_execution(order_id, order_update)
-
-                if order_status!='closed': 
+                else:
+                    if not param['dry_run']:
+                        executed_order = await exchange.create_order( # type: ignore
+                            symbol = position.ticker,
+                            type = position.order_type,
+                            amount = rounded_slice_amount_in_base_ccy,
+                            side = position.side,
+                            params = order_params
+                        )
+                    else:
+                        executed_order = DUMMY_EXECUTION.copy()
+                        executed_order['clientOrderId'] = str(uuid.uuid4())
+                        executed_order['timestamp'] = dt_now.timestamp()
+                        executed_order['datetime'] = dt_now
+                        executed_order['symbol'] = position.ticker
+                        executed_order['type'] = position.order_type
+                        executed_order['side'] = position.side
+                        executed_order['price'] = rounded_limit_price
+                        executed_order['average'] = rounded_limit_price
+                        executed_order['cost'] = 0
+                        executed_order['amount'] = rounded_slice_amount_in_base_ccy
+                        executed_order['filled'] = rounded_slice_amount_in_base_ccy
+                        executed_order['remaining'] = 0
+                        executed_order['status'] = 'closed'
+                        executed_order['multiplier'] = position.multiplier
+
+                executed_order['slice_id'] = i
+
+                '''
+                Format of executed_order:
+                    executed_order
+                    {'info': {'clOrdId': 'xxx', 'ordId': '2245241151525347328', 'sCode': '0', 'sMsg': 'Order placed', 'tag': 'xxx', 'ts': '1739415800635'}, 'id': '2245241151525347328', 'clientOrderId': 'xxx', 'timestamp': None, 'datetime': None, 'lastTradeTimestamp': None, 'lastUpdateTimestamp': None, 'symbol': 'SUSHI/USDT:USDT', 'type': 'limit', 'timeInForce': None, 'postOnly': None, 'side': 'buy', 'price': None, 'stopLossPrice': None, 'takeProfitPrice': None, 'triggerPrice': None, 'average': None, 'cost': None, 'amount': None, 'filled': None, 'remaining': None, 'status': None, 'fee': None, 'trades': [], 'reduceOnly': False, 'fees': [], 'stopPrice': None}
+                    special variables:
+                    function variables:
+                    'info': {'clOrdId': 'xxx', 'ordId': '2245241151525347328', 'sCode': '0', 'sMsg': 'Order placed', 'tag': 'xxx', 'ts': '1739415800635'}
+                    'id': '2245241151525347328'
+                    'clientOrderId': 'xxx'
+                    'timestamp': None
+                    'datetime': None
+                    'lastTradeTimestamp': None
+                    'lastUpdateTimestamp': None
+                    'symbol': 'SUSHI/USDT:USDT'
+                    'type': 'limit'
+                    'timeInForce': None
+                    'postOnly': None
+                    'side': 'buy'
+                    'price': None
+                    'stopLossPrice': None
+                    'takeProfitPrice': None
+                    'triggerPrice': None
+                    'average': None
+                    'cost': None
+                    'amount': None
+                    'filled': None
+                    'remaining': None
+                    'status': None
+                    'fee': None
+                    'trades': []
+                    'reduceOnly': False
+                    'fees': []
+                    'stopPrice': None
+                '''
+                order_id = executed_order['id']
+                order_status = executed_order['status']
+                filled_amount = executed_order['filled']
+                remaining_amount = executed_order['remaining']
+                executed_order['multiplier'] = multiplier
+                position.append_execution(order_id, executed_order)
+
+                log(f"Order dispatched: {order_id}. status: {order_status}, filled_amount: {filled_amount}, remaining_amount: {remaining_amount}")
+
+                if not order_status or order_status!='closed':
+                    start_time = time.time()
+                    wait_threshold_sec = position.wait_fill_threshold_ms / 1000 
+
+                    elapsed_sec = time.time() - start_time
+                    while elapsed_sec < wait_threshold_sec:
+                        order_update = None
+                        if order_id in executions:
+                            order_update = executions[order_id]
+                        
+                        if order_update:
+                            order_status = order_update['status']
+                            filled_amount = order_update['filled']
+                            remaining_amount = order_update['remaining']
+                            order_update['multiplier'] = multiplier
+                            position.append_execution(order_id, order_update)
+
+                            if remaining_amount <= 0:
+                                log(f"Limit order fully filled: {order_id}", log_level=LogLevel.INFO)
+                                break
+
+                        await asyncio.sleep(int(param['loop_freq_ms']/1000))
+                
+                
+                # Cancel hung limit order, resend as market
+                if order_status!='closed':
+                    # If no update from websocket, do one last fetch via REST
+                    order_update = await exchange.fetch_order(order_id, position.ticker) # type: ignore 
                     order_status = order_update['status']
                     filled_amount = order_update['filled']
                     remaining_amount = order_update['remaining']
+                    order_update['multiplier'] = multiplier
+                    position.append_execution(order_id, order_update)
 
-                    await exchange.cancel_order(order_id, position.ticker)  # type: ignore
-                    position.get_execution(order_id)['status'] = 'canceled'
-                    log(f"Canceled unfilled/partial filled order: {order_id}. Resending remaining_amount: {remaining_amount} as market order.", log_level=LogLevel.INFO)
-                    
-                    rounded_slice_amount_in_base_ccy = exchange.amount_to_precision(position.ticker, remaining_amount) # type: ignore
-                    rounded_slice_amount_in_base_ccy = float(rounded_slice_amount_in_base_ccy)
-                    rounded_slice_amount_in_base_ccy = rounded_slice_amount_in_base_ccy if rounded_slice_amount_in_base_ccy>min_amount else min_amount
-                    if rounded_slice_amount_in_base_ccy>0:
-                        executed_resent_order = await exchange.create_order(  # type: ignore
-                            symbol=position.ticker,
-                            type='market',
-                            amount=remaining_amount,
-                            side=position.side
-                        )
-
-                        order_id = executed_resent_order['id']
-                        order_status = executed_resent_order['status']
-                        executed_resent_order['multiplier'] = multiplier
-                        position.append_execution(order_id, executed_resent_order)
-
-                        while not order_status or order_status!='closed':
-                            order_update = None
-                            if order_id in executions:
-                                order_update = executions[order_id]
-
-                            if order_update:
-                                order_id = order_update['id']
-                                order_status = order_update['status']
-                                filled_amount = order_update['filled']
-                                remaining_amount = order_update['remaining']
-
-                            log(f"Waiting for resent market order to close {order_id} ...")
+                    if order_status!='closed': 
+                        order_status = order_update['status']
+                        filled_amount = order_update['filled']
+                        remaining_amount = order_update['remaining']
 
-                            await asyncio.sleep(int(param['loop_freq_ms']/1000))
+                        await exchange.cancel_order(order_id, position.ticker)  # type: ignore
+                        position.get_execution(order_id)['status'] = 'canceled'
+                        log(f"Canceled unfilled/partial filled order: {order_id}. Resending remaining_amount: {remaining_amount} as market order.", log_level=LogLevel.INFO)
+                        
+                        rounded_slice_amount_in_base_ccy = exchange.amount_to_precision(position.ticker, remaining_amount) # type: ignore
+                        rounded_slice_amount_in_base_ccy = float(rounded_slice_amount_in_base_ccy)
+                        rounded_slice_amount_in_base_ccy = rounded_slice_amount_in_base_ccy if rounded_slice_amount_in_base_ccy>min_amount else min_amount
+                        if rounded_slice_amount_in_base_ccy>0:
+                            executed_resent_order = await exchange.create_order(  # type: ignore
+                                symbol=position.ticker,
+                                type='market',
+                                amount=remaining_amount,
+                                side=position.side
+                            )
+
+                            order_id = executed_resent_order['id']
+                            order_status = executed_resent_order['status']
+                            executed_resent_order['multiplier'] = multiplier
+                            position.append_execution(order_id, executed_resent_order)
+
+                            while not order_status or order_status!='closed':
+                                order_update = None
+                                if order_id in executions:
+                                    order_update = executions[order_id]
+
+                                if order_update:
+                                    order_id = order_update['id']
+                                    order_status = order_update['status']
+                                    filled_amount = order_update['filled']
+                                    remaining_amount = order_update['remaining']
+
+                                log(f"Waiting for resent market order to close {order_id} ...")
+
+                                await asyncio.sleep(int(param['loop_freq_ms']/1000))
+
+                            log(f"Resent market order{order_id} filled. status: {order_status}, filled_amount: {filled_amount}, remaining_amount: {remaining_amount}")
+
+                slice.dispatched_price = rounded_limit_price
+                slice.dispatched_amount = rounded_slice_amount_in_base_ccy
+                position.dispatched_slices.append(slice)
+
+                log(f"Executed slice #{i}", log_level=LogLevel.INFO)
+                log(f"{position.ticker}, multiplier: {multiplier}, slice_amount_in_base_ccy: {slice_amount_in_base_ccy}, rounded_slice_amount_in_base_ccy, {rounded_slice_amount_in_base_ccy}", log_level=LogLevel.INFO)
+                if position.order_type=='limit':
+                    log(f"{position.ticker}, limit_price: {limit_price}, rounded_limit_price, {rounded_limit_price}", log_level=LogLevel.INFO)
+
+            except Exception as slice_err:
+                log(
+                    f"Failed to execute #{i} slice: {slice.to_dict()}. {slice_err} {str(sys.exc_info()[0])} {str(sys.exc_info()[1])} {traceback.format_exc()}",
+                    log_level=LogLevel.ERROR
+                    )
+            finally:
+                i += 1
 
-                        log(f"Resent market order{order_id} filled. status: {order_status}, filled_amount: {filled_amount}, remaining_amount: {remaining_amount}")
+        position.patch_executions()
+        position.filled_amount = position.get_filled_amount()
+        position.average_cost = position.get_average_cost()
+        position.fees = position.get_fees()
 
-            slice.dispatched_price = rounded_limit_price
-            slice.dispatched_amount = rounded_slice_amount_in_base_ccy
-            position.dispatched_slices.append(slice)
+        balances = await exchange.fetch_balance() # type: ignore
+        if param['default_type']!='spot':
+            updated_position = await exchange.fetch_position(symbol=position.ticker) # type: ignore
+            # After position closed, 'updated_position' can be an empty dict. hyperliquid for example.
+            amount = (updated_position['contracts'] if updated_position else 0) * position.multiplier # in base ccy
+        else:
+            base_ccy : str = position.ticker.split("/")[0]
+            amount = balances[base_ccy]['total']
+        position.pos = amount
 
-            log(f"Executed slice #{i}", log_level=LogLevel.INFO)
-            log(f"{position.ticker}, multiplier: {multiplier}, slice_amount_in_base_ccy: {slice_amount_in_base_ccy}, rounded_slice_amount_in_base_ccy, {rounded_slice_amount_in_base_ccy}", log_level=LogLevel.INFO)
-            if position.order_type=='limit':
-                log(f"{position.ticker}, limit_price: {limit_price}, rounded_limit_price, {rounded_limit_price}", log_level=LogLevel.INFO)
+        position.done = True
 
-        except Exception as slice_err:
-            log(
-                f"Failed to execute #{i} slice: {slice.to_dict()}. {slice_err} {str(sys.exc_info()[0])} {str(sys.exc_info()[1])} {traceback.format_exc()}",
-                log_level=LogLevel.ERROR
-                )
-        finally:
-            i += 1
-
-    position.patch_executions()
-    position.filled_amount = position.get_filled_amount()
-    position.average_cost = position.get_average_cost()
-    position.fees = position.get_fees()
-
-    balances = await exchange.fetch_balance() # type: ignore
-    if param['default_type']!='spot':
-        updated_position = await exchange.fetch_position(symbol=position.ticker) # type: ignore
-        # After position closed, 'updated_position' can be an empty dict. hyperliquid for example.
-        amount = (updated_position['contracts'] if updated_position else 0) * position.multiplier # in base ccy
-    else:
-        base_ccy : str = position.ticker.split("/")[0]
-        amount = balances[base_ccy]['total']
-    position.pos = amount
+    except Exception as position_execution_err:
+        position.done = False
+        position.execution_err = position_execution_err
 
 async def work(
     param : Dict,

siglab_py/util/market_data_util.py

@@ -21,7 +21,7 @@ def timestamp_to_datetime_cols(pd_candles : pd.DataFrame):
     pd_candles['timestamp_ms'] = pd_candles['timestamp_ms'].apply(
         lambda x: int(x.timestamp()) if isinstance(x, pd.Timestamp) else (int(x) if len(str(int(x)))==13 else int(x*1000)) 
     )
-    pd_candles['datetime'] = pd_candles['timestamp_ms'].apply(lambda x: datetime.fromtimestamp(int(x)))
+    pd_candles['datetime'] = pd_candles['timestamp_ms'].apply(lambda x: datetime.fromtimestamp(int(x/1000)))
     pd_candles['datetime'] = pd.to_datetime(pd_candles['datetime'])
     pd_candles['datetime'] = pd_candles['datetime'].dt.tz_localize(None)
     pd_candles['datetime_utc'] = pd_candles['timestamp_ms'].apply(
@@ -37,17 +37,17 @@ def timestamp_to_datetime_cols(pd_candles : pd.DataFrame):
     pd_candles['dayofweek'] = pd_candles['datetime'].dt.dayofweek  # dayofweek: Monday is 0 and Sunday is 6
 
     pd_candles['week_of_month'] = pd_candles['timestamp_ms'].apply(
-        lambda x: timestamp_to_week_of_month(x)
+        lambda x: timestamp_to_week_of_month(int(x/1000))
     )
 
     pd_candles['apac_trading_hr'] = pd_candles['timestamp_ms'].apply(
-        lambda x: "APAC" in timestamp_to_active_trading_regions(x)
+        lambda x: "APAC" in timestamp_to_active_trading_regions(int(x/1000))
     )
     pd_candles['emea_trading_hr'] = pd_candles['timestamp_ms'].apply(
-        lambda x: "EMEA" in timestamp_to_active_trading_regions(x)
+        lambda x: "EMEA" in timestamp_to_active_trading_regions(int(x/1000))
     )
     pd_candles['amer_trading_hr'] = pd_candles['timestamp_ms'].apply(
-        lambda x: "AMER" in timestamp_to_active_trading_regions(x)
+        lambda x: "AMER" in timestamp_to_active_trading_regions(int(x/1000))
     )
 
 def timestamp_to_active_trading_regions(

{siglab_py-0.1.38.dist-info → siglab_py-0.1.51.dist-info}/METADATA

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

{siglab_py-0.1.38.dist-info → siglab_py-0.1.51.dist-info}/RECORD

@@ -7,15 +7,15 @@ siglab_py/market_data_providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm
 siglab_py/market_data_providers/aggregated_orderbook_provider.py,sha256=FZRobEBNRzcNGlOG3u38OVhmOZYlkNm8dVvR-S7Ii2g,23342
 siglab_py/market_data_providers/candles_provider.py,sha256=fqHJjlECsBiBlpgyywrc4gTgxiROPNzZM8KxQBB5cOg,14139
 siglab_py/market_data_providers/candles_ta_provider.py,sha256=uiAhbEZZdTF-YulBHpSLwabos5LHCKU91NTiTmpUc0w,12001
-siglab_py/market_data_providers/ccxt_candles_ta_to_csv.py,sha256=xQh2N1Qc9Exs2ODPeH4S1rt4tNWLp-_qDp-Puox6Baw,11239
+siglab_py/market_data_providers/ccxt_candles_ta_to_csv.py,sha256=8-cKcZXFBHLX_-KmPXBKv1QNqJYUdDp6iqa1miVlpF8,11139
 siglab_py/market_data_providers/deribit_options_expiry_provider.py,sha256=e9Ee8TmC8pXaid8-jouSLKIpuW6_JBBgwRTieI665yQ,8684
 siglab_py/market_data_providers/futu_candles_ta_to_csv.py,sha256=S4GXaJ7AveEh-Cm9-VhENBdlj_1CfyBTrQO7acTqfUE,10226
 siglab_py/market_data_providers/orderbooks_provider.py,sha256=olt-3LIkoyzQWfNNQRhJtKibLbkTutt_q_rCCTM7i1g,16216
 siglab_py/market_data_providers/test_provider.py,sha256=wBLCgcWjs7FGZJXWsNyn30lkOLa_cgpuvqRakMC0wbA,2221
 siglab_py/ordergateway/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-siglab_py/ordergateway/client.py,sha256=gtUyR41xXuAcBNoVCSlcg99koiQphe8gUBxlEgvWYt8,14637
+siglab_py/ordergateway/client.py,sha256=sn9_QqoJwQC0Aj89icOReztW_D4LxPt9g93vCSI5-j4,14794
 siglab_py/ordergateway/encrypt_keys_util.py,sha256=-qi87db8To8Yf1WS1Q_Cp2Ya7ZqgWlRqSHfNXCM7wE4,1339
-siglab_py/ordergateway/gateway.py,sha256=VI-OIc3enhQ78cFNzAbLgX0Pzyjr2tl9VDV3IZTAtMQ,37438
+siglab_py/ordergateway/gateway.py,sha256=Owq7QquD3pmvzXft0wkDHs_rMmt7kiXT771ZmG02BA8,38495
 siglab_py/ordergateway/test_ordergateway.py,sha256=_Gz2U_VqljogGWqGyNDYYls1INqUiig9veyPttfGRpg,3901
 siglab_py/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 siglab_py/tests/integration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -26,9 +26,9 @@ siglab_py/tests/unit/market_data_util_tests.py,sha256=A1y83itISmMJdn6wLpfwcr4tGo
 siglab_py/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 siglab_py/util/analytic_util.py,sha256=xo9gD1ELQt_1v84yu9d4NgxtOIXthePZGipvDrjZAQ8,43834
 siglab_py/util/aws_util.py,sha256=KGmjHrr1rpnnxr33nXHNzTul4tvyyxl9p6gpwNv0Ygc,2557
-siglab_py/util/market_data_util.py,sha256=RZ-N8UerEC3svMkJ74ab4eKocWvROCHaOykd9oog85w,19441
+siglab_py/util/market_data_util.py,sha256=QJGYIO-ixzjbOm3pY1koiDd_UV5-_QS7JrwuaCn7kug,19486
 siglab_py/util/retry_util.py,sha256=mxYuRFZRZoaQQjENcwPmxhxixtd1TFvbxIdPx4RwfRc,743
-siglab_py-0.1.38.dist-info/METADATA,sha256=B-M6RDjMYbWaYSFPNvQ5fkVovEZXI6B1mlQDhKG_Qvw,980
-siglab_py-0.1.38.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-siglab_py-0.1.38.dist-info/top_level.txt,sha256=AbD4VR9OqmMOGlMJLkAVPGQMtUPIQv0t1BF5xmcLJSk,10
-siglab_py-0.1.38.dist-info/RECORD,,
+siglab_py-0.1.51.dist-info/METADATA,sha256=-_AbTmpyR4M72ARWFjPXg7V0oTHsPUU3S5N775NfhvA,980
+siglab_py-0.1.51.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+siglab_py-0.1.51.dist-info/top_level.txt,sha256=AbD4VR9OqmMOGlMJLkAVPGQMtUPIQv0t1BF5xmcLJSk,10
+siglab_py-0.1.51.dist-info/RECORD,,