OctoBot-Trading 2.4.126__tar.gz → 2.4.128__tar.gz

{OctoBot-Trading-2.4.126 → OctoBot-Trading-2.4.128}/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.4.128] - 2023-12-03
+### Updated
+[OHLCVUpdater] prevent missing candles spam
+
+## [2.4.127] - 2023-11-28
+### Updated
+[MarketStatus] fix min cost overriding
+
 ## [2.4.126] - 2023-11-24
 ### Updated
 [Backtesting] make backtesting more flexible for missing data

{OctoBot-Trading-2.4.126 → OctoBot-Trading-2.4.128/OctoBot_Trading.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OctoBot-Trading
-Version: 2.4.126
+Version: 2.4.128
 Summary: OctoBot project trading package
 Home-page: https://github.com/Drakkar-Software/OctoBot-Trading
 Author: Drakkar-Software
@@ -16,7 +16,7 @@ Classifier: Operating System :: POSIX
 Requires-Python: >=3.8
 License-File: LICENSE
 
-# OctoBot-Trading [2.4.126](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.128](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/903b6b22bceb4661b608a86fea655f69)](https://app.codacy.com/gh/Drakkar-Software/OctoBot-Trading?utm_source=github.com&utm_medium=referral&utm_content=Drakkar-Software/OctoBot-Trading&utm_campaign=Badge_Grade_Dashboard)
 [![PyPI](https://img.shields.io/pypi/v/OctoBot-Trading.svg)](https://pypi.python.org/pypi/OctoBot-Trading/)
 [![Coverage Status](https://coveralls.io/repos/github/Drakkar-Software/OctoBot-Trading/badge.svg?branch=master)](https://coveralls.io/github/Drakkar-Software/OctoBot-Trading?branch=master)

{OctoBot-Trading-2.4.126 → OctoBot-Trading-2.4.128}/OctoBot_Trading.egg-info/SOURCES.txt

@@ -451,6 +451,7 @@ tests_additional/real_exchanges/test_bitfinex.py
 tests_additional/real_exchanges/test_bitget.py
 tests_additional/real_exchanges/test_bithumb.py
 tests_additional/real_exchanges/test_bitmart.py
+tests_additional/real_exchanges/test_bitmex.py
 tests_additional/real_exchanges/test_bitso.py
 tests_additional/real_exchanges/test_bitstamp.py
 tests_additional/real_exchanges/test_bybit.py

{OctoBot-Trading-2.4.126/OctoBot_Trading.egg-info → OctoBot-Trading-2.4.128}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OctoBot-Trading
-Version: 2.4.126
+Version: 2.4.128
 Summary: OctoBot project trading package
 Home-page: https://github.com/Drakkar-Software/OctoBot-Trading
 Author: Drakkar-Software
@@ -16,7 +16,7 @@ Classifier: Operating System :: POSIX
 Requires-Python: >=3.8
 License-File: LICENSE
 
-# OctoBot-Trading [2.4.126](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.128](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/903b6b22bceb4661b608a86fea655f69)](https://app.codacy.com/gh/Drakkar-Software/OctoBot-Trading?utm_source=github.com&utm_medium=referral&utm_content=Drakkar-Software/OctoBot-Trading&utm_campaign=Badge_Grade_Dashboard)
 [![PyPI](https://img.shields.io/pypi/v/OctoBot-Trading.svg)](https://pypi.python.org/pypi/OctoBot-Trading/)
 [![Coverage Status](https://coveralls.io/repos/github/Drakkar-Software/OctoBot-Trading/badge.svg?branch=master)](https://coveralls.io/github/Drakkar-Software/OctoBot-Trading?branch=master)

{OctoBot-Trading-2.4.126 → OctoBot-Trading-2.4.128}/README.md

@@ -1,4 +1,4 @@
-# OctoBot-Trading [2.4.126](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.128](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/903b6b22bceb4661b608a86fea655f69)](https://app.codacy.com/gh/Drakkar-Software/OctoBot-Trading?utm_source=github.com&utm_medium=referral&utm_content=Drakkar-Software/OctoBot-Trading&utm_campaign=Badge_Grade_Dashboard)
 [![PyPI](https://img.shields.io/pypi/v/OctoBot-Trading.svg)](https://pypi.python.org/pypi/OctoBot-Trading/)
 [![Coverage Status](https://coveralls.io/repos/github/Drakkar-Software/OctoBot-Trading/badge.svg?branch=master)](https://coveralls.io/github/Drakkar-Software/OctoBot-Trading?branch=master)

{OctoBot-Trading-2.4.126 → OctoBot-Trading-2.4.128}/octobot_trading/__init__.py

@@ -15,4 +15,4 @@
 #  License along with this library.
 
 PROJECT_NAME = "OctoBot-Trading"
-VERSION = "2.4.126"  # major.minor.revision
+VERSION = "2.4.128"  # major.minor.revision

{OctoBot-Trading-2.4.126 → OctoBot-Trading-2.4.128}/octobot_trading/constants.py

@@ -115,6 +115,7 @@ FULL_CANDLE_HISTORY_EXCHANGES = [
     "coinbase",
     "binanceus",
     "bitmart",
+    "bitmex",
 ]
 
 DEFAULT_FUTURE_EXCHANGES = ["binanceusdm", "bybit"]
@@ -139,7 +140,7 @@ TESTED_EXCHANGES = [
     "bitmart",
 ])
 DEFAULT_FUTURE_EXCHANGES = sorted(["bybit"])
-SIMULATOR_TESTED_EXCHANGES = sorted(["bitfinex2", "bithumb", "bitstamp", "bittrex",
+SIMULATOR_TESTED_EXCHANGES = sorted(["bitfinex2", "bithumb", "bitstamp", "bitmex",
                               "hitbtc", "kraken", "poloniex", "bitso", "ndax", "upbit",
                               "wavesexchange",])
 

{OctoBot-Trading-2.4.126 → OctoBot-Trading-2.4.128}/octobot_trading/exchange_data/kline/channel/kline_updater.py

@@ -78,7 +78,7 @@ class KlineUpdater(kline_channel.KlineProducer):
             except errors.FailedRequest as e:
                 self.logger.warning(str(e))
                 # avoid spamming on disconnected situation
-                await asyncio.sleep(constants.DEFAULT_FAILED_REQUEST_RETRY_TIME)
+                await asyncio.sleep(constants.FAILED_NETWORK_REQUEST_RETRY_ATTEMPTS)
             except errors.NotSupported:
                 self.logger.warning(f"{self.channel.exchange_manager.exchange_name} is not supporting updates")
                 await self.pause()

{OctoBot-Trading-2.4.126 → OctoBot-Trading-2.4.128}/octobot_trading/exchange_data/ohlcv/channel/ohlcv_updater.py

@@ -35,7 +35,14 @@ class OHLCVUpdater(ohlcv_channel.OHLCVProducer):
     OHLCV_OLD_LIMIT = constants.DEFAULT_CANDLE_HISTORY_SIZE  # should be <= to candle manager's MAX_CANDLES_COUNT
     OHLCV_ON_ERROR_TIME = 5
     OHLCV_MIN_REFRESH_TIME = 1
-    OHLCV_REFRESH_TIME_THRESHOLD = 1.5  # to prevent spamming at candle closing
+    OHLCV_REFRESH_TIME_THRESHOLD_BY_RETRY_ATTEMPT = [
+        2,      # retry 1: t+2
+        5,      # retry 2: t+7
+        8 ,     # retry 3: t+15
+        15,     # retry 4: t+30
+        15,     # retry 5: t+45
+        60      # retry N: every 60s
+    ] # to prevent spamming when missing closed candles
     OHLCV_MISSING_DATA_REFRESH_RETRY_MAX_DELAY = 30 * common_constants.MINUTE_TO_SECONDS
 
     OHLCV_INITIALIZATION_TIMEOUT = 60
@@ -206,11 +213,18 @@ class OHLCVUpdater(ohlcv_channel.OHLCVProducer):
         time_frame_seconds: int = common_enums.TimeFramesMinutes[time_frame] * common_constants.MINUTE_TO_SECONDS
         time_frame_sleep: int = time_frame_seconds
         last_candle_timestamp: float = 0
-        missing_data_sleep_time = min(int(time_frame_seconds / 6), self.OHLCV_MISSING_DATA_REFRESH_RETRY_MAX_DELAY)
 
+        current_candle_start_time = 0
+        attempt = 1
         while not self.should_stop and not self.channel.is_paused:
+            start_update_time = time.time()
+            iteration_candle_start_time = start_update_time - (start_update_time % time_frame_seconds)
             try:
-                start_update_time = time.time()
+                if iteration_candle_start_time == current_candle_start_time:
+                    attempt += 1    # not working?
+                else:
+                    current_candle_start_time = iteration_candle_start_time
+                    attempt = 1
                 await self._ensure_candles_initialization(pair)
                 # skip uninitialized candles
                 if self.initialized_candles_by_tf_by_symbol[pair][time_frame]:
@@ -225,21 +239,37 @@ class OHLCVUpdater(ohlcv_channel.OHLCVProducer):
 
                     if last_candle and len(candles) > 1:
                         last_candle_timestamp, sleep_time = await self._refresh_current_candle(
-                            time_frame, pair, candles, last_candle, last_candle_timestamp, time_frame_sleep
+                            time_frame, pair, candles, last_candle, last_candle_timestamp,
+                            iteration_candle_start_time, time_frame_seconds, attempt
+                        )
+                        updated_sleep_time = self._ensure_correct_sleep_time(
+                            sleep_time, iteration_candle_start_time, time_frame_seconds
                         )
-                        await asyncio.sleep(self._ensure_correct_sleep_time(sleep_time, time_frame_sleep))
+                        await asyncio.sleep(updated_sleep_time)
                     else:
                         # not enough candles: retry soon
+                        sleep_time = self._ensure_correct_sleep_time(
+                            self._get_missing_candle_retry_sleep_time(attempt),
+                            iteration_candle_start_time, time_frame_seconds
+                        )
                         self.logger.debug(f"Missing candles in request results for {pair} on {time_frame}, refreshing "
-                                          f"in {missing_data_sleep_time} seconds (available candles: {candles}).")
-                        await asyncio.sleep(missing_data_sleep_time)
+                                          f"in {sleep_time} seconds (available candles: {candles}).")
+                        await asyncio.sleep(sleep_time)
                 else:
                     # candles on this time frame have not been initialized: sleep until the next candle update
                     await asyncio.sleep(max(0.0, time_frame_sleep - (time.time() - start_update_time)))
-            except errors.FailedRequest as e:
-                self.logger.warning(str(e))
+            except errors.FailedRequest as err:
                 # avoid spamming on disconnected situation
-                await asyncio.sleep(constants.DEFAULT_FAILED_REQUEST_RETRY_TIME)
+                sleep_time = self._ensure_correct_sleep_time(
+                    self._get_missing_candle_retry_sleep_time(attempt),
+                    iteration_candle_start_time, time_frame_seconds
+                )
+                sleep_time = max(sleep_time, constants.DEFAULT_FAILED_REQUEST_RETRY_TIME)
+                self.logger.warning(
+                    f"Impossible to fetch {time_frame.value} {pair} candles. Retry in {sleep_time} seconds: "
+                    f"{html_util.get_html_summary_if_relevant(err)}"
+                )
+                await asyncio.sleep(sleep_time)
             except errors.NotSupported:
                 self.logger.warning(
                     f"{self.channel.exchange_manager.exchange_name} is not supporting updates")
@@ -253,36 +283,51 @@ class OHLCVUpdater(ohlcv_channel.OHLCVProducer):
                 )
                 await asyncio.sleep(self.OHLCV_ON_ERROR_TIME)
 
-    async def _refresh_current_candle(self, time_frame, pair, candles, last_candle,
-                                      last_candle_timestamp, time_frame_sleep):
+    async def _refresh_current_candle(
+        self, time_frame, pair, candles, last_candle, last_candle_timestamp,
+        iteration_candle_start_time, time_frame_seconds, attempt
+    ):
         current_candle_timestamp: float = last_candle[common_enums.PriceIndexes.IND_PRICE_TIME.value]
-        should_sleep_time: float = current_candle_timestamp + time_frame_sleep - time.time()
+        should_sleep_time: float = current_candle_timestamp + time_frame_seconds - time.time()
 
         # if we're trying to refresh the current candle => useless
         if last_candle_timestamp == current_candle_timestamp:
             if should_sleep_time < 0:
-                # up to date candle is not yet available on exchange: retry in a few seconds
+                # up-to-date candle is not yet available on exchange: retry in a few seconds
                 should_sleep_time = self._ensure_correct_sleep_time(
-                    self.OHLCV_REFRESH_TIME_THRESHOLD,
-                    time_frame_sleep
+                    self._get_missing_candle_retry_sleep_time(attempt),
+                    iteration_candle_start_time,
+                    time_frame_seconds
                 )
             else:
                 should_sleep_time = self._ensure_correct_sleep_time(
-                    should_sleep_time + time_frame_sleep + self.OHLCV_REFRESH_TIME_THRESHOLD,
-                    time_frame_sleep
+                    should_sleep_time + time_frame_seconds + self._get_missing_candle_retry_sleep_time(attempt),
+                    iteration_candle_start_time,
+                    time_frame_seconds
                 )
+            self.logger.debug(
+                f"Failed to fetch up-to-date candle for {pair} on {time_frame.value}. "
+                f"Retrying in {round(should_sleep_time, 2)} seconds"
+            )
+
         else:
             # A fresh candle happened
             last_candle_timestamp = current_candle_timestamp
             await self._push_complete_candles(time_frame, pair, candles)
         return last_candle_timestamp, should_sleep_time
 
-    def _ensure_correct_sleep_time(self, sleep_time_candidate, time_frame_sleep):
+    def _get_missing_candle_retry_sleep_time(self, attempt):
+        if attempt < len(self.OHLCV_REFRESH_TIME_THRESHOLD_BY_RETRY_ATTEMPT):
+            return self.OHLCV_REFRESH_TIME_THRESHOLD_BY_RETRY_ATTEMPT[attempt - 1]
+        return self.OHLCV_REFRESH_TIME_THRESHOLD_BY_RETRY_ATTEMPT[-1]
+
+    def _ensure_correct_sleep_time(self, sleep_time_candidate, iteration_candle_start_time, time_frame_seconds):
         if sleep_time_candidate < OHLCVUpdater.OHLCV_MIN_REFRESH_TIME:
             return OHLCVUpdater.OHLCV_MIN_REFRESH_TIME
-        elif sleep_time_candidate > time_frame_sleep:
-            return time_frame_sleep
-        return sleep_time_candidate
+        else:
+            max_sleep_time = max(iteration_candle_start_time + time_frame_seconds - time.time(), 0)
+            # ensure does not sleep more than missing time before next candle
+            return min(sleep_time_candidate, max_sleep_time)
 
     def _set_initialized(self, pair, time_frame, initialized):
         if pair not in self.initialized_candles_by_tf_by_symbol:

{OctoBot-Trading-2.4.126 → OctoBot-Trading-2.4.128}/octobot_trading/exchange_data/recent_trades/channel/recent_trade_updater.py

@@ -74,10 +74,14 @@ class RecentTradeUpdater(recent_trade_channel.RecentTradeProducer):
                         except TypeError:
                             pass
                 await asyncio.sleep(self.refresh_time)
-            except errors.FailedRequest as e:
-                self.logger.warning(str(e))
+            except errors.FailedRequest as err:
+                sleep_time = constants.FAILED_NETWORK_REQUEST_RETRY_ATTEMPTS
+                self.logger.warning(
+                    f"Impossible to fetch recent trades. Retry in {sleep_time} seconds: "
+                    f"{html_util.get_html_summary_if_relevant(err)}"
+                )
                 # avoid spamming on disconnected situation
-                await asyncio.sleep(constants.DEFAULT_FAILED_REQUEST_RETRY_TIME)
+                await asyncio.sleep(sleep_time)
             except errors.NotSupported:
                 self.logger.warning(f"{self.channel.exchange_manager.exchange_name} is not supporting updates")
                 await self.pause()

{OctoBot-Trading-2.4.126 → OctoBot-Trading-2.4.128}/octobot_trading/exchange_data/ticker/channel/ticker_updater.py

@@ -74,7 +74,7 @@ class TickerUpdater(ticker_channel.TickerProducer):
         except errors.FailedRequest as e:
             self.logger.warning(html_util.get_html_summary_if_relevant(e))
             # avoid spamming on disconnected situation
-            await asyncio.sleep(constants.DEFAULT_FAILED_REQUEST_RETRY_TIME)
+            await asyncio.sleep(constants.FAILED_NETWORK_REQUEST_RETRY_ATTEMPTS)
 
     async def fetch_and_push_pair(self, pair: str):
         with self._single_pair_update(pair) as can_update:

{OctoBot-Trading-2.4.126 → OctoBot-Trading-2.4.128}/octobot_trading/exchanges/connectors/ccxt/ccxt_connector.py

@@ -664,7 +664,10 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
                 )
                 if cancelled_order is None or personal_data.parse_is_cancelled(cancelled_order):
                     return enums.OrderStatus.CANCELED
-                elif personal_data.parse_is_open(cancelled_order):
+                elif (
+                    personal_data.parse_is_open(cancelled_order)
+                    or personal_data.parse_is_pending_cancel(cancelled_order)
+                ):
                     return enums.OrderStatus.PENDING_CANCEL
                 # cancel command worked but order is still existing and is not open or canceled. unhandled case
                 # log error and consider it canceling. order states will manage the

{OctoBot-Trading-2.4.126 → OctoBot-Trading-2.4.128}/octobot_trading/exchanges/util/exchange_market_status_fixer.py

@@ -245,7 +245,7 @@ class ExchangeMarketStatusFixer:
     def _fix_market_status_limits_with_price(self):
         candidate_amount_min, candidate_amount_max = self._calculate_amount()
         limits_amount = self.market_status[Ecmsc.LIMITS.value][Ecmsc.LIMITS_AMOUNT.value]
-        amount_min = limits_amount.get(Ecmsc.LIMITS_PRICE_MIN.value)
+        amount_min = limits_amount.get(Ecmsc.LIMITS_AMOUNT_MIN.value)
         if not is_ms_valid(amount_min, zero_valid=True):
             amount_min = candidate_amount_min
         amount_max = limits_amount.get(Ecmsc.LIMITS_AMOUNT_MAX.value)
@@ -259,6 +259,28 @@ class ExchangeMarketStatusFixer:
         price_max = limits_price.get(Ecmsc.LIMITS_PRICE_MAX.value)
         if not is_ms_valid(price_max, zero_valid=False):
             price_max = self.price_example * self.LIMIT_PRICE_MULTIPLIER
+        limit_cost = self.market_status[Ecmsc.LIMITS.value].get(Ecmsc.LIMITS_COST.value, {})
+        cost_min = limit_cost.get(Ecmsc.LIMITS_COST_MIN.value)
+        if not is_ms_valid(cost_min, zero_valid=False):
+            updated_cost = False
+            if (
+                is_ms_valid(limits_price.get(Ecmsc.LIMITS_PRICE_MIN.value))
+                and is_ms_valid(limits_amount.get(Ecmsc.LIMITS_AMOUNT_MIN.value))
+            ):
+                # min cost can be computed from min price and amount: those values come from exchange data
+                candidate_cost_min = (
+                    limits_price.get(Ecmsc.LIMITS_PRICE_MIN.value)
+                    * limits_amount.get(Ecmsc.LIMITS_AMOUNT_MIN.value)
+                )
+                if is_ms_valid(candidate_cost_min, zero_valid=False):
+                    cost_min = candidate_cost_min
+                    updated_cost = True
+            if not updated_cost:
+                # avoid computing min cost based on indirect min price or amount
+                cost_min = 0
+        cost_max = limit_cost.get(Ecmsc.LIMITS_COST_MAX.value)
+        if not is_ms_valid(cost_max, zero_valid=False):
+            cost_max = price_max * amount_max
         self.market_status[Ecmsc.LIMITS.value] = {
             Ecmsc.LIMITS_AMOUNT.value: {
                 Ecmsc.LIMITS_AMOUNT_MIN.value: amount_min,
@@ -269,8 +291,8 @@ class ExchangeMarketStatusFixer:
                 Ecmsc.LIMITS_PRICE_MAX.value: price_max,
             },
             Ecmsc.LIMITS_COST.value: {
-                Ecmsc.LIMITS_COST_MIN.value: price_min * amount_min,
-                Ecmsc.LIMITS_COST_MAX.value: price_max * amount_max,
+                Ecmsc.LIMITS_COST_MIN.value: cost_min,
+                Ecmsc.LIMITS_COST_MAX.value: cost_max,
             }
         }
 

{OctoBot-Trading-2.4.126 → OctoBot-Trading-2.4.128}/octobot_trading/personal_data/__init__.py

@@ -37,6 +37,7 @@ from octobot_trading.personal_data.orders import (
     parse_raw_fees,
     parse_order_status,
     parse_is_cancelled,
+    parse_is_pending_cancel,
     parse_is_open,
     get_pnl_transaction_source_from_order,
     is_stop_order,
@@ -253,6 +254,7 @@ __all__ = [
     "parse_raw_fees",
     "parse_order_status",
     "parse_is_cancelled",
+    "parse_is_pending_cancel",
     "parse_is_open",
     "get_pnl_transaction_source_from_order",
     "is_stop_order",

{OctoBot-Trading-2.4.126 → OctoBot-Trading-2.4.128}/octobot_trading/personal_data/orders/__init__.py

@@ -87,6 +87,7 @@ from octobot_trading.personal_data.orders.order_util import (
     parse_raw_fees,
     parse_order_status,
     parse_is_cancelled,
+    parse_is_pending_cancel,
     parse_is_open,
     get_up_to_date_price,
     get_pre_order_data,
@@ -160,6 +161,7 @@ __all__ = [
     "parse_raw_fees",
     "parse_order_status",
     "parse_is_cancelled",
+    "parse_is_pending_cancel",
     "parse_is_open",
     "get_up_to_date_price",
     "get_pre_order_data",

{OctoBot-Trading-2.4.126 → OctoBot-Trading-2.4.128}/octobot_trading/personal_data/orders/decimal_order_adapter.py

@@ -212,11 +212,11 @@ def decimal_check_and_adapt_order_details_if_necessary(quantity, price, symbol_m
     valid_price = decimal_adapt_price(symbol_market, price, truncate)
 
     # case 1: try with data directly from exchange
-    if personal_data.is_valid(limit_amount, Ecmsc.LIMITS_AMOUNT_MIN.value):
+    if personal_data.is_valid(limit_amount, Ecmsc.LIMITS_AMOUNT_MIN.value, zero_valid=True):
         min_quantity = decimal.Decimal(str(limit_amount.get(Ecmsc.LIMITS_AMOUNT_MIN.value, math.nan)))
         max_quantity = None
         # not all symbol data have a max quantity
-        if personal_data.is_valid(limit_amount, Ecmsc.LIMITS_AMOUNT_MAX.value):
+        if personal_data.is_valid(limit_amount, Ecmsc.LIMITS_AMOUNT_MAX.value, zero_valid=False):
             max_quantity = decimal.Decimal(str(limit_amount.get(Ecmsc.LIMITS_AMOUNT_MAX.value, math.nan)))
 
         total_order_price = valid_quantity * valid_price
@@ -226,11 +226,11 @@ def decimal_check_and_adapt_order_details_if_necessary(quantity, price, symbol_m
             return []
 
         # case 1.1: use only quantity and cost
-        if personal_data.is_valid(limit_cost, Ecmsc.LIMITS_COST_MIN.value):
+        if personal_data.is_valid(limit_cost, Ecmsc.LIMITS_COST_MIN.value, zero_valid=True):
             min_cost = decimal.Decimal(str(limit_cost.get(Ecmsc.LIMITS_COST_MIN.value, math.nan)))
             max_cost = None
             # not all symbol data have a max cost
-            if personal_data.is_valid(limit_cost, Ecmsc.LIMITS_COST_MAX.value):
+            if personal_data.is_valid(limit_cost, Ecmsc.LIMITS_COST_MAX.value, zero_valid=False):
                 max_cost = decimal.Decimal(str(limit_cost.get(Ecmsc.LIMITS_COST_MAX.value, math.nan)))
 
             # check total_order_price not < min_cost
@@ -250,11 +250,11 @@ def decimal_check_and_adapt_order_details_if_necessary(quantity, price, symbol_m
 
         # case 1.2: use only quantity and price (if available)
         else:
-            if personal_data.is_valid(limit_price, Ecmsc.LIMITS_PRICE_MIN.value):
+            if personal_data.is_valid(limit_price, Ecmsc.LIMITS_PRICE_MIN.value, zero_valid=True):
                 min_price = decimal.Decimal(str(limit_price.get(Ecmsc.LIMITS_PRICE_MIN.value, math.nan)))
                 max_price = None
                 # not all symbol data have a max price
-                if personal_data.is_valid(limit_price, Ecmsc.LIMITS_PRICE_MAX.value):
+                if personal_data.is_valid(limit_price, Ecmsc.LIMITS_PRICE_MAX.value, zero_valid=False):
                     max_price = decimal.Decimal(str(limit_price.get(Ecmsc.LIMITS_PRICE_MAX.value, math.nan)))
 
                 if (max_price is not None and (valid_price > max_price)) or valid_price < min_price:

{OctoBot-Trading-2.4.126 → OctoBot-Trading-2.4.128}/octobot_trading/personal_data/orders/order_util.py

@@ -34,14 +34,15 @@ from octobot_trading.enums import ExchangeConstantsMarketStatusColumns as Ecmsc
 LOGGER_NAME = "order_util"
 
 
-def is_valid(element, key):
+def is_valid(element, key, zero_valid=False):
     """
     Checks is the element is valid with the market status fixer
     :param element:
     :param key:
+    :param zero_valid: if 0 should be considered a valid value
     :return:
     """
-    return key in element and exchange_market_status_fixer.is_ms_valid(element[key])
+    return key in element and exchange_market_status_fixer.is_ms_valid(element[key], zero_valid=zero_valid)
 
 
 def get_min_max_amounts(symbol_market, default_value=None):
@@ -394,6 +395,10 @@ def parse_is_cancelled(raw_order):
     return parse_order_status(raw_order) in {enums.OrderStatus.CANCELED, enums.OrderStatus.CLOSED}
 
 
+def parse_is_pending_cancel(raw_order):
+    return parse_order_status(raw_order) is enums.OrderStatus.PENDING_CANCEL
+
+
 def parse_is_open(raw_order):
     return parse_order_status(raw_order) is enums.OrderStatus.OPEN
 

{OctoBot-Trading-2.4.126 → OctoBot-Trading-2.4.128}/tests/exchanges/util/test_exchange_market_status_fixer.py

@@ -63,7 +63,7 @@ class TestExchangeMarketStatusFixer:
             Ecmsc.LIMITS.value: self._get_limits(
                 0.002190990480628382, 21909.904806283797,
                 0.05, 10000.0,
-                0.0001095495240314191, 219099048.062838
+                0, 219099048.062838
             )
         }
 
@@ -77,7 +77,7 @@ class TestExchangeMarketStatusFixer:
             Ecmsc.LIMITS.value: self._get_limits(
                 0.002190990480628382, 21909.904806283797,
                 0.05, 10000.0,
-                0.0001095495240314191, 219099048.062838
+                0, 219099048.062838
             )
         }
 
@@ -92,7 +92,7 @@ class TestExchangeMarketStatusFixer:
             Ecmsc.LIMITS.value: self._get_limits(
                 641.0256410256403, 64102564102564.04,
                 1.5600000000000002e-09, 0.0015600000000000002,
-                9.999999999999991e-07, 99999999999.99991
+                0, 99999999999.99991
             )
         }
 
@@ -107,14 +107,14 @@ class TestExchangeMarketStatusFixer:
             Ecmsc.LIMITS.value: self._get_limits(
                 6.37795818470299, 63779581.84702988,
                 0.0015678999, 1567.8999000000001,
-                0.01, 99999999999.99997
+                0, 99999999999.99997
             )
         }
 
         current_price = 25.87257
         ms = {
             Ecmsc.PRECISION.value: self._get_precision(),
-            Ecmsc.LIMITS.value: self._get_limits(None, None, 0, 0, None, None)
+            Ecmsc.LIMITS.value: self._get_limits(None, None, 0, 0, 11, None)
         }
 
         assert ExchangeMarketStatusFixer(ms, price_example=current_price).market_status == {
@@ -122,7 +122,7 @@ class TestExchangeMarketStatusFixer:
             Ecmsc.LIMITS.value: self._get_limits(
                 0.3865097282566056, 3865097.2825660524,
                 0.02587257, current_price * 1000,
-                0.010000000000000007, 99999999999.99997
+                11, 99999999999.99997
             )
         }
 
@@ -137,7 +137,7 @@ class TestExchangeMarketStatusFixer:
             Ecmsc.LIMITS.value: self._get_limits(
                 0.04986163396574511, 498616.3396574511,
                 3, 3,
-                0.14958490189723533, 1495849.0189723533
+                0, 1495849.0189723533
             )
         }
 
@@ -271,6 +271,50 @@ class TestExchangeMarketStatusFixer:
                 9.999999999999991e-07, 99999999999.99991
             )
 
+            emsf = ExchangeMarketStatusFixer({
+                Ecmsc.LIMITS.value: self._get_limits(cost_min=1, cost_max=11000.33)
+            }, 0.000999)
+            emsf._fix_market_status_limits_with_price()
+            assert emsf.market_status[Ecmsc.LIMITS.value] == self._get_limits(
+                1.001001001001, 100100100100.09999,
+                9.99e-07, 0.9990000000000001,
+                1, 11000.33
+            )
+
+            emsf = ExchangeMarketStatusFixer({
+                Ecmsc.LIMITS.value: self._get_limits(
+                    amount_min=0.1, amount_max=10000,
+                    price_min=44, price_max=4444,
+                )
+            }, 52)
+            # cost min max computed using price & amount
+            emsf._fix_market_status_limits_with_price()
+            assert emsf.market_status[Ecmsc.LIMITS.value] == self._get_limits(
+                0.1, 10000,
+                44, 4444,
+                4.4, 44440000
+            )
+
+            # cost max ONLY computed using price & amount (missing min price)
+            emsf = ExchangeMarketStatusFixer({
+                Ecmsc.LIMITS.value: self._get_limits(
+                    amount_min=0.1, amount_max=10000,
+                    price_max=4444,
+                )
+            }, 52)
+            assert emsf.market_status[Ecmsc.LIMITS.value] == self._get_limits(
+                0.1, 10000,
+                0.052, 4444,
+                0, 44440000    # min cost impossible to compute (no exchange info)
+            )
+            # min cost inferred from price (2nd call: consider min price as 'from exchange')
+            emsf._fix_market_status_limits_with_price()
+            assert emsf.market_status[Ecmsc.LIMITS.value] == self._get_limits(
+                0.1, 10000,
+                0.052, 4444,
+                0.0052, 44440000
+            )
+
     # Precision
     def test_get_price_precision(self):
         if not os.getenv('CYTHON_IGNORE'):