OctoBot-Trading 2.4.183__tar.gz → 2.4.184__tar.gz

{OctoBot-Trading-2.4.183 → OctoBot-Trading-2.4.184}/CHANGELOG.md

@@ -4,6 +4,10 @@ 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.184] - 2025-06-04
+### Fixed
+[Order Cancel] fix deadlock
+
 ## [2.4.183] - 2025-06-01
 ### Fixed
 [Exchanges] fix edit_order

{OctoBot-Trading-2.4.183 → OctoBot-Trading-2.4.184/OctoBot_Trading.egg-info}/PKG-INFO

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

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

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

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

{OctoBot-Trading-2.4.183 → OctoBot-Trading-2.4.184}/octobot_trading/exchange_data/recent_trades/channel/recent_trade_updater.py

@@ -34,6 +34,7 @@ class RecentTradeUpdater(recent_trade_channel.RecentTradeProducer):
         self.refresh_time = RecentTradeUpdater.RECENT_TRADE_REFRESH_TIME
 
     async def init_recent_trades(self):
+        pair = None
         try:
             for pair in self.channel.exchange_manager.exchange_config.traded_symbol_pairs:
                 recent_trades = await self.channel.exchange_manager.exchange.\
@@ -45,7 +46,7 @@ class RecentTradeUpdater(recent_trade_channel.RecentTradeProducer):
             self.logger.exception(
                 e,
                 True,
-                f"Fail to initialize recent trades : {html_util.get_html_summary_if_relevant(e)}"
+                f"Fail to initialize {pair} recent trades : {html_util.get_html_summary_if_relevant(e)}"
             )
 
     async def start(self):

{OctoBot-Trading-2.4.183 → OctoBot-Trading-2.4.184}/octobot_trading/exchanges/traders/trader.py

@@ -465,6 +465,7 @@ class Trader(util.Initializable):
             order.is_waiting_for_chained_trigger = False
             return success
         order_status = None
+        is_order_refreshing = False
         # if real order: cancel on exchange
         if not self.simulate and order.is_active and not order.is_self_managed():
             try:
@@ -496,6 +497,7 @@ class Trader(util.Initializable):
             except Exception as err:
                 self.logger.exception(err, True, f"Failed to cancel order {order}")
                 return False
+            is_order_refreshing = order.is_refreshing()
             if order_status is enums.OrderStatus.CANCELED:
                 order.status = octobot_trading.enums.OrderStatus.CANCELED
                 self.logger.debug(f"Successfully cancelled order {order}")
@@ -505,11 +507,14 @@ class Trader(util.Initializable):
         else:
             order.status = octobot_trading.enums.OrderStatus.CANCELED
 
-        await order.on_cancel(force_cancel=order.status is octobot_trading.enums.OrderStatus.CANCELED,
-                              is_from_exchange_data=False,
-                              ignored_order=ignored_order)
-        if wait_for_cancelling and order.state is not None and order.state.is_pending():
-            await self._wait_for_order_cancel(order, cancelling_timeout)
+        if not is_order_refreshing:
+            # don't override state if order is already refreshing (most likely from open orders updater)
+            await order.on_cancel(force_cancel=order.status is octobot_trading.enums.OrderStatus.CANCELED,
+                                  is_from_exchange_data=False,
+                                  ignored_order=ignored_order)
+        if wait_for_cancelling and (order.is_refreshing() or order.is_pending()):
+            # Don't wait for new state to avoid potential deadlock. Will raise if cancel is not in process
+            self._ensure_probably_canceled_order(order, None)
         return True
 
     async def _handle_order_cancel_error(self, order, err, wait_for_cancelling, cancelling_timeout):
@@ -531,10 +536,7 @@ class Trader(util.Initializable):
             # can't wait for the order state to fully refresh as it will require a portfolio lock which might
             # be locked by this ask already (and create a deadlock)
             # => be optimistic and consider refreshing state as end state
-            if order.is_refreshing_filling_state():
-                raise errors.FilledOrderError(f"Order is filled, it can't be cancelled. Order: {order}") from err
-            if order.is_refreshing_canceling_state():
-                self.logger.debug(f"Tried to cancel an already cancelled order. Order: {order}")
+            if self._ensure_probably_canceled_order(order, err):
                 return True
         else:
             # trigger forced refresh to get an update of the order
@@ -542,17 +544,14 @@ class Trader(util.Initializable):
             await order.state.synchronize(force_synchronization=True)
             if previous_status != order.status:
                 # don't wait for new state to avoid potential deadlock
-                if order.is_refreshing_filling_state():
-                    raise errors.FilledOrderError(f"Order is filled, it can't be cancelled. Order: {order}") from err
-                if order.is_refreshing_canceling_state():
-                    self.logger.debug(f"Tried to cancel an already cancelled order. Order: {order}")
+                if self._ensure_probably_canceled_order(order, err):
                     return True
         if order.is_cancelled():
             self.logger.debug(f"Tried to cancel an already cancelled order. Order: {order}")
             return True
         if order.is_cancelling():
-            if wait_for_cancelling:
-                await self._wait_for_order_cancel(order, cancelling_timeout)
+            # don't wait for new state to avoid potential deadlock, just check that order is not filling
+            self._ensure_probably_canceled_order(order, err)
             return True
         elif order.is_open():
             if isinstance(err, errors.OrderNotFoundOnCancelError):
@@ -574,6 +573,20 @@ class Trader(util.Initializable):
                 f"Can't cancel order and unknown post sync order state for order: {order}."
             ) from err
 
+    def _ensure_probably_canceled_order(self, order, err: typing.Optional[Exception]) -> bool:
+        if order.is_refreshing_filling_state():
+            filled_err = errors.FilledOrderError(f"Order is filled, it can't be cancelled. Order: {order}")
+            if err is None:
+                raise filled_err
+            raise filled_err from err
+        if order.is_refreshing_canceling_state():
+            self.logger.debug(f"Tried to cancel an already cancelled order. Order: {order}")
+            return True
+        if order.is_pending_cancel_state():
+            self.logger.debug(f"Tried to cancel a pending cancel order. Order: {order}")
+            return True
+        return False
+
     async def cancel_all_orders(
         self,
         symbol: str,

{OctoBot-Trading-2.4.183 → OctoBot-Trading-2.4.184}/octobot_trading/personal_data/orders/channel/orders.py

@@ -29,7 +29,7 @@ class OrdersProducer(exchanges_channel.ExchangeChannelProducer):
 
     async def perform(self, orders, is_from_bot=False, are_closed=False):
         try:
-            self.logger.debug(f"Received order update for {len(orders)} {'closed' if are_closed else ''} orders.")
+            self.logger.debug(f"Received order update for {len(orders)}{' closed' if are_closed else ''} orders.")
             has_new_order = False
             waiting_complete_init_orders = []
             symbols = set()

{OctoBot-Trading-2.4.183 → OctoBot-Trading-2.4.184}/octobot_trading/personal_data/orders/channel/orders_updater.py

@@ -200,10 +200,10 @@ class OrdersUpdater(orders_channel.OrdersProducer):
 
         if raw_order is not None:
             self.logger.info(f"Received update for {order} on {exchange_name}: {raw_order}")
-
             await self.channel.exchange_manager.exchange_personal_data.handle_order_update_from_raw(
                 order.exchange_order_id, raw_order, should_notify=should_notify
             )
+            self.logger.info(f"Completed update for {order} on {exchange_name}")
         else:
             self.logger.info(f"Can't received update for {order} on {exchange_name}: received order is None")
 

{OctoBot-Trading-2.4.183 → OctoBot-Trading-2.4.184}/octobot_trading/personal_data/orders/order.py

@@ -405,15 +405,24 @@ class Order(util.Initializable):
     def is_refreshing(self) -> bool:
         return self.state is not None and self.state.is_refreshing()
 
+    def is_pending(self) -> bool:
+        return self.state is not None and self.state.is_pending()
+
     def is_refreshing_filling_state(self) -> bool:
         return self._is_refreshing_state(orders_states.FillOrderState)
 
     def is_refreshing_canceling_state(self) -> bool:
         return self._is_refreshing_state(orders_states.CancelOrderState)
 
+    def is_pending_cancel_state(self) -> bool:
+        return self._is_pending_state(orders_states.CancelOrderState)
+
     def _is_refreshing_state(self, state_type) -> bool:
         return self.is_refreshing() and isinstance(self.state, state_type)
 
+    def _is_pending_state(self, state_type) -> bool:
+        return self.is_pending() and isinstance(self.state, state_type)
+
     def can_be_edited(self) -> bool:
         # orders that are not yet open or already open can be edited
         return self.state is None or (self.state.is_open() and not self.is_refreshing())

{OctoBot-Trading-2.4.183 → OctoBot-Trading-2.4.184}/tests/modes/test_abstract_mode_consumer.py

@@ -316,7 +316,6 @@ async def test_create_order_if_possible_ensure_no_deadlock_when_canceling_orders
 
         _origin_handle_portfolio_and_position_update_from_order_calls = []
         _synchronize_with_exchange_calls = []
-        origin_handle_portfolio_and_position_update_from_order = exchange_manager.exchange_personal_data.handle_portfolio_and_position_update_from_order
         assert exchange_manager.exchange_personal_data.orders_manager.get_open_orders() == [open_order]
         with mock.patch.object(
             consumer, "create_new_orders", mock.AsyncMock(side_effect=_create_new_orders)
@@ -393,7 +392,6 @@ async def test_create_order_if_possible_ensure_no_deadlock_when_canceling_orders
 
         _origin_handle_portfolio_and_position_update_from_order_calls = []
         _synchronize_with_exchange_calls = []
-        origin_handle_portfolio_and_position_update_from_order = exchange_manager.exchange_personal_data.handle_portfolio_and_position_update_from_order
         assert exchange_manager.exchange_personal_data.orders_manager.get_open_orders() == [open_order]
         with mock.patch.object(
             consumer, "create_new_orders", mock.AsyncMock(side_effect=_create_new_orders)
@@ -421,6 +419,155 @@ async def test_create_order_if_possible_ensure_no_deadlock_when_canceling_orders
         assert exchange_manager.exchange_personal_data.orders_manager.get_open_orders() == []   # order no more open
 
 
+        # 5. no concurrent task: open_order ends up in PENDING_CANCEL state after exchange.cancel() call
+        #   order.on_cancel() and don't dead lock in cancelled order state
+        #   => create_order_if_possible (which has portfolio lock) will not wait for cancel order state terminate
+        open_order = await _create_initialized_open_order(exchange_manager, symbol)
+        open_order.simulated = False    # force real order simulation
+        assert exchange_manager.exchange_personal_data.orders_manager.get_open_orders() == [open_order]
+        completed_tasks.clear()
+
+        async def _synchronize_with_exchange(*_, **__):
+            # will not set order in final state => don't do anything, order stays pending
+            _synchronize_with_exchange_calls.append(1)
+            _synchronize_with_exchange_calls.append(1)
+
+        async def _create_new_orders(*_, **__):
+            # for now order is open
+            assert exchange_manager.exchange_personal_data.orders_manager.get_open_orders() == [open_order]
+            assert open_order.status == octobot_trading.enums.OrderStatus.OPEN
+            assert isinstance(open_order.state, personal_data.OpenOrderState)
+            # order cancel will end up in PENDING_CANCEL
+            await consumer.trading_mode.cancel_order(open_order, wait_for_cancelling=True) is True
+            # order now in pending cancel state
+            assert isinstance(open_order.state, personal_data.CancelOrderState)
+            assert open_order.is_pending_cancel_state() is True
+            for _ in range(10):
+                # wait a few cycles to make sure handle_portfolio_and_position_update_from_order_calls
+                # really don't get called (locked by consumer lock
+                await asyncio_tools.wait_asyncio_next_cycle()
+            # _synchronize_with_exchange_calls started and completed
+            assert _synchronize_with_exchange_calls == [1, 1]
+
+        async def _on_cancel(*args, **kwargs):
+            await origin_on_cancel(*args, **kwargs)
+
+
+        _synchronize_with_exchange_calls = []
+        _origin_handle_portfolio_and_position_update_from_order_calls = []
+        origin_on_cancel = open_order.on_cancel
+        assert exchange_manager.exchange_personal_data.orders_manager.get_open_orders() == [open_order]
+        with mock.patch.object(
+            consumer, "create_new_orders", mock.AsyncMock(side_effect=_create_new_orders)
+        ) as _create_new_orders_mock, mock.patch.object(
+            open_order, "on_cancel", mock.AsyncMock(side_effect=_on_cancel)
+        ) as _on_cancel_mock, \
+        mock.patch.object(
+            exchange_manager.exchange_personal_data, "handle_portfolio_and_position_update_from_order", mock.AsyncMock()
+        ) as handle_portfolio_and_position_update_from_order_mock, \
+        mock.patch.object(
+            personal_data.CancelOrderState, "_synchronize_with_exchange", mock.AsyncMock(side_effect=_synchronize_with_exchange)
+        ) as _synchronize_with_exchange_mock, \
+        mock.patch.object(
+            exchange_manager.exchange, "cancel_order", mock.AsyncMock(return_value=octobot_trading.enums.OrderStatus.PENDING_CANCEL)
+        ) as cancel_order_mock:
+            # doesn't create a concurrent cancel order task let, it will be created from then on_cancel() call
+            await asyncio.gather(_create_order_if_possible_task(), _timeout_task(timeout))
+            _create_new_orders_mock.assert_called_once_with(symbol, -1, octobot_trading.enums.EvaluatorStates.VERY_LONG.value)
+            cancel_order_mock.assert_called_once()
+            _on_cancel_mock.assert_called_once()
+            handle_portfolio_and_position_update_from_order_mock.assert_not_called()    # call has been skipped for the test
+            _synchronize_with_exchange_mock.assert_called_once()
+            # ensure no error was raised
+            assert symbol not in consumer.previous_call_error_per_symbol
+            consumer.previous_call_error_per_symbol.clear()
+        assert exchange_manager.exchange_personal_data.orders_manager.get_open_orders() == []   # order no more open
+
+
+        # 6. concurrent task: open_order ends up in PENDING_CANCEL state after exchange.cancel() call
+        #   because order is already refreshing (ex: from open orders updater)
+        #   => create_order_if_possible (which has portfolio lock) will not wait for cancel order state terminate
+        open_order = await _create_initialized_open_order(exchange_manager, symbol)
+        open_order.simulated = False    # force real order simulation
+        assert exchange_manager.exchange_personal_data.orders_manager.get_open_orders() == [open_order]
+        completed_tasks.clear()
+
+        async def _synchronize_with_exchange(*_, **__):
+            # will not set order in final state => don't do anything, order stays pending
+            _synchronize_with_exchange_calls.append(1)
+            for _ in range(10):
+                # wait a few cycles to let _cancel_order trading_mode.cancel_order
+                await asyncio_tools.wait_asyncio_next_cycle()
+            _synchronize_with_exchange_calls.append(1)
+
+        async def _create_new_orders(*_, **__):
+            assert _origin_handle_portfolio_and_position_update_from_order_calls == []
+            # for now order is open
+            assert exchange_manager.exchange_personal_data.orders_manager.get_open_orders() == [open_order]
+            assert open_order.status == octobot_trading.enums.OrderStatus.OPEN
+            assert isinstance(open_order.state, personal_data.OpenOrderState)
+            # order cancel will end up in PENDING_CANCEL
+            await consumer.trading_mode.cancel_order(open_order, wait_for_cancelling=True) is True
+            # _synchronize_with_exchange_calls is still waiting
+            assert _synchronize_with_exchange_calls == [1]
+            assert open_order.is_refreshing() is True
+            # order now in pending cancel state
+            assert isinstance(open_order.state, personal_data.CancelOrderState)
+            assert open_order.is_refreshing_canceling_state() is True
+            for _ in range(10):
+                # wait a few cycles to make sure _origin_handle_portfolio_and_position_update_from_order_calls
+                # really don't get called (locked by consumer lock
+                await asyncio_tools.wait_asyncio_next_cycle()
+            # _delayed_handle_portfolio_and_position_update_from_order is waiting for consumer to release lock
+            assert _origin_handle_portfolio_and_position_update_from_order_calls == []
+            # _synchronize_with_exchange_calls is now completed
+            assert _synchronize_with_exchange_calls == [1, 1]
+
+        async def _on_cancel(*args, **kwargs):
+            await origin_on_cancel(*args, **kwargs)
+
+        async def _cancel_order(*args, **kwargs):
+            # simulate an on_cancel call from somewhere else => triggers a canceling state
+            open_order.status = octobot_trading.enums.OrderStatus.PENDING_CANCEL
+            asyncio.create_task(open_order.on_cancel()) # will leave order in refreshing
+            await asyncio_tools.wait_asyncio_next_cycle()   # let task run once (trigger refreshing state)
+            return octobot_trading.enums.OrderStatus.PENDING_CANCEL
+
+        _origin_handle_portfolio_and_position_update_from_order_calls = []
+        _synchronize_with_exchange_calls = []
+        origin_on_cancel = open_order.on_cancel
+        origin_ensure_probably_canceled_order = exchange_manager.trader._ensure_probably_canceled_order
+        assert exchange_manager.exchange_personal_data.orders_manager.get_open_orders() == [open_order]
+        with mock.patch.object(
+            consumer, "create_new_orders", mock.AsyncMock(side_effect=_create_new_orders)
+        ) as _create_new_orders_mock, mock.patch.object(
+            open_order, "on_cancel", mock.AsyncMock(side_effect=_on_cancel)
+        ) as _on_cancel_mock, \
+        mock.patch.object(
+            exchange_manager.exchange_personal_data, "handle_portfolio_and_position_update_from_order", mock.AsyncMock()
+        ) as handle_portfolio_and_position_update_from_order_mock, \
+        mock.patch.object(
+            personal_data.CancelOrderState, "_synchronize_with_exchange", mock.AsyncMock(side_effect=_synchronize_with_exchange)
+        ) as _synchronize_with_exchange_mock, \
+        mock.patch.object(
+            exchange_manager.exchange, "cancel_order", mock.AsyncMock(side_effect=_cancel_order)
+        ) as cancel_order_mock, \
+        mock.patch.object(
+            exchange_manager.trader, "_ensure_probably_canceled_order", mock.AsyncMock(side_effect=origin_ensure_probably_canceled_order)
+        ) as _ensure_probably_canceled_order_mock:
+            # doesn't create a concurrent cancel order task let, it will be created from then on_cancel() call
+            await asyncio.gather(_create_order_if_possible_task(), _timeout_task(timeout))
+            _create_new_orders_mock.assert_called_once_with(symbol, -1, octobot_trading.enums.EvaluatorStates.VERY_LONG.value)
+            cancel_order_mock.assert_called_once()
+            _on_cancel_mock.assert_called_once()
+            handle_portfolio_and_position_update_from_order_mock.assert_not_called()    # call has been skipped for the test
+            _synchronize_with_exchange_mock.assert_called_once()
+            _ensure_probably_canceled_order_mock.assert_called_once()
+            # ensure no error was raised
+            assert symbol not in consumer.previous_call_error_per_symbol
+            consumer.previous_call_error_per_symbol.clear()
+        assert exchange_manager.exchange_personal_data.orders_manager.get_open_orders() == []   # order no more open
+
 
 async def _create_initialized_open_order(exchange_manager, symbol):
     open_order = personal_data.BuyLimitOrder(exchange_manager.trader)