OctoBot-Trading 2.4.143__tar.gz → 2.4.145__tar.gz

{OctoBot-Trading-2.4.143 → OctoBot-Trading-2.4.145}/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.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
+
 ## [2.4.143] - 2025-01-08
 ### Fixed
 [Orders] properly handle trigger above

{OctoBot-Trading-2.4.143 → OctoBot-Trading-2.4.145/OctoBot_Trading.egg-info}/PKG-INFO

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

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

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

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

{OctoBot-Trading-2.4.143 → OctoBot-Trading-2.4.145}/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.143 → OctoBot-Trading-2.4.145}/octobot_trading/errors.py

@@ -45,6 +45,12 @@ class OrderCreationError(OctoBotExchangeError):
     """
 
 
+class UnsupportedOrderTypeError(OrderCreationError):
+    """
+    Raised when asking for an order type that is not supported by the exchange
+    """
+
+
 class OrderEditError(OctoBotExchangeError):
     """
     Raised upon a failed order edition

{OctoBot-Trading-2.4.143 → OctoBot-Trading-2.4.145}/octobot_trading/exchanges/connectors/simulator/exchange_simulator_connector.py

@@ -88,7 +88,8 @@ class ExchangeSimulatorConnector(abstract_exchange.AbstractExchange):
         return self.exchange_manager.use_cached_markets
 
     def get_contract_size(self, symbol: str):
-        return ccxt_client_simulation.get_contract_size(self.get_market_status(symbol, with_fixer=False))
+        market_status, _ = self.get_market_status(symbol, with_fixer=False)
+        return ccxt_client_simulation.get_contract_size(market_status)
 
     @classmethod
     def load_user_inputs_from_class(cls, tentacles_setup_config, tentacle_config):
@@ -157,7 +158,7 @@ class ExchangeSimulatorConnector(abstract_exchange.AbstractExchange):
                     return util.ExchangeMarketStatusFixer(
                         self._forced_market_statuses[symbol], price_example
                     ).market_status
-                return self._forced_market_statuses[symbol]
+                return self._forced_market_statuses[symbol], True
             except KeyError:
                 self._missing_market_statuses.add(symbol)
                 if len(self._missing_market_statuses) >= len(self.symbols) - 1:
@@ -168,7 +169,7 @@ class ExchangeSimulatorConnector(abstract_exchange.AbstractExchange):
                     )
                 else:
                     self.logger.warning(f"Missing cached market status for {symbol}: using default market status")
