siglab-py 0.1.50__tar.gz → 0.1.52__tar.gz

{siglab_py-0.1.50 → siglab_py-0.1.52}/PKG-INFO

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

{siglab_py-0.1.50 → siglab_py-0.1.52}/pyproject.toml

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

{siglab_py-0.1.50 → siglab_py-0.1.52}/setup.cfg

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

{siglab_py-0.1.50 → siglab_py-0.1.52}/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-0.1.50 → siglab_py-0.1.52}/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]] = {}
 
@@ -324,7 +327,10 @@ class DivisiblePosition(Order):
         rv['executions'] = self.executions
         rv['filled_amount'] = self.filled_amount
         rv['average_cost'] = self.average_cost
+        rv['fees'] = self.fees
         rv['pos'] = self.pos
+        rv['done'] = self.done
+        rv['execution_err'] = self.execution_err
         return rv
 
 def execute_positions(

{siglab_py-0.1.50 → siglab_py-0.1.52}/siglab_py/ordergateway/gateway.py

@@ -1,4 +1,3 @@
-from ctypes import ArgumentError
 import sys
 import traceback
 import os
@@ -392,7 +391,7 @@ async def instantiate_exchange(
             }
         )  # type: ignore
     else:
-        raise ArgumentError(f"Unsupported exchange {exchange_name}, check gateway_id {gateway_id}.")
+        raise ValueError(f"Unsupported exchange {exchange_name}, check gateway_id {gateway_id}.")
 
     await exchange.load_markets() # type: ignore
 
@@ -446,251 +445,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 = f"Execution failed: {position_execution_err} {str(sys.exc_info()[0])} {str(sys.exc_info()[1])} {traceback.format_exc()}"
 
 async def work(
     param : Dict,

{siglab_py-0.1.50 → siglab_py-0.1.52}/siglab_py.egg-info/PKG-INFO

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