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

{OctoBot-Trading-2.4.142 → OctoBot-Trading-2.4.144}/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.144] - 2025-01-10
+### Fixed
+[Backtesting] fix default market status + adapter issues
+
+## [2.4.143] - 2025-01-08
+### Fixed
+[Orders] properly handle trigger above
+
 ## [2.4.142] - 2025-01-07
 ### Fixed
 [Order] fix _create_triggered_chained_order

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

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

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

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

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

{OctoBot-Trading-2.4.142 → OctoBot-Trading-2.4.144}/octobot_trading/enums.py

@@ -536,6 +536,7 @@ class TradingSignalOrdersAttrs(enum.Enum):
     EXCHANGE = "exchange"
     EXCHANGE_TYPE = "exchange_type"
     TYPE = "type"
+    TRIGGER_ABOVE = "trigger_above"
     QUANTITY = "quantity"
     TARGET_AMOUNT = "target_amount"
     TARGET_POSITION = "target_position"

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

@@ -57,7 +57,13 @@ class OrderCancelError(OctoBotExchangeError):
     """
 
 
-class OrderNotFoundOnCancelError(OrderCancelError):
+class ExchangeOrderCancelError(OrderCancelError):
+    """
+    Raised when an exchange failed to execute the given request because the associated order can't be cancelled
+    """
+
+
+class OrderNotFoundOnCancelError(ExchangeOrderCancelError):
     """
     Raised upon a failed order cancel because order is not found
     """

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

@@ -672,7 +672,18 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
     ) -> enums.OrderStatus:
         try:
             with self.error_describer():
-                await self.client.cancel_order(exchange_order_id, symbol=symbol, params=kwargs)
+                try:
+                    await self.client.cancel_order(exchange_order_id, symbol=symbol, params=kwargs)
+                except Exception as err:
+                    if self.exchange_manager.exchange.is_exchange_order_uncancellable(err):
+                        # handle ExchangeOrderCancelError locally not to raise it from other contexts
+                        # (such as if used in error_describer)
+                        raise octobot_trading.errors.ExchangeOrderCancelError(
+                            f"Error when handling order {html_util.get_html_summary_if_relevant(err)}. "
+                            f"Exchange is refusing to cancel this order. The order is probably filled "
+                            f"or cancelled already."
+                        ) from err
+                    raise
                 # no exception, cancel worked
             try:
                 # make sure order is canceled

{OctoBot-Trading-2.4.142 → OctoBot-Trading-2.4.144}/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.142 → OctoBot-Trading-2.4.144}/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.142 → OctoBot-Trading-2.4.144}/octobot_trading/exchanges/traders/trader.py

@@ -389,6 +389,7 @@ class Trader(util.Initializable):
             # order will just never get created
             order.is_waiting_for_chained_trigger = False
             return success
+        order_status = None
         # if real order: cancel on exchange
         if not self.simulate and not order.is_self_managed():
             try:
@@ -408,8 +409,15 @@ class Trader(util.Initializable):
                             order.exchange_order_id, order.symbol, order.order_type
                         )
             except errors.OrderCancelError as err:
-                if await self._handle_order_cancel_error(order, err, wait_for_cancelling, cancelling_timeout):
-                    return True
+                if self.exchange_manager.exchange_personal_data.orders_manager.enable_order_auto_synchronization:
+                    if await self._handle_order_cancel_error(order, err, wait_for_cancelling, cancelling_timeout):
+                        return True
+                else:
+                    self.logger.warning(
+                        f"Impossible to cancel order ({err} {err.__class__.__name__}). "
+                        f"Considering order as cancelled {order}"
+                    )
+                    order_status = enums.OrderStatus.CANCELED
             except Exception as err:
                 self.logger.exception(err, True, f"Failed to cancel order {order}")
                 return False
@@ -602,9 +610,9 @@ class Trader(util.Initializable):
         return all_cancelled, cancelled_orders
 
     async def cancel_all_open_orders_with_currency(
-            self, currency, emit_trading_signals=False,
-            wait_for_cancelling=True,
-            cancelling_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT
+        self, currency, emit_trading_signals=False,
+        wait_for_cancelling=True,
+        cancelling_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT
     ) -> bool:
         """
         Should be called only if the goal is to cancel all open orders for each traded symbol containing the

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