-        return self._get_default_market_status()
+        return self._get_default_market_status(), False
 
     def _get_default_market_status(self):
         return {

{OctoBot-Trading-2.4.143 → OctoBot-Trading-2.4.145}/octobot_trading/exchanges/implementations/exchange_simulator.py

@@ -14,6 +14,7 @@
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
 import typing
+import copy
 
 import octobot_trading.constants as constants
 import octobot_trading.exchanges.util as exchange_util
@@ -115,6 +116,43 @@ class ExchangeSimulator(rest_exchange.RestExchange):
     def get_backtesting_data_files(self):
         return self.connector.get_backtesting_data_files()
 
+    def get_market_status(self, symbol, price_example=None, with_fixer=True):
+        """
+        Override of the RESTExchange get_fixed_market_status to handle different get_market_status return values
+        """
+        if self._should_fix_market_status():
+            return self.get_fixed_market_status(
+                symbol,
+                price_example=price_example,
+                with_fixer=with_fixer,
+                remove_price_limits=self._should_remove_market_status_limits(),
+                adapt_for_contract_size=self._should_adapt_market_status_for_contract_size()
+            )
+        market_status, _ = self.connector.get_market_status(
+            symbol, price_example=price_example, with_fixer=with_fixer
+        )
+        return market_status
+
+    def get_fixed_market_status(self, symbol, price_example=None, with_fixer=True, remove_price_limits=False,
+                                adapt_for_contract_size=False):
+        """
+        Override of the RESTExchange get_fixed_market_status to call adapt_market_status only on fetch market statuses
+        (should not be call on default market status)
+        """
+        market_status, is_real = self.connector.get_market_status(symbol, with_fixer=False)
+        market_status = copy.deepcopy(market_status)
+        if is_real:
+            # only use adapter on real market status (not default simulator values)
+            market_status = self.connector.adapter.adapt_market_status(
+                market_status,
+                remove_price_limits=remove_price_limits
+            )
+            if adapt_for_contract_size and self.exchange_manager.is_future:
+                self._adapt_market_status_for_contract_size(market_status, self.get_contract_size(symbol))
+        if with_fixer:
+            return exchange_util.ExchangeMarketStatusFixer(market_status, price_example).market_status
+        return market_status
+
     async def load_pair_future_contract(self, pair: str):
         """
         Create a new FutureContract for the pair

{OctoBot-Trading-2.4.143 → OctoBot-Trading-2.4.145}/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.143 → OctoBot-Trading-2.4.145}/octobot_trading/personal_data/orders/order.py

@@ -525,10 +525,10 @@ class Order(util.Initializable):
                 continue
             can_be_created = await order_util.adapt_chained_order_before_creation(self, order)
             if can_be_created and order.should_be_created():
-                logger.debug(f"Creating chained order {index + 1}/{len(self.chained_orders)}")
+                logger.info(f"Creating chained order {index + 1}/{len(self.chained_orders)}")
                 await self._create_triggered_chained_order(order, enable_associated_orders_creation)
             else:
-                logger.debug(f"Skipping cancelled chained order {index + 1}/{len(self.chained_orders)}")
+                logger.info(f"Skipping cancelled chained order {index + 1}/{len(self.chained_orders)}")
 
     async def _create_triggered_chained_order(self, order, enable_associated_orders_creation):
         logger = logging.get_logger(self.get_logger_name())

{OctoBot-Trading-2.4.143 → OctoBot-Trading-2.4.145}/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.143 → OctoBot-Trading-2.4.145}/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.143 → OctoBot-Trading-2.4.145}/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.143 → OctoBot-Trading-2.4.145}/tests/personal_data/orders/test_order.py

@@ -307,13 +307,13 @@ async def test_trigger_chained_orders(trader_simulator):
     # with chained orders
     order_mock_1 = mock.Mock(
         update_price_if_outdated=mock.AsyncMock(),
-        update_quantity_with_order_fees=mock.AsyncMock(return_value=True),
+        update_quantity_with_order_fees=mock.Mock(return_value=True),
         should_be_created=mock.Mock(return_value=True),
         is_cleared=mock.Mock(return_value=False)
     )
     order_mock_2 = mock.Mock(
         update_price_if_outdated=mock.AsyncMock(),
-        update_quantity_with_order_fees=mock.AsyncMock(return_value=True),
+        update_quantity_with_order_fees=mock.Mock(return_value=True),
         should_be_created=mock.Mock(return_value=False),
         is_cleared=mock.Mock(return_value=False)
     )
@@ -399,7 +399,7 @@ async def test_create_triggered_chained_order_mock(trader_simulator):
     base_order = personal_data.Order(trader_inst)
     eq_chained_order_1 = mock.Mock(get_name=mock.Mock(return_value="plop"))
     chained_order_1 = personal_data.Order(trader_inst)
-    chained_order_1.create_triggered_equivalent_order=mock.AsyncMock(return_value=eq_chained_order_1)
+    chained_order_1.create_triggered_equivalent_order = mock.AsyncMock(return_value=eq_chained_order_1)
 
     # normal call
     with mock.patch.object(order_util, "create_as_chained_order", mock.AsyncMock()) as create_as_chained_order_mock:
@@ -443,7 +443,9 @@ async def test_create_triggered_chained_order_mock(trader_simulator):
     with mock.patch.object(
         order_util, "create_as_chained_order", mock.AsyncMock(side_effect=_create_as_chained_order)
     ) as create_as_chained_order_mock, mock.patch.object(
-        chained_order_1, "create_on_filled_artificial_order", mock.AsyncMock()
+        chained_order_1, "create_on_filled_artificial_order", mock.AsyncMock(
+            return_value=mock.Mock(get_name=mock.Mock(return_value="plop"))
+        )
     ) as create_on_filled_artificial_order_mock:
         await base_order._create_triggered_chained_order(chained_order_1, True)
         create_as_chained_order_mock.assert_called_once_with(chained_order_1)

{OctoBot-Trading-2.4.143 → OctoBot-Trading-2.4.145}/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.143 → OctoBot-Trading-2.4.145}/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