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

{OctoBot-Trading-2.4.141 → OctoBot-Trading-2.4.143}/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.143] - 2025-01-08
+### Fixed
+[Orders] properly handle trigger above
+
+## [2.4.142] - 2025-01-07
+### Fixed
+[Order] fix _create_triggered_chained_order
+
 ## [2.4.141] - 2025-01-05
 ### Added
 [TradingSignals] add positions and leverage update

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

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

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

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

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

{OctoBot-Trading-2.4.141 → OctoBot-Trading-2.4.143}/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.141 → OctoBot-Trading-2.4.143}/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.141 → OctoBot-Trading-2.4.143}/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.141 → OctoBot-Trading-2.4.143}/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.141 → OctoBot-Trading-2.4.143}/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.141 → OctoBot-Trading-2.4.143}/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()
 
@@ -532,7 +537,7 @@ class Order(util.Initializable):
         except errors.ExchangeClosedPositionError as err:
             message = (
                 f"chained order is cancelled as it can't be created: position is closed "
-                f"on exchange ({err}) order: {order.id}"
+                f"on exchange ({err}) order: {order.order_id}"
             )
             if order.reduce_only:
                 # can happen on reduce only orders
@@ -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.141 → OctoBot-Trading-2.4.143}/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.141 → OctoBot-Trading-2.4.143}/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.141 → OctoBot-Trading-2.4.143}/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.141 → OctoBot-Trading-2.4.143}/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.141 → OctoBot-Trading-2.4.143}/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.141 → OctoBot-Trading-2.4.143}/tests/personal_data/orders/test_order.py

@@ -398,9 +398,8 @@ 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 = mock.Mock(
-        create_triggered_equivalent_order=mock.AsyncMock(return_value=eq_chained_order_1),
-    )
+    chained_order_1 = personal_data.Order(trader_inst)
+    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:
@@ -419,7 +418,7 @@ async def test_create_triggered_chained_order_mock(trader_simulator):
 
     # ExchangeClosedPositionError
     chained_order_1.status = None
-    chained_order_1.state = 1
+    chained_order_1.state = mock.Mock()
     with mock.patch.object(
         order_util, "create_as_chained_order", mock.AsyncMock(side_effect=errors.ExchangeClosedPositionError)
     ) as create_as_chained_order_mock:
@@ -440,7 +439,7 @@ async def test_create_triggered_chained_order_mock(trader_simulator):
         return
 
     chained_order_1.status = 1
-    chained_order_1.state = 1
+    chained_order_1.state = mock.Mock()
     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(

{OctoBot-Trading-2.4.141 → OctoBot-Trading-2.4.143}/tests/personal_data/orders/test_order_factory.py

@@ -81,6 +81,24 @@ class TestOrderFactory:
         }
         assert personal_data.parse_order_type(ccxt_order_sell_limit) == (TradeOrderSide.SELL, TraderOrderType.SELL_LIMIT)
 
+        ccxt_order_stop_loss_sell = {
+            "side": TradeOrderSide.SELL,
+            "type": TradeOrderType.STOP_LOSS
+        }
+        assert personal_data.parse_order_type(ccxt_order_stop_loss_sell) == (TradeOrderSide.SELL, TraderOrderType.STOP_LOSS)
+
+        ccxt_order_stop_loss_buy = {
+            "side": TradeOrderSide.BUY,
+            "type": TradeOrderType.STOP_LOSS
+        }
+        assert personal_data.parse_order_type(ccxt_order_stop_loss_buy) == (TradeOrderSide.BUY, TraderOrderType.STOP_LOSS)
+
+        unsupported = {
+            "side": TradeOrderSide.BUY,
+            "type": TradeOrderType.UNSUPPORTED
+        }
+        assert personal_data.parse_order_type(unsupported) == (TradeOrderSide.BUY, TraderOrderType.UNSUPPORTED)
+
         await self.stop(exchange_manager)
 
     async def test_create_order_from_dict(self):
@@ -114,7 +132,35 @@ class TestOrderFactory:
         assert limit_order.exchange_creation_params == {"plop": 1, "fake_param": True}
         # associated_entry_ids are not copied
         assert created_from_dict.associated_entry_ids is None
+        assert created_from_dict.trigger_above is limit_order.trigger_above is True
         assert limit_order.associated_entry_ids == ["1"]
+
+
+        _, exchange_manager, trader_inst = await self.init_default()
+        limit_order = personal_data.create_order_instance(
+            trader_inst,
+            TraderOrderType.SELL_LIMIT,
+            self.DEFAULT_SYMBOL,
+            price,
+            quantity,
+            price=price,
+            trigger_above=False,
+        )
+        order_dict = limit_order.to_dict()
+        created_from_dict = personal_data.create_order_from_dict(trader_inst, order_dict)
+        assert created_from_dict.origin_price == limit_order.origin_price == price
+        assert created_from_dict.origin_quantity == limit_order.origin_quantity == quantity
+        assert created_from_dict.__class__ is limit_order.__class__ == personal_data.SellLimitOrder
+        assert created_from_dict.symbol == limit_order.symbol == self.DEFAULT_SYMBOL
+        assert created_from_dict.reduce_only is limit_order.reduce_only is False
+        # exchange_creation_params are not copied
+        assert created_from_dict.exchange_creation_params == {}
+        assert limit_order.exchange_creation_params == {}
+        # associated_entry_ids are not copied
+        assert created_from_dict.associated_entry_ids is None
+        assert created_from_dict.trigger_above is limit_order.trigger_above is False
+        assert limit_order.associated_entry_ids is None
+
         await self.stop(exchange_manager)
 
     async def test_create_order_from_order_storage_details_with_simple_order(self):
@@ -127,6 +173,7 @@ class TestOrderFactory:
                          current_price=decimal.Decimal("70"),
                          quantity=decimal.Decimal("10"),
                          price=decimal.Decimal("70"))
+            order.trigger_above = True
             order_storage_details = orders_storage._format_order(order, exchange_manager)
             order_storage_details[StoredOrdersAttr.ENTRIES.value] = ["11111"]
 
@@ -141,6 +188,7 @@ class TestOrderFactory:
             assert created_order.timestamp == order.timestamp
             assert created_order.creation_time == order.creation_time
             assert created_order.origin_price == order.origin_price
+            assert created_order.trigger_above is order.trigger_above is True
             assert created_order.__class__ is order.__class__
             # associated_entry_ids are added from order_storage_details but not in original order
             assert created_order.associated_entry_ids == ["11111"]
@@ -149,6 +197,7 @@ class TestOrderFactory:
             # updated creation_time (as with chained orders): creation_time is used to restore order
             assert created_order.creation_time != 123
             order.creation_time = 123
+            order.trigger_above = False
 
             order_storage_details = orders_storage._format_order(order, exchange_manager)
             created_order = await personal_data.create_order_from_order_storage_details(
@@ -160,6 +209,7 @@ class TestOrderFactory:
             assert created_order.timestamp == 123   # aligned with creation time
             assert created_order.creation_time == 123   # aligned with creation time
             assert created_order.origin_price == order.origin_price
+            assert created_order.trigger_above is order.trigger_above is False
             assert created_order.__class__ is order.__class__
             # associated_entry_ids are added from order_storage_details but not in original order
             assert created_order.associated_entry_ids is None