@@ -125,6 +125,8 @@ class RestExchange(abstract_exchange.AbstractExchange):
     EXCHANGE_CLOSED_POSITION_ERRORS: typing.List[typing.Iterable[str]] = []
     # text content of errors due to an order that would immediately trigger if created. Relevant for stop losses
     EXCHANGE_ORDER_IMMEDIATELY_TRIGGER_ERRORS: typing.List[typing.Iterable[str]] = []
+    # text content of errors due to an order that can't be cancelled on exchange (because filled or already cancelled)
+    EXCHANGE_ORDER_UNCANCELLABLE_ERRORS: typing.List[typing.Iterable[str]] = []
 
     DEFAULT_CONNECTOR_CLASS = ccxt_connector.CCXTConnector
 
@@ -1018,6 +1020,11 @@ class RestExchange(abstract_exchange.AbstractExchange):
             return exchanges_util.is_error_on_this_type(error, self.EXCHANGE_ORDER_IMMEDIATELY_TRIGGER_ERRORS)
         return False
 
+    def is_exchange_order_uncancellable(self, error: BaseException) -> bool:
+        if self.EXCHANGE_ORDER_UNCANCELLABLE_ERRORS:
+            return exchanges_util.is_error_on_this_type(error, self.EXCHANGE_ORDER_UNCANCELLABLE_ERRORS)
+        return False
+
     def is_exchange_internal_sync_error(self, error: BaseException) -> bool:
         if self.EXCHANGE_INTERNAL_SYNC_ERRORS:
             return exchanges_util.is_error_on_this_type(error, self.EXCHANGE_INTERNAL_SYNC_ERRORS)

{OctoBot-Trading-2.4.142 → OctoBot-Trading-2.4.144}/octobot_trading/personal_data/orders/order.py

@@ -59,6 +59,7 @@ class Order(util.Initializable):
         self.taker_or_maker = None
         self.timestamp = 0
         self.side = side
+        self.trigger_above = None
         self.tag = None
         self.associated_entry_ids = None
         self.broker_applied = False
@@ -138,7 +139,7 @@ class Order(util.Initializable):
                fee=None, total_cost=constants.ZERO, timestamp=None,
                order_type=None, reduce_only=None, close_position=None, position_side=None, fees_currency_side=None,
                group=None, tag=None, quantity_currency=None, exchange_creation_params=None,
-               associated_entry_id=None) -> bool:
+               associated_entry_id=None, trigger_above=None) -> bool:
         changed: bool = False
         should_update_total_cost = False
 
@@ -275,6 +276,10 @@ class Order(util.Initializable):
         if associated_entry_id is not None:
             self.associate_to_entry(associated_entry_id)
 
+        if trigger_above is not None and self.trigger_above != trigger_above:
+            changed = True
+            self.trigger_above = trigger_above
+
         if should_update_total_cost and not total_cost:
             self._update_total_cost()
 
@@ -520,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())
@@ -725,7 +730,8 @@ class Order(util.Initializable):
             total_cost=decimal.Decimal(str(raw_order.get(enums.ExchangeConstantsOrderColumns.COST.value, 0.0) or 0.0)),
             fee=order_util.parse_raw_fees(raw_order.get(enums.ExchangeConstantsOrderColumns.FEE.value, None)),
             timestamp=raw_order.get(enums.ExchangeConstantsOrderColumns.TIMESTAMP.value, None),
-            reduce_only=raw_order.get(enums.ExchangeConstantsOrderColumns.REDUCE_ONLY.value, False)
+            reduce_only=raw_order.get(enums.ExchangeConstantsOrderColumns.REDUCE_ONLY.value, False),
+            trigger_above=raw_order.get(enums.ExchangeConstantsOrderColumns.TRIGGER_ABOVE.value, None)
         )
 
     async def update_from_order(self, other_order):
@@ -875,6 +881,7 @@ class Order(util.Initializable):
             enums.ExchangeConstantsOrderColumns.FEE.value: self.fee,
             enums.ExchangeConstantsOrderColumns.REDUCE_ONLY.value: self.reduce_only,
             enums.ExchangeConstantsOrderColumns.TAG.value: self.tag,
+            enums.ExchangeConstantsOrderColumns.TRIGGER_ABOVE.value: self.trigger_above,
             enums.ExchangeConstantsOrderColumns.SELF_MANAGED.value: self.is_self_managed(),
             enums.ExchangeConstantsOrderColumns.BROKER_APPLIED.value: self.broker_applied,
         }

{OctoBot-Trading-2.4.142 → OctoBot-Trading-2.4.144}/octobot_trading/personal_data/orders/order_factory.py

@@ -68,6 +68,7 @@ def create_order_instance(
     total_cost=constants.ZERO,
     timestamp=0,
     side=None,
+    trigger_above=None,
     fees_currency_side=None,
     group=None,
     tag=None,
@@ -103,7 +104,8 @@ def create_order_instance(
         quantity_currency=quantity_currency,
         close_position=close_position,
         exchange_creation_params=exchange_creation_params,
-        associated_entry_id=associated_entry_id
+        associated_entry_id=associated_entry_id,
+        trigger_above=trigger_above,
     )
     return order
 
@@ -127,6 +129,7 @@ def create_order_from_dict(trader, order_dict):
         quantity_filled=order_dict[enums.ExchangeConstantsOrderColumns.FILLED.value],
         timestamp=order_dict[enums.ExchangeConstantsOrderColumns.TIMESTAMP.value],
         side=enums.TradeOrderSide(order_dict[enums.ExchangeConstantsOrderColumns.SIDE.value]),
+        trigger_above=order_dict.get(enums.ExchangeConstantsOrderColumns.TRIGGER_ABOVE.value),
         tag=order_dict[enums.ExchangeConstantsOrderColumns.TAG.value],
         reduce_only=order_dict[enums.ExchangeConstantsOrderColumns.REDUCE_ONLY.value],
     )

{OctoBot-Trading-2.4.142 → OctoBot-Trading-2.4.144}/octobot_trading/personal_data/orders/types/limit/limit_order.py

@@ -29,14 +29,6 @@ class LimitOrder(order_class.Order):
         self.trigger_above = self.side is enums.TradeOrderSide.SELL
         self.allow_instant_fill = constants.ALLOW_SIMULATED_ORDERS_INSTANT_FILL
 
-    def update_from_raw(self, raw_order):
-        updated = super(LimitOrder, self).update_from_raw(raw_order)
-        if enums.ExchangeConstantsOrderColumns.TRIGGER_ABOVE.value in raw_order \
-                and self.trigger_above != raw_order[enums.ExchangeConstantsOrderColumns.TRIGGER_ABOVE.value]:
-            updated = True
-            self.trigger_above = raw_order[enums.ExchangeConstantsOrderColumns.TRIGGER_ABOVE.value]
-        return updated
-
     async def update_price_if_outdated(self):
         # price is outdated if it would trigger and instantly filled order with more than the allowed tolerance
         try:

{OctoBot-Trading-2.4.142 → OctoBot-Trading-2.4.144}/octobot_trading/signals/util.py

@@ -36,6 +36,7 @@ def create_order_signal_content(
         trading_enums.TradingSignalOrdersAttrs.EXCHANGE.value: exchange_manager.exchange_name,
         trading_enums.TradingSignalOrdersAttrs.EXCHANGE_TYPE.value: exchanges.get_exchange_type(exchange_manager).value,
         trading_enums.TradingSignalOrdersAttrs.SIDE.value: order.side.value,
+        trading_enums.TradingSignalOrdersAttrs.TRIGGER_ABOVE.value: order.trigger_above,
         trading_enums.TradingSignalOrdersAttrs.TYPE.value: order.order_type.value,
         trading_enums.TradingSignalOrdersAttrs.QUANTITY.value: float(order.origin_quantity),
         trading_enums.TradingSignalOrdersAttrs.TARGET_AMOUNT.value: target_amount

{OctoBot-Trading-2.4.142 → OctoBot-Trading-2.4.144}/octobot_trading/util/test_tools/exchanges_test_tools.py

@@ -145,26 +145,67 @@ async def get_portfolio(exchange_manager, as_float=False, clear_empty=True) -> d
     }
 
 
-async def _get_open_orders(exchange_manager, symbol: str, open_orders: list):
+def _parse_order_dict(
+    exchange_manager, order: dict, force_open_or_pending_creation: bool
+) -> typing.Optional[personal_data.Order]:
+    if not order:
+        return None
+    try:
+        return personal_data.create_order_instance_from_raw(
+            exchange_manager.trader, order, force_open_or_pending_creation=force_open_or_pending_creation
+        )
+    except Exception as err:
+        logging.get_logger("_parse_order_dict").exception(
+            err,
+            True,
+            f"Unexpected error when parsing [{exchange_manager.exchange_name}] "
+            f"order ({err} {err.__class__.__name__}), order ignored: {order}"
+        )
+    return None
+
+
+def _parse_order_into_dict(
+    exchange_manager, order: dict, force_open_or_pending_creation: bool, ignore_unsupported_orders: bool
+) -> typing.Optional[dict]:
+    if (
+        ignore_unsupported_orders and
+        order[enums.ExchangeConstantsOrderColumns.TYPE.value] == enums.TradeOrderType.UNSUPPORTED.value
+    ):
+        logging.get_logger("_parse_order_into_dict").warning(
+            f"Ignored unsupported [{exchange_manager.exchange_name}] order: {order}"
+        )
+        return None
+    if parsed_order := _parse_order_dict(exchange_manager, order, force_open_or_pending_creation):
+        try:
+            return parsed_order.to_dict()
+        except Exception as err:
+            logging.get_logger("_parse_order_dict").exception(
+                err,
+                True,
+                f"Unexpected error when converting [{exchange_manager.exchange_name}] order to dict" 
+                f"({err}. {err.__class__.__name__}), order: {order}"
+            )
+    return None
+
+
+async def _get_open_orders(exchange_manager, symbol: str, open_orders: list, ignore_unsupported_orders: bool):
     orders = await exchange_manager.exchange.get_open_orders(symbol=symbol)
-    open_orders.extend(
-        personal_data.create_order_instance_from_raw(
-            exchange_manager.trader, order, force_open_or_pending_creation=True
-        ).to_dict()
-        for order in orders
-    )
+    for order in orders:
+        if order_dict := _parse_order_into_dict(exchange_manager, order, True,  ignore_unsupported_orders):
+            open_orders.append(order_dict)
 
 
 async def get_open_orders(
     exchange_manager,
     exchange_data: exchange_data_import.ExchangeData,
-    symbols: list = None
+    symbols: list = None,
+    ignore_unsupported_orders: bool = True,
 ) -> list:
     open_orders = []
 
     symbols = symbols or [market.symbol for market in exchange_data.markets]
     await asyncio.gather(*(
-        _get_open_orders(exchange_manager, symbol, open_orders) for symbol in symbols
+        _get_open_orders(exchange_manager, symbol, open_orders, ignore_unsupported_orders) for symbol in symbols
     ))
     return open_orders
 
@@ -177,25 +218,26 @@ async def get_order(
     return await exchange_manager.exchange.get_order(exchange_order_id, symbol=symbol)
 
 
-async def _get_cancelled_orders(exchange_manager, symbol: str, cancelled_orders: list):
+async def _get_cancelled_orders(exchange_manager, symbol: str, cancelled_orders: list, ignore_unsupported_orders: bool):
     orders = await exchange_manager.exchange.get_cancelled_orders(symbol=symbol)
-    cancelled_orders.extend(
-        personal_data.create_order_instance_from_raw(
-            exchange_manager.trader, order, force_open_or_pending_creation=False
-        ).to_dict()
-        for order in orders
-    )
+    for order in orders:
+        if order_dict := _parse_order_into_dict(
+            exchange_manager, order, False, ignore_unsupported_orders
+        ):
+            cancelled_orders.append(order_dict)
 
 
 async def get_cancelled_orders(
     exchange_manager,
     exchange_data: exchange_data_import.ExchangeData,
-    symbols: list = None
+    symbols: list = None,
+    ignore_unsupported_orders: bool = True,
 ) -> list:
     cancelled_orders = []
     symbols = symbols or [market.symbol for market in exchange_data.markets]
     await asyncio.gather(*(
-        _get_cancelled_orders(exchange_manager, symbol, cancelled_orders) for symbol in symbols
+        _get_cancelled_orders(exchange_manager, symbol, cancelled_orders, ignore_unsupported_orders)
+        for symbol in symbols
     ))
     return cancelled_orders
 
@@ -230,11 +272,11 @@ async def _create_order(
 ) -> typing.Optional[personal_data.Order]:
     symbol = order_dict[enums.ExchangeConstantsOrderColumns.SYMBOL.value]
     side, order_type = personal_data.parse_order_type(order_dict)
-    order_params = exchange_manager.exchange.get_order_additional_params(
-        personal_data.create_order_instance_from_raw(
-            exchange_manager.trader, order_dict, force_open_or_pending_creation=True
-        )
-    )
+    temp_order = _parse_order_dict(exchange_manager, order_dict, True)
+    if temp_order is None:
+        logging.get_logger("_create_order").error(f"Unexpected: order can't be created.")
+        return None
+    order_params = exchange_manager.exchange.get_order_additional_params(temp_order)
     created_order = await exchange_manager.exchange.create_order(
         order_type,
         symbol,
@@ -246,10 +288,9 @@ async def _create_order(
         params=order_params
     )
     # is private, to use in tests context only
-    order = personal_data.create_order_instance_from_raw(
-        exchange_manager.trader, created_order, force_open_or_pending_creation=True
-    ) if created_order else None
-    if not order:
+    order = _parse_order_dict(exchange_manager, created_order, True)
+    if order is None:
+        logging.get_logger("_create_order").error(f"Unexpected: order hasn't been created.")
         return order
     if order.status is enums.OrderStatus.PENDING_CREATION and order_creation_timeout > 0:
         try:
@@ -284,9 +325,8 @@ async def wait_for_other_status(order: personal_data.Order, timeout) -> personal
                 f"Order fetched with status different from {origin_status} after {iterations} "
                 f"iterations and {round(time.time() - t0)}s"
             )
-            return personal_data.create_order_instance_from_raw(
-                order.trader, raw_order, force_open_or_pending_creation=False
-            )
+            if parsed_order := _parse_order_dict(order.exchange_manager, raw_order, False):
+                return parsed_order
         if time.time() - t0 + constants.CREATED_ORDER_FORCED_UPDATE_PERIOD >= timeout:
             break
         await asyncio.sleep(constants.CREATED_ORDER_FORCED_UPDATE_PERIOD)

{OctoBot-Trading-2.4.142 → OctoBot-Trading-2.4.144}/tests/exchanges/traders/test_trader.py

@@ -23,7 +23,10 @@ import pytest
 import time
 from mock import AsyncMock, patch, Mock
 
-from octobot_trading.errors import TooManyOpenPositionError, InvalidLeverageValue, OrderEditError
+from octobot_trading.errors import (
+    TooManyOpenPositionError, InvalidLeverageValue, OrderEditError,
+    ExchangeOrderCancelError, OrderNotFoundOnCancelError
+)
 from octobot_trading.personal_data import LinearPosition
 import octobot_commons.constants as commons_constants
 from octobot_commons.asyncio_tools import wait_asyncio_next_cycle
@@ -178,6 +181,70 @@ class TestTrader:
 
         await self.stop(exchange_manager)
 
+
+    async def test_cancel_order_error(self):
+        _, exchange_manager, trader_inst = await self.init_default()
+
+        limit_buy = BuyLimitOrder(trader_inst)
+        limit_buy.update(order_type=TraderOrderType.SELL_LIMIT,
+                         symbol=self.DEFAULT_SYMBOL,
+                         current_price=decimal.Decimal("70"),
+                         quantity=decimal.Decimal("10"),
+                         price=decimal.Decimal("70"))
+        try:
+            trader_inst.simulate = False
+            with mock.patch.object(trader_inst, "_handle_order_cancel_error", mock.AsyncMock(
+                return_value=True
+            )) as _handle_order_cancel_error_mock:
+                with mock.patch.object(exchange_manager.exchange, "cancel_order", mock.AsyncMock(
+                    return_value=OrderStatus.CANCELED
+                )) as cancel_order_mock:
+                    assert await trader_inst.cancel_order(limit_buy) is True
+                    cancel_order_mock.assert_called_once()
+                    _handle_order_cancel_error_mock.assert_not_called()
+                    limit_buy.state = None
+                with mock.patch.object(exchange_manager.exchange, "cancel_order", mock.AsyncMock(
+                    side_effect=ExchangeOrderCancelError
+                )) as cancel_order_mock:
+                    assert await trader_inst.cancel_order(limit_buy) is True
+                    assert cancel_order_mock.call_count == 2
+                    _handle_order_cancel_error_mock.assert_called_once()
+                    _handle_order_cancel_error_mock.reset_mock()
+                    limit_buy.state = None
+                with mock.patch.object(exchange_manager.exchange, "cancel_order", mock.AsyncMock(
+                    side_effect=OrderNotFoundOnCancelError
+                )) as cancel_order_mock:
+                    assert await trader_inst.cancel_order(limit_buy) is True
+                    assert cancel_order_mock.call_count == 2
+                    _handle_order_cancel_error_mock.assert_called_once()
+                    _handle_order_cancel_error_mock.reset_mock()
+                    limit_buy.state = None
+
+                with trader_inst.exchange_manager.exchange_personal_data.orders_manager.disabled_order_auto_synchronization():
+                    with mock.patch.object(exchange_manager.exchange, "cancel_order", mock.AsyncMock(
+                        side_effect=OrderNotFoundOnCancelError
+                    )) as cancel_order_mock:
+                        assert await trader_inst.cancel_order(limit_buy) is True
+                        assert cancel_order_mock.call_count == 2
+                        _handle_order_cancel_error_mock.assert_not_called()
+                        limit_buy.state = None
+
+            with mock.patch.object(trader_inst, "_handle_order_cancel_error", mock.AsyncMock(
+                return_value=False
+            )) as _handle_order_cancel_error_mock:
+                with mock.patch.object(exchange_manager.exchange, "cancel_order", mock.AsyncMock(
+                    side_effect=ExchangeOrderCancelError
+                )) as cancel_order_mock:
+                    assert await trader_inst.cancel_order(limit_buy) is True
+                    assert cancel_order_mock.call_count == 2
+                    _handle_order_cancel_error_mock.assert_called_once()
+                    _handle_order_cancel_error_mock.reset_mock()
+                    limit_buy.state = None
+
+        finally:
+            trader_inst.simulate = True
+
+
     async def test_cancel_open_orders_default_symbol(self):
         config, exchange_manager, trader_inst = await self.init_default()
         orders_manager = exchange_manager.exchange_personal_data.orders_manager

{OctoBot-Trading-2.4.142 → OctoBot-Trading-2.4.144}/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)