OctoBot-Trading 2.4.144__tar.gz → 2.4.146__tar.gz

{OctoBot-Trading-2.4.144 → OctoBot-Trading-2.4.146}/CHANGELOG.md

@@ -4,6 +4,16 @@ 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.146] - 2025-01-12
+### Added
+[Exceptions] add UntradableSymbolError
+
+## [2.4.145] - 2025-01-11
+### Added
+[Exceptions] add UnsupportedOrderTypeError
+### Fixed
+[Orders] avoid portfolio desync after filled order
+
 ## [2.4.144] - 2025-01-10
 ### Fixed
 [Backtesting] fix default market status + adapter issues

{OctoBot-Trading-2.4.144 → OctoBot-Trading-2.4.146/OctoBot_Trading.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OctoBot-Trading
-Version: 2.4.144
+Version: 2.4.146
 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.144](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.146](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.144/OctoBot_Trading.egg-info → OctoBot-Trading-2.4.146}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OctoBot-Trading
-Version: 2.4.144
+Version: 2.4.146
 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.144](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.146](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.144 → OctoBot-Trading-2.4.146}/README.md

@@ -1,4 +1,4 @@
-# OctoBot-Trading [2.4.144](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.146](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.144 → OctoBot-Trading-2.4.146}/octobot_trading/__init__.py

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

{OctoBot-Trading-2.4.144 → OctoBot-Trading-2.4.146}/octobot_trading/constants.py

@@ -46,6 +46,10 @@ CHAINED_ORDERS_OUTDATED_PRICE_ALLOWANCE = decimal.Decimal("0.005")  # allows 0.5
 INSTANT_FILLED_LIMIT_ORDER_PRICE_DELTA = decimal.Decimal("0.005")
 CREATED_ORDER_FORCED_UPDATE_PERIOD = 5
 
+# Portfolio
+MAX_PORTFOLIO_SYNC_ATTEMPTS = 1
+SYNC_ATTEMPTS_INTERVAL = 20
+
 # Tentacles
 TRADING_MODE_REQUIRED_STRATEGIES = "required_strategies"
 TRADING_MODE_REQUIRED_STRATEGIES_MIN_COUNT = "required_strategies_min_count"

{OctoBot-Trading-2.4.144 → OctoBot-Trading-2.4.146}/octobot_trading/errors.py

@@ -45,6 +45,18 @@ class OrderCreationError(OctoBotExchangeError):
     """
 
 
+class UnsupportedOrderTypeError(OrderCreationError):
+    """
+    Raised when asking for an order type that is not supported by the exchange
+    """
+
+
+class UntradableSymbolError(OrderCreationError):
+    """
+    Raised when a symbol can't currently be traded on the exchange (not in exchange.get_all_tradable_symbols)
+    """
+
+
 class OrderEditError(OctoBotExchangeError):
     """
     Raised upon a failed order edition

{OctoBot-Trading-2.4.144 → OctoBot-Trading-2.4.146}/octobot_trading/exchanges/connectors/ccxt/ccxt_client_util.py

@@ -181,7 +181,7 @@ def get_ccxt_client_login_options(exchange_manager):
     return {'defaultType': 'spot'}
 
 
-def get_symbols(client, active_only):
+def get_symbols(client, active_only) -> set[str]:
     try:
         if active_only:
             return set(

{OctoBot-Trading-2.4.144 → OctoBot-Trading-2.4.146}/octobot_trading/exchanges/connectors/ccxt/ccxt_connector.py

@@ -207,7 +207,7 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
                 else:
                     raise
 
-    def get_client_symbols(self, active_only=True):
+    def get_client_symbols(self, active_only=True) -> set[str]:
         return ccxt_client_util.get_symbols(self.client, active_only)
 
     def get_client_time_frames(self):

{OctoBot-Trading-2.4.144 → OctoBot-Trading-2.4.146}/octobot_trading/exchanges/exchange_manager.py

@@ -30,20 +30,21 @@ import octobot_trading.enums as enums
 import octobot_trading.util as util
 import octobot_trading.errors as errors
 import octobot_trading.storage as storage
+import trading_backend.exchanges
 
 
 class ExchangeManager(util.Initializable):
     def __init__(self, config, exchange_class_string):
         super().__init__()
-        self.id = str(uuid.uuid4())
-        self.bot_id = None
-        self.config = config
+        self.id : str= str(uuid.uuid4())
+        self.bot_id: str = None
+        self.config: dict = config
         self.tentacles_setup_config = None
-        self.exchange_class_string = exchange_class_string
-        self.exchange_name = exchange_class_string
+        self.exchange_class_string: str = exchange_class_string
+        self.exchange_name: str = exchange_class_string
         self.logger = logging.get_logger(self.__class__.__name__)
 
-        self.is_ready = False
+        self.is_ready: bool = False
         self.is_simulated: bool = False
         self.is_backtesting: bool = False
         self.rest_only: bool = False
@@ -65,24 +66,24 @@ class ExchangeManager(util.Initializable):
 
         self.backtesting = None
 
-        self.is_trader_simulated = util.is_trader_simulator_enabled(self.config)
-        self.has_websocket = False
+        self.is_trader_simulated: bool = util.is_trader_simulator_enabled(self.config)
+        self.has_websocket: bool = False
 
-        self.trader = None
-        self.exchange = None
-        self.exchange_backend = None
-        self.is_broker_enabled = False
-        self.trading_modes = []
+        self.trader: exchanges.Trader = None
+        self.exchange: exchanges.RestExchange = None
+        self.exchange_backend: trading_backend.exchanges.Exchange = None
+        self.is_broker_enabled: bool = False
+        self.trading_modes: list = []
 
         self.exchange_web_socket = None
 
-        self.client_symbols = []
-        self.client_time_frames = []
+        self.client_symbols: list[str] = []
+        self.client_time_frames: list[str] = []
 
-        self.storage_manager = storage.StorageManager(self)
-        self.exchange_config = exchanges.ExchangeConfig(self)
-        self.exchange_personal_data = personal_data.ExchangePersonalData(self)
-        self.exchange_symbols_data = exchange_data.ExchangeSymbolsData(self)
+        self.storage_manager: storage.StorageManager = storage.StorageManager(self)
+        self.exchange_config: exchanges.ExchangeConfig = exchanges.ExchangeConfig(self)
+        self.exchange_personal_data: personal_data.ExchangePersonalData = personal_data.ExchangePersonalData(self)
+        self.exchange_symbols_data: exchange_data.ExchangeSymbolsData = exchange_data.ExchangeSymbolsData(self)
 
         self.debug_info = {}
 

{OctoBot-Trading-2.4.144 → OctoBot-Trading-2.4.146}/octobot_trading/exchanges/traders/trader.py

@@ -122,7 +122,10 @@ class Trader(util.Initializable):
                 self.logger.warning(f"Order not created on {self.exchange_manager.exchange_name} "
                                     f"(failed attempt to create: {order}). This is likely due to "
                                     f"the order being refused by the exchange.")
-        except (errors.MissingFunds, errors.AuthenticationError, errors.ExchangeCompliancyError):
+        except (
+            errors.MissingFunds, errors.AuthenticationError,
+            errors.ExchangeCompliancyError, errors.OrderCreationError
+        ):
             # forward errors that require actions to fix the situation
             raise
         except Exception as e:

{OctoBot-Trading-2.4.144 → OctoBot-Trading-2.4.146}/octobot_trading/exchanges/types/rest_exchange.py

@@ -1,3 +1,4 @@
+# pylint: disable=W0706
 #  Drakkar-Software OctoBot-Trading
 #  Copyright (c) Drakkar-Software, All rights reserved.
 #
@@ -263,7 +264,7 @@ class RestExchange(abstract_exchange.AbstractExchange):
             raise errors.FailedRequest(
                 f"Failed order operation: {e.__class__.__name__} {html_util.get_html_summary_if_relevant(e)}"
             ) from e
-        except errors.OctoBotExchangeError:
+        except (errors.OctoBotExchangeError, errors.OrderCreationError):
             # custom error: forward it
             raise
         except Exception as e:
@@ -726,6 +727,19 @@ class RestExchange(abstract_exchange.AbstractExchange):
     def get_rate_limit(self):
         return self.connector.get_rate_limit()
 
+    def get_all_available_symbols(self, active_only=True) -> set[str]:
+        """
+        :return: the list of all symbols supported by the exchange
+        """
+        return self.connector.get_client_symbols(active_only=active_only)
+
+    async def get_all_tradable_symbols(self, active_only=True) -> set[str]:
+        """
+        Override if the exchange is not allowing trading for all available symbols (ex: MEXC)
+        :return: the list of all symbols supported by the exchange that can currently be traded through API
+        """
+        return self.get_all_available_symbols(active_only=active_only)
+
     async def switch_to_account(self, account_type: enums.AccountTypes):
         return await self.connector.switch_to_account(account_type=account_type)
 

{OctoBot-Trading-2.4.144 → OctoBot-Trading-2.4.146}/octobot_trading/personal_data/exchange_personal_data.py

@@ -84,11 +84,12 @@ class ExchangePersonalData(util.Initializable):
             return False
 
     async def handle_portfolio_and_position_update_from_order(
-        self, order, require_exchange_update: bool = True, should_notify: bool = True
+        self, order, require_exchange_update: bool = True, expect_filled_order_update: bool = False,
+        should_notify: bool = True
     ) -> bool:
         try:
             changed: bool = await self.portfolio_manager.handle_balance_update_from_order(
-                order, require_exchange_update
+                order, require_exchange_update, expect_filled_order_update
             )
             if self.exchange_manager.is_future:
                 changed = await self.positions_manager.handle_position_update_from_order(

{OctoBot-Trading-2.4.144 → OctoBot-Trading-2.4.146}/octobot_trading/personal_data/orders/states/cancel_order_state.py

@@ -109,7 +109,7 @@ class CancelOrderState(order_state.OrderState):
             async with self.order.exchange_manager.exchange_personal_data.portfolio_manager.portfolio.lock:
                 self.ensure_not_cleared(self.order)
                 await self.order.exchange_manager.exchange_personal_data.\
-                    handle_portfolio_and_position_update_from_order(self.order, False)
+                    handle_portfolio_and_position_update_from_order(self.order, require_exchange_update=False)
 
             # notify order cancelled
             await self.order.exchange_manager.exchange_personal_data.handle_order_update_notification(

{OctoBot-Trading-2.4.144 → OctoBot-Trading-2.4.146}/octobot_trading/personal_data/orders/states/fill_order_state.py

@@ -120,7 +120,7 @@ class FillOrderState(order_state.OrderState):
                 async with self.order.exchange_manager.exchange_personal_data.portfolio_manager.portfolio.lock:
                     self.ensure_not_cleared(self.order)
                     await self.order.exchange_manager.exchange_personal_data.\
-                        handle_portfolio_and_position_update_from_order(self.order)
+                        handle_portfolio_and_position_update_from_order(self.order, expect_filled_order_update=True)
 
                 # notify order filled
                 await self.order.exchange_manager.exchange_personal_data.handle_order_update_notification(

{OctoBot-Trading-2.4.144 → OctoBot-Trading-2.4.146}/octobot_trading/personal_data/portfolios/portfolio_manager.py

@@ -15,10 +15,14 @@
 #  License along with this library.
 import contextlib
 import copy
+import decimal
+import time
+import asyncio
 
 import octobot_commons.logging as logging
 import octobot_commons.constants as commons_constants
 import octobot_commons.tree as commons_tree
+import octobot_commons.symbols as commons_symbols
 import octobot_commons.enums as commons_enums
 
 import octobot_trading.exchange_channel as exchange_channel
@@ -77,7 +81,9 @@ class PortfolioManager(util.Initializable):
             self._is_initialized_event_set = True
         return changed
 
-    async def handle_balance_update_from_order(self, order, require_exchange_update: bool) -> bool:
+    async def handle_balance_update_from_order(
+        self, order, require_exchange_update: bool, expect_filled_order_update: bool
+    ) -> bool:
         """
         Handle a balance update from an order update
         :param order: the order
@@ -91,9 +97,43 @@ class PortfolioManager(util.Initializable):
                     return self._refresh_simulated_trader_portfolio_from_order(order)
                 # on real trading only:
                 # reload portfolio to ensure portfolio sync
-                return await self._refresh_real_trader_portfolio()
+                return await self._refresh_real_trader_portfolio_until_order_update_applied(
+                    order, expect_filled_order_update
+                )
         return False
 
+    async def _refresh_real_trader_portfolio_until_order_update_applied(self, order, expect_filled_order_update):
+        t0 = time.time()
+        refreshed = await self._refresh_real_trader_portfolio()
+        if not expect_filled_order_update:
+            return refreshed
+        if self._has_filled_order_been_applied(order):
+            return refreshed
+        for i in range(constants.MAX_PORTFOLIO_SYNC_ATTEMPTS):
+            await asyncio.sleep(constants.SYNC_ATTEMPTS_INTERVAL)
+            refreshed = await self._refresh_real_trader_portfolio()
+            # + 2 since 1st attempt is before looping
+            self.logger.info(f"Updated portfolio fetched after {i + 2} attempts")
+            if self._has_filled_order_been_applied(order):
+                return refreshed
+        self.logger.error(f"Filled order has not be counted in portfolio after {time.time() - t0} seconds")
+        return refreshed
+
+    def _has_filled_order_been_applied(self, order):
+        if self.exchange_manager.is_future:
+            # implement futures if necessary
+            return True
+        # in spot, consider order fill if the portfolio contains at least the order's executed amount
+        base, quote = commons_symbols.parse_symbol(order.symbol).base_and_quote()
+        checked_asset = base if order.side == enums.TradeOrderSide.BUY else quote
+        checked_amount = (
+            order.origin_quantity
+            if order.side == enums.TradeOrderSide.BUY else (order.origin_quantity * order.origin_price)
+        ) * decimal.Decimal("0.95") # consider a 5% error margin
+        available_amount = self.portfolio.get_currency_portfolio(checked_asset).available
+        # if available_amount > checked_amount, then the order fill is most likely taken into account in portfolio
+        return available_amount > checked_amount
+
     async def handle_balance_update_from_funding(self, position, funding_rate, require_exchange_update: bool) -> bool:
         """
         Handle a balance update from a funding update

{OctoBot-Trading-2.4.144 → OctoBot-Trading-2.4.146}/tests/personal_data/portfolios/test_portfolio_manager.py

@@ -15,12 +15,15 @@
 #  License along with this library.
 import decimal
 import os
+import asyncio
 
 import mock
 import pytest
 from mock import patch, Mock, AsyncMock
 import octobot_commons.constants as commons_constants
 import octobot_trading.personal_data as personal_data
+import octobot_trading.constants as constants
+from octobot_trading.personal_data import SellLimitOrder
 from octobot_trading.personal_data.orders import BuyMarketOrder, BuyLimitOrder
 
 from tests.exchanges import backtesting_trader, backtesting_config, backtesting_exchange_manager, fake_backtesting
@@ -63,46 +66,123 @@ async def test_handle_balance_update_from_order(backtesting_trader):
     trader.simulate = False
     order = BuyMarketOrder(trader)
 
-    with patch.object(portfolio_manager, '_refresh_real_trader_portfolio',
-                      new=AsyncMock()) as _refresh_real_trader_portfolio_mock, \
+    with patch.object(portfolio_manager, '_refresh_real_trader_portfolio_until_order_update_applied',
+                      new=AsyncMock()) as _refresh_real_trader_portfolio_until_order_update_applied_mock, \
         patch.object(portfolio_manager, '_refresh_simulated_trader_portfolio_from_order',
                      new=Mock()) as _refresh_simulated_trader_portfolio_from_order_mock:
-        _refresh_real_trader_portfolio_mock.assert_not_called()
-        await portfolio_manager.handle_balance_update_from_order(order, True)
-        _refresh_real_trader_portfolio_mock.assert_called_once()
+        _refresh_real_trader_portfolio_until_order_update_applied_mock.assert_not_called()
+        await portfolio_manager.handle_balance_update_from_order(order, True, False)
+        _refresh_real_trader_portfolio_until_order_update_applied_mock.assert_called_once_with(order, False)
+        _refresh_simulated_trader_portfolio_from_order_mock.assert_not_called()
+        _refresh_real_trader_portfolio_until_order_update_applied_mock.reset_mock()
+        await portfolio_manager.handle_balance_update_from_order(order, True, True)
+        _refresh_real_trader_portfolio_until_order_update_applied_mock.assert_called_once_with(order, True)
         _refresh_simulated_trader_portfolio_from_order_mock.assert_not_called()
-        _refresh_real_trader_portfolio_mock.reset_mock()
+        _refresh_real_trader_portfolio_until_order_update_applied_mock.reset_mock()
         with portfolio_manager.disabled_portfolio_update_from_order():
-            await portfolio_manager.handle_balance_update_from_order(order, False)
-            _refresh_real_trader_portfolio_mock.assert_not_called()
+            await portfolio_manager.handle_balance_update_from_order(order, False, False)
+            _refresh_real_trader_portfolio_until_order_update_applied_mock.assert_not_called()
             _refresh_simulated_trader_portfolio_from_order_mock.assert_not_called()
-            await portfolio_manager.handle_balance_update_from_order(order, True)
-            _refresh_real_trader_portfolio_mock.assert_not_called()
+            await portfolio_manager.handle_balance_update_from_order(order, True, False)
+            _refresh_real_trader_portfolio_until_order_update_applied_mock.assert_not_called()
             _refresh_simulated_trader_portfolio_from_order_mock.assert_not_called()
-        await portfolio_manager.handle_balance_update_from_order(order, False)
-        _refresh_real_trader_portfolio_mock.assert_not_called()
+        await portfolio_manager.handle_balance_update_from_order(order, False, False)
+        _refresh_real_trader_portfolio_until_order_update_applied_mock.assert_not_called()
         _refresh_simulated_trader_portfolio_from_order_mock.assert_called_once()
 
     trader.simulate = True
     with patch.object(portfolio_manager, '_refresh_simulated_trader_portfolio_from_order',
                       new=Mock()) as _refresh_simulated_trader_portfolio_from_order_mock:
         _refresh_simulated_trader_portfolio_from_order_mock.assert_not_called()
-        await portfolio_manager.handle_balance_update_from_order(order, True)
+        await portfolio_manager.handle_balance_update_from_order(order, True, False)
         _refresh_simulated_trader_portfolio_from_order_mock.assert_called_once()
         _refresh_simulated_trader_portfolio_from_order_mock.reset_mock()
         with portfolio_manager.disabled_portfolio_update_from_order():
-            await portfolio_manager.handle_balance_update_from_order(order, True)
+            await portfolio_manager.handle_balance_update_from_order(order, True, False)
             _refresh_simulated_trader_portfolio_from_order_mock.assert_not_called()
-            await portfolio_manager.handle_balance_update_from_order(order, False)
+            await portfolio_manager.handle_balance_update_from_order(order, False, False)
             _refresh_simulated_trader_portfolio_from_order_mock.assert_not_called()
         # ensure no side effect with require_exchange_update param
-        await portfolio_manager.handle_balance_update_from_order(order, False)
+        await portfolio_manager.handle_balance_update_from_order(order, False, False)
         _refresh_simulated_trader_portfolio_from_order_mock.assert_called_once()
 
     trader.is_enabled = False
     trader.simulate = False
-    assert not await portfolio_manager.handle_balance_update_from_order(order, True)
-    assert not await portfolio_manager.handle_balance_update_from_order(order, False)
+    assert not await portfolio_manager.handle_balance_update_from_order(order, True, False)
+    assert not await portfolio_manager.handle_balance_update_from_order(order, False, False)
+
+
+async def test_refresh_real_trader_portfolio_until_order_update_applied(backtesting_trader):
+    config, exchange_manager, trader = backtesting_trader
+    portfolio_manager = exchange_manager.exchange_personal_data.portfolio_manager
+
+    trader.simulate = False
+    order = BuyMarketOrder(trader)
+    with patch.object(portfolio_manager, '_refresh_real_trader_portfolio',
+                      new=AsyncMock(return_value=True)) as _refresh_real_trader_portfolio_mock, \
+        patch.object(asyncio, 'sleep', AsyncMock()) as sleep_mock:
+        with patch.object(portfolio_manager, '_has_filled_order_been_applied',
+                          new=Mock(return_value=True)) as _has_filled_order_been_applied_mock:
+            assert await portfolio_manager._refresh_real_trader_portfolio_until_order_update_applied(order, False) is True
+            _has_filled_order_been_applied_mock.assert_not_called()
+            _refresh_real_trader_portfolio_mock.assert_called_once()
+            sleep_mock.assert_not_called()
+            _refresh_real_trader_portfolio_mock.reset_mock()
+            assert await portfolio_manager._refresh_real_trader_portfolio_until_order_update_applied(order, True) is True
+            _has_filled_order_been_applied_mock.assert_called_once_with(order)
+            sleep_mock.assert_not_called()
+            _refresh_real_trader_portfolio_mock.reset_mock()
+        with patch.object(portfolio_manager, '_has_filled_order_been_applied',
+                          new=Mock(return_value=False)) as _has_filled_order_been_applied_mock:
+            assert await portfolio_manager._refresh_real_trader_portfolio_until_order_update_applied(order, True) is True
+            assert _has_filled_order_been_applied_mock.call_count == 1 + constants.MAX_PORTFOLIO_SYNC_ATTEMPTS
+            assert _refresh_real_trader_portfolio_mock.call_count == 1 + constants.MAX_PORTFOLIO_SYNC_ATTEMPTS
+            assert sleep_mock.call_count == constants.MAX_PORTFOLIO_SYNC_ATTEMPTS
+            _has_filled_order_been_applied_mock.reset_mock()
+            _refresh_real_trader_portfolio_mock.reset_mock()
+            sleep_mock.reset_mock()
+        calls = []
+
+        # retry once
+        def _has_filled_order_been_applied(*args):
+            if calls:
+                return True
+            calls.append(1)
+            return False
+        with patch.object(portfolio_manager, '_has_filled_order_been_applied',
+                          new=Mock(side_effect=_has_filled_order_been_applied)) as _has_filled_order_been_applied_mock:
+            assert await portfolio_manager._refresh_real_trader_portfolio_until_order_update_applied(order, True) is True
+            assert _has_filled_order_been_applied_mock.call_count == 2
+            assert _refresh_real_trader_portfolio_mock.call_count == 2
+            assert sleep_mock.call_count == 1
+
+
+async def test_has_filled_order_been_applied(backtesting_trader):
+    config, exchange_manager, trader = backtesting_trader
+    portfolio_manager = exchange_manager.exchange_personal_data.portfolio_manager
+
+    trader.simulate = False
+    order = BuyMarketOrder(trader)
+    order.update("BTC/USDT", quantity=decimal.Decimal(10), price=decimal.Decimal(100))
+
+    # 10 BTC in PF
+    assert portfolio_manager._has_filled_order_been_applied(order) is True
+
+    order.update("BTC/USDT", quantity=decimal.Decimal(15), price=decimal.Decimal(100))
+    assert portfolio_manager._has_filled_order_been_applied(order) is False
+
+    order = SellLimitOrder(trader)
+    order.update("BTC/USDT", quantity=decimal.Decimal(10), price=decimal.Decimal(100))
+    # 1000 USDT in PF
+    assert portfolio_manager._has_filled_order_been_applied(order) is True
+
+    order.update("BTC/USDT", quantity=decimal.Decimal(10), price=decimal.Decimal(200))
+    assert portfolio_manager._has_filled_order_been_applied(order) is False
+
+    trader.exchange_manager.is_future = True
+    # always True on futures
+    assert portfolio_manager._has_filled_order_been_applied(order) is True
+    trader.exchange_manager.is_future = False
 
 
 async def test_refresh_simulated_trader_portfolio_from_order(backtesting_trader):

{OctoBot-Trading-2.4.144 → OctoBot-Trading-2.4.146}/tests_additional/real_exchanges/real_exchange_tester.py

@@ -277,10 +277,10 @@ class RealExchangeTester:
     async def inner_test_active_symbols(self, expected_active_symbols_count: int, expected_total_symbols_count: int):
         async with self.get_exchange_manager() as exchange_manager:
             # ensure active symbols are correctly parsed by ccxt
-            active_symbols = exchange_manager.exchange.connector.get_client_symbols(active_only=True)
+            active_symbols = exchange_manager.exchange.get_all_available_symbols(active_only=True)
             assert expected_active_symbols_count <= len(active_symbols) <= expected_active_symbols_count * 1.5, \
                 f"{len(active_symbols)=}, {expected_active_symbols_count=}"
-            all_symbols = exchange_manager.exchange.connector.get_client_symbols(active_only=False)
+            all_symbols = exchange_manager.exchange.get_all_available_symbols(active_only=False)
             assert expected_total_symbols_count <= len(all_symbols) <= expected_total_symbols_count * 1.5, \
                 f"{len(all_symbols)=}, {expected_total_symbols_count=}"
 

{OctoBot-Trading-2.4.144 → OctoBot-Trading-2.4.146}/tests_additional/real_exchanges/test_mexc.py

@@ -54,7 +54,7 @@ class TestMEXCRealExchangeTester(RealExchangeTester):
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
             self.ensure_required_market_status_values(market_status)
-            assert 1e-06 <= market_status[Ecmsc.PRECISION.value][
+            assert 1e-08 <= market_status[Ecmsc.PRECISION.value][
                 Ecmsc.PRECISION_AMOUNT.value] <= 1  # to be fixed in tentacle
             assert 1e-09 <= market_status[Ecmsc.PRECISION.value][
                 Ecmsc.PRECISION_PRICE.value] <= 1   # to be fixed in tentacle