OctoBot-Trading 2.4.2__tar.gz → 2.4.4__tar.gz

{OctoBot-Trading-2.4.2 → OctoBot-Trading-2.4.4}/CHANGELOG.md

@@ -4,6 +4,17 @@ 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.4] - 2023-06-08
+### Fixed
+- Orders sync issues
+- Order sizing issues when using % param
+
+## [2.4.3] - 2023-05-12
+### Updated
+- Use orders shared if for pnl
+### Fixed
+- Chained orders in trading signals
+
 ## [2.4.2] - 2023-05-10
 ### Added
 - Display timeframe

{OctoBot-Trading-2.4.2 → OctoBot-Trading-2.4.4/OctoBot_Trading.egg-info}/PKG-INFO

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

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

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

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

{OctoBot-Trading-2.4.2 → OctoBot-Trading-2.4.4}/octobot_trading/api/portfolio.py

@@ -40,14 +40,12 @@ def get_global_portfolio_currencies_values(exchange_managers: list) -> dict:
     currencies_values = {}
     for exchange in exchange_managers:
         this_currency_values = (
-            exchange.exchange_personal_data.portfolio_manager \
-                .portfolio_value_holder.get_current_crypto_currencies_values()
+            exchange.exchange_personal_data.portfolio_manager
+            .portfolio_value_holder.get_current_crypto_currencies_values()
         )
         for currency, value in this_currency_values.items():
             if currency not in currencies_values:
                 currencies_values[currency] = value
-            else:
-                currencies_values[currency] += value
     return currencies_values
 
 

{OctoBot-Trading-2.4.2 → OctoBot-Trading-2.4.4}/octobot_trading/api/trades.py

@@ -25,7 +25,7 @@ def get_trade_history(
 ) -> list:
     return [
         trade.to_dict() if as_dict else trade
-        for trade in exchange_manager.exchange_personal_data.trades_manager.trades.values()
+        for trade in exchange_manager.exchange_personal_data.trades_manager.get_trades()
         if _trade_filter(trade, quote, symbol, since, include_cancelled)
     ]
 

{OctoBot-Trading-2.4.2 → OctoBot-Trading-2.4.4}/octobot_trading/constants.py

@@ -181,16 +181,6 @@ CANCEL_ORDER_STATUS_SCOPE = [enums.OrderStatus.PENDING_CANCEL,
                              enums.OrderStatus.EXPIRED,
                              enums.OrderStatus.REJECTED]
 
-ORDER_NON_EMPTY_FIELDS = [enums.ExchangeConstantsOrderColumns.ID.value,
-                          enums.ExchangeConstantsOrderColumns.TIMESTAMP.value,
-                          enums.ExchangeConstantsOrderColumns.SYMBOL.value,
-                          enums.ExchangeConstantsOrderColumns.TYPE.value,
-                          enums.ExchangeConstantsOrderColumns.SIDE.value,
-                          enums.ExchangeConstantsOrderColumns.PRICE.value,
-                          enums.ExchangeConstantsOrderColumns.AMOUNT.value,
-                          enums.ExchangeConstantsOrderColumns.STATUS.value]
-ORDER_REQUIRED_FIELDS = ORDER_NON_EMPTY_FIELDS + [enums.ExchangeConstantsOrderColumns.REMAINING.value]
-
 DEFAULT_INITIALIZATION_EVENT_TOPICS = [
     commons_enums.InitializationEventExchangeTopics.BALANCE,
     commons_enums.InitializationEventExchangeTopics.ORDERS,

{OctoBot-Trading-2.4.2 → OctoBot-Trading-2.4.4}/octobot_trading/enums.py

@@ -299,6 +299,7 @@ class ExchangeConstantsOrderBookTickerColumns(enum.Enum):
 class ExchangeConstantsOrderColumns(enum.Enum):
     INFO = "info"
     ID = "id"
+    EXCHANGE_ID = "exchange_id"
     ORDER_ID = "order_id"
     TIMESTAMP = "timestamp"
     DATETIME = 'datetime'
@@ -331,6 +332,10 @@ class ExchangeConstantsOrderColumns(enum.Enum):
     ENTRIES = "entries"
 
 
+class TradeExtraConstants(enum.Enum):
+    CREATION_TIME = "creation_time"
+
+
 class ExchangeConstantsPositionColumns(enum.Enum):
     ID = "id"
     TIMESTAMP = "timestamp"
@@ -523,7 +528,7 @@ class TradingSignalOrdersAttrs(enum.Enum):
     GROUP_ID = "group_id"
     GROUP_TYPE = "group_type"
     TAG = "tag"
-    SHARED_SIGNAL_ORDER_ID = "shared_signal_order_id"
+    ORDER_ID = "order_id"
     BUNDLED_WITH = "bundled_with"
     CHAINED_TO = "chained_to"
     ADDITIONAL_ORDERS = "additional_orders"
@@ -545,12 +550,12 @@ class StoredOrdersAttr(enum.Enum):
     CHAINED_ORDERS = "co"
     EXCHANGE_CREATION_PARAMS = "ecp"
     TRADER_CREATION_KWARGS = "tck"
-    SHARED_SIGNAL_ORDER_ID = "ssoi"
     HAS_BEEN_BUNDLED = "hbb"
     ENTRIES = "en"
     UPDATE_TIME = "ut"
     UPDATE_TYPE = "uty"
     ORDER_ID = "oid"
+    ORDER_EXCHANGE_ID = "oeid"
     ORDER_STATUS = "s"
     ORDER_DETAILS = "d"
     UPDATE_WITH_TRIGGERING_ORDER_FEES = "utf"

{OctoBot-Trading-2.4.2 → OctoBot-Trading-2.4.4}/octobot_trading/errors.py

@@ -111,16 +111,6 @@ class PortfolioOperationError(Exception):
     """
 
 
-class MissingOrderException(Exception):
-    """
-    Raised when an order is missing
-    """
-
-    def __init__(self, order_id):
-        super().__init__()
-        self.order_id = order_id
-
-
 class InvalidOrderState(Exception):
     """
     Raised when an order state is handled on a previously cleared order

{OctoBot-Trading-2.4.2 → OctoBot-Trading-2.4.4}/octobot_trading/exchange_data/ohlcv/channel/ohlcv_updater.py

@@ -67,7 +67,7 @@ class OHLCVUpdater(ohlcv_channel.OHLCVProducer):
                 ]
 
     def _get_traded_pairs(self):
-        return self.channel.exchange_manager.exchange_config.watched_pairs
+        return self.channel.exchange_manager.exchange_config.traded_symbol_pairs
 
     def _get_time_frames(self):
         return self.channel.exchange_manager.exchange_config.available_time_frames

{OctoBot-Trading-2.4.2 → OctoBot-Trading-2.4.4}/octobot_trading/exchanges/abstract_exchange.py

@@ -227,10 +227,10 @@ class AbstractExchange(tentacles_management.AbstractTentacle):
         """
         raise NotImplementedError("get_all_currencies_price_ticker is not implemented")
 
-    async def get_order(self, order_id: str, symbol: str = None, **kwargs: dict) -> dict:
+    async def get_order(self, exchange_order_id: str, symbol: str = None, **kwargs: dict) -> dict:
         """
         Get the order data from the exchange
-        :param order_id: the order id
+        :param exchange_order_id: the order id on exchange
         :param symbol: the order symbol
         :return: the order data
         """
@@ -288,11 +288,11 @@ class AbstractExchange(tentacles_management.AbstractTentacle):
         raise NotImplementedError("get_leverage_tiers is not implemented")
 
     async def cancel_order(
-            self, order_id: str, symbol: str, order_type: enums.TraderOrderType, **kwargs: dict
+            self, exchange_order_id: str, symbol: str, order_type: enums.TraderOrderType, **kwargs: dict
     ) -> enums.OrderStatus:
         """
         Cancel a order on the exchange
-        :param order_id: the order id
+        :param exchange_order_id: the order id on exchange
         :param symbol: the order symbol
         :param order_type: the type of the order
         :return: True if the order is successfully cancelled

{OctoBot-Trading-2.4.2 → OctoBot-Trading-2.4.4}/octobot_trading/exchanges/adapters/abstract_adapter.py

@@ -16,6 +16,7 @@
 import decimal
 
 import octobot_trading.errors as errors
+import octobot_trading.enums as enums
 import octobot_commons.logging as logging
 import octobot_commons.constants as commons_constants
 
@@ -133,6 +134,9 @@ class AbstractAdapter:
         return default
 
     def fix_order(self, raw, **kwargs):
+        # id is reserved for octobot managed id. store exchange id in EXCHANGE_ID
+        raw[enums.ExchangeConstantsOrderColumns.EXCHANGE_ID.value] = \
+            raw.pop(enums.ExchangeConstantsOrderColumns.ID.value, None)
         # add generic logic if necessary
         return raw
 
@@ -182,7 +186,11 @@ class AbstractAdapter:
         raise NotImplementedError("parse_public_recent_trades is not implemented")
 
     def fix_trades(self, raw, **kwargs):
-        # add generic logic if necessary
+        for trade in raw:
+            # id is reserved for octobot managed id. store exchange id in EXCHANGE_ID
+            trade[enums.ExchangeConstantsOrderColumns.EXCHANGE_ID.value] = \
+                trade.pop(enums.ExchangeConstantsOrderColumns.ID.value, None)
+            # add generic logic if necessary
         return raw
 
     def parse_trades(self, fixed, **kwargs):

{OctoBot-Trading-2.4.2 → OctoBot-Trading-2.4.4}/octobot_trading/exchanges/connectors/ccxt/ccxt_adapter.py

@@ -148,6 +148,7 @@ class CCXTAdapter(adapters.AbstractAdapter):
         for recent_trade in fixed:
             recent_trade.pop(ecoc.INFO.value, None)
             recent_trade.pop(ecoc.DATETIME.value, None)
+            recent_trade.pop(ecoc.EXCHANGE_ID.value, None)
             recent_trade.pop(ecoc.ID.value, None)
             recent_trade.pop(ecoc.ORDER.value, None)
             recent_trade.pop(ecoc.FEE.value, None)

{OctoBot-Trading-2.4.2 → OctoBot-Trading-2.4.4}/octobot_trading/exchanges/connectors/ccxt/ccxt_connector.py

@@ -285,12 +285,12 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
             raise octobot_trading.errors.FailedRequest(f"Failed to get_all_currencies_price_ticker {e}")
 
     # ORDERS
-    async def get_order(self, order_id: str, symbol: str = None, **kwargs: dict) -> dict:
+    async def get_order(self, exchange_order_id: str, symbol: str = None, **kwargs: dict) -> dict:
         if self.client.has['fetchOrder']:
             try:
                 with self.error_describer():
                     return self.adapter.adapt_order(
-                        await self.client.fetch_order(order_id, symbol, params=kwargs),
+                        await self.client.fetch_order(exchange_order_id, symbol, params=kwargs),
                         symbol=symbol
                     )
             except ccxt.OrderNotFound:
@@ -306,7 +306,7 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
             # When fetch_order is not supported, uses get_open_orders and extract order id
             open_orders = await self.get_open_orders(symbol=symbol)
             for order in open_orders:
-                if order.get(ecoc.ID.value, None) == order_id:
+                if order.get(ecoc.EXCHANGE_ID.value, None) == exchange_order_id:
                     return order
         return None  # OrderNotFound
 
@@ -449,7 +449,7 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
     async def create_limit_trailing_stop_order(self, symbol, quantity, price=None, side=None, params=None) -> dict:
         raise NotImplementedError("create_limit_trailing_stop_order is not implemented")
 
-    async def edit_order(self, order_id: str, order_type: enums.TraderOrderType, symbol: str,
+    async def edit_order(self, exchange_order_id: str, order_type: enums.TraderOrderType, symbol: str,
                          quantity: float, price: float, stop_price: float = None, side: str = None,
                          current_price: float = None, params: dict = None):
         ccxt_order_type = self.get_ccxt_order_type(order_type)
@@ -459,21 +459,23 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
             price_to_use = None
         # do not use keyword arguments here as default ccxt edit order is passing *args (and not **kwargs)
         return self.adapter.adapt_order(
-            await self.client.edit_order(order_id, symbol, ccxt_order_type, side, quantity, price_to_use, params),
+            await self.client.edit_order(
+                exchange_order_id, symbol, ccxt_order_type, side, quantity, price_to_use, params
+            ),
             symbol=symbol
         )
 
     async def cancel_order(
-            self, order_id: str, symbol: str, order_type: enums.TraderOrderType, **kwargs: dict
+        self, exchange_order_id: str, symbol: str, order_type: enums.TraderOrderType, **kwargs: dict
     ) -> enums.OrderStatus:
         try:
             with self.error_describer():
-                await self.client.cancel_order(order_id, symbol=symbol, params=kwargs)
+                await self.client.cancel_order(exchange_order_id, symbol=symbol, params=kwargs)
                 # no exception, cancel worked
             try:
                 # make sure order is canceled
                 cancelled_order = await self.exchange_manager.exchange.get_order(
-                    order_id, symbol=symbol
+                    exchange_order_id, symbol=symbol
                 )
                 if cancelled_order is None or personal_data.parse_is_cancelled(cancelled_order):
                     return enums.OrderStatus.CANCELED
@@ -489,13 +491,13 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
                 # get a cancelled order).
                 return enums.OrderStatus.CANCELED
         except ccxt.OrderNotFound as e:
-            self.logger.debug(f"Trying to cancel order with id {order_id} but order was not found")
+            self.logger.debug(f"Trying to cancel order with id {exchange_order_id} but order was not found")
             raise octobot_trading.errors.OrderCancelError from e
         except (ccxt.NotSupported, octobot_trading.errors.NotSupported) as e:
             raise octobot_trading.errors.NotSupported from e
         except Exception as e:
-            self.logger.exception(e, True, f"Unexpected error when cancelling order with id: "
-                                           f"{order_id} failed to cancel | {e} ({e.__class__.__name__})")
+            self.logger.exception(e, True, f"Unexpected error when cancelling order with exchange id: "
+                                           f"{exchange_order_id} failed to cancel | {e} ({e.__class__.__name__})")
             raise e
 
     async def get_positions(self, symbols=None, **kwargs: dict) -> list:
@@ -726,8 +728,8 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
     def parse_currency(self, currency):
         return self.client.safe_currency_code(currency)
 
-    def parse_order_id(self, order):
-        return order.get(ecoc.ID.value, None)
+    def parse_exhange_order_id(self, order):
+        return order.get(ecoc.EXCHANGE_ID.value, None)
 
     def parse_order_symbol(self, order):
         return order.get(ecoc.SYMBOL.value, None)

{OctoBot-Trading-2.4.2 → OctoBot-Trading-2.4.4}/octobot_trading/exchanges/connectors/ccxt/ccxt_websocket_connector.py

@@ -565,7 +565,7 @@ class CCXTWebsocketConnector(abstract_websocket_exchange.AbstractWebsocketExchan
                     message = f"Closed exchange connection to force reconnect. Error: {err}"
                     if subsequent_disconnections > 1 and subsequent_disconnections % 5 == 0:
                         self.logger.error(
-                            f"Multiple disconnections if a row [{subsequent_disconnections}]for {ws_des}. {message}"
+                            f"Multiple disconnections if a row [{subsequent_disconnections}] for {ws_des}. {message}"
                         )
                     else:
                         self.logger.debug(message)

{OctoBot-Trading-2.4.2 → OctoBot-Trading-2.4.4}/octobot_trading/exchanges/traders/trader.py

@@ -165,7 +165,7 @@ class Trader(util.Initializable):
         if not order.can_be_edited():
             raise errors.OrderEditError(f"Order can't be edited, order: {order}")
         changed = False
-        previous_order_id = order.order_id
+        previous_exchange_order_id = order.exchange_order_id
         try:
             async with order.lock:
                 # now that we got the lock, ensure we can edit the order
@@ -183,7 +183,7 @@ class Trader(util.Initializable):
                         order_params.update(params or {})
                         # fill in every param as some exchange rely on re-creating the order altogether
                         edited_order = await self.exchange_manager.exchange.edit_order(
-                            order.order_id,
+                            order.exchange_order_id,
                             order.order_type,
                             order.symbol,
                             quantity=order.origin_quantity if edited_quantity is None else edited_quantity,
@@ -222,9 +222,9 @@ class Trader(util.Initializable):
                 self.logger.info(f"Edited order: {order}")
             return changed
         finally:
-            if previous_order_id != order.order_id:
+            if previous_exchange_order_id != order.exchange_order_id:
                 # order id changed: update orders_manager to keep consistency
-                self.exchange_manager.exchange_personal_data.orders_manager.replace_order(previous_order_id, order)
+                self.exchange_manager.exchange_personal_data.orders_manager.replace_order(order.order_id, order)
 
     async def _create_new_order(self, new_order, params: dict,
                                 wait_for_creation=True,
@@ -263,16 +263,15 @@ class Trader(util.Initializable):
             # rebind local elements to new order instance
             if new_order.order_group:
                 updated_order.add_to_order_group(new_order.order_group)
+            updated_order.order_id = new_order.order_id
             updated_order.tag = new_order.tag
             updated_order.chained_orders = new_order.chained_orders
             for chained_order in new_order.chained_orders:
                 chained_order.triggered_by = updated_order
-                chained_order.replace_associated_entry_id(new_order.order_id, updated_order.order_id)
             updated_order.triggered_by = new_order.triggered_by
             updated_order.has_been_bundled = new_order.has_been_bundled
             updated_order.exchange_creation_params = new_order.exchange_creation_params
             updated_order.is_waiting_for_chained_trigger = new_order.is_waiting_for_chained_trigger
-            updated_order.set_shared_signal_order_id(new_order.shared_signal_order_id)
             updated_order.associated_entry_ids = new_order.associated_entry_ids
             updated_order.update_with_triggering_order_fees = new_order.update_with_triggering_order_fees
 
@@ -362,7 +361,7 @@ class Trader(util.Initializable):
                 async with order.lock:
                     try:
                         order_status = await self.exchange_manager.exchange.cancel_order(
-                            order.order_id, order.symbol, order.order_type
+                            order.exchange_order_id, order.symbol, order.order_type
                         )
                     except errors.NotSupported:
                         raise
@@ -370,7 +369,7 @@ class Trader(util.Initializable):
                         # retry to cancel order
                         self.logger.debug(f"Failed to cancel order ({err} {err.__class__.__name__}), retrying")
                         order_status = await self.exchange_manager.exchange.cancel_order(
-                            order.order_id, order.symbol, order.order_type
+                            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):
@@ -444,19 +443,19 @@ class Trader(util.Initializable):
         await order.state.wait_for_terminate(cancelling_timeout)
         self.logger.debug(f"Completed order cancelling, order: {order}")
 
-    async def cancel_order_with_id(self, order_id, emit_trading_signals=False,
+    async def cancel_order_with_id(self, exchange_order_id, emit_trading_signals=False,
                                    wait_for_cancelling=True,
                                    cancelling_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT):
         """
         Gets order matching order_id from the OrderManager and calls self.cancel_order() on it
-        :param order_id: Id of the order to cancel
+        :param exchange_order_id: Exchange id of the order to cancel
         :param emit_trading_signals: when true, trading signals will be emitted
         :param wait_for_cancelling: when True, always make sure the order is completely cancelled before returning.
         :param cancelling_timeout: time before raising a timeout error when waiting for an order cancel
         :return: True if cancel is successful, False if order is not found or cancellation failed
         """
         try:
-            order = self.exchange_manager.exchange_personal_data.orders_manager.get_order(order_id)
+            order = self.exchange_manager.exchange_personal_data.orders_manager.get_order(exchange_order_id)
             async with signals.remote_signal_publisher(self.exchange_manager, order.symbol, emit_trading_signals):
                 return await signals.cancel_order(
                     self.exchange_manager,

{OctoBot-Trading-2.4.2 → OctoBot-Trading-2.4.4}/octobot_trading/exchanges/types/rest_exchange.py

@@ -39,7 +39,7 @@ import octobot_trading.personal_data.orders as orders
 
 
 class RestExchange(abstract_exchange.AbstractExchange):
-    ORDER_NON_EMPTY_FIELDS = [ecoc.ID.value, ecoc.TIMESTAMP.value, ecoc.SYMBOL.value, ecoc.TYPE.value,
+    ORDER_NON_EMPTY_FIELDS = [ecoc.EXCHANGE_ID.value, ecoc.TIMESTAMP.value, ecoc.SYMBOL.value, ecoc.TYPE.value,
                               ecoc.SIDE.value, ecoc.PRICE.value, ecoc.AMOUNT.value, ecoc.STATUS.value]
     ORDER_REQUIRED_FIELDS = ORDER_NON_EMPTY_FIELDS + [ecoc.REMAINING.value]
     PRINT_DEBUG_LOGS = False
@@ -143,7 +143,7 @@ class RestExchange(abstract_exchange.AbstractExchange):
             return await self._verify_order(created_order, order_type, symbol, price, side)
         return None
 
-    async def edit_order(self, order_id: str, order_type: enums.TraderOrderType, symbol: str,
+    async def edit_order(self, exchange_order_id: str, order_type: enums.TraderOrderType, symbol: str,
                          quantity: decimal.Decimal, price: decimal.Decimal,
                          stop_price: decimal.Decimal = None, side: enums.TradeOrderSide = None,
                          current_price: decimal.Decimal = None,
@@ -158,17 +158,17 @@ class RestExchange(abstract_exchange.AbstractExchange):
             side = None if side is None else side.value
             params = {} if params is None else params
             params.update(self.exchange_manager.exchange_backend.get_orders_parameters(None))
-            edited_order = await self._edit_order(order_id, order_type, symbol, quantity=float_quantity,
+            edited_order = await self._edit_order(exchange_order_id, order_type, symbol, quantity=float_quantity,
                                                   price=float_price, stop_price=float_stop_price, side=side,
                                                   current_price=float_current_price, params=params)
             order = await self._verify_order(edited_order, order_type, symbol, price, side)
             return order
         return None
 
-    async def _edit_order(self, order_id: str, order_type: enums.TraderOrderType, symbol: str,
+    async def _edit_order(self, exchange_order_id: str, order_type: enums.TraderOrderType, symbol: str,
                           quantity: float, price: float, stop_price: float = None, side: str = None,
                           current_price: float = None, params: dict = None):
-        return await self.connector.edit_order(order_id, order_type, symbol,
+        return await self.connector.edit_order(exchange_order_id, order_type, symbol,
                                                quantity, price, stop_price, side,
                                                current_price, params)
 
@@ -196,14 +196,14 @@ class RestExchange(abstract_exchange.AbstractExchange):
     async def _verify_order(self, created_order, order_type, symbol, price, side, get_order_params=None):
         # some exchanges are not returning the full order details on creation: fetch it if necessary
         if created_order and not self._ensure_order_details_completeness(created_order):
-            if ecoc.ID.value in created_order:
-                order_id = created_order[ecoc.ID.value]
-                if order_id is None:
-                    self.logger.error(f"No order id on created order: {created_order}")
+            if ecoc.EXCHANGE_ID.value in created_order:
+                order_exchange_id = created_order[ecoc.EXCHANGE_ID.value]
+                if order_exchange_id is None:
+                    self.logger.error(f"No order exchange id on created order: {created_order}")
                     return None
                 params = get_order_params or {}
                 fetched_order = await self.get_order(
-                    created_order[ecoc.ID.value], symbol=symbol, **params
+                    created_order[ecoc.EXCHANGE_ID.value], symbol=symbol, **params
                 )
                 if fetched_order is None:
                     created_order[ecoc.STATUS.value] = enums.OrderStatus.PENDING_CREATION.value
@@ -446,27 +446,27 @@ class RestExchange(abstract_exchange.AbstractExchange):
     async def get_all_currencies_price_ticker(self, **kwargs: dict) -> typing.Optional[list]:
         return await self.connector.get_all_currencies_price_ticker(**kwargs)
 
-    async def get_order(self, order_id: str, symbol: str = None, **kwargs: dict) -> dict:
+    async def get_order(self, exchange_order_id: str, symbol: str = None, **kwargs: dict) -> dict:
         return await self._ensure_order_completeness(
-            await self.connector.get_order(order_id, symbol=symbol, **kwargs),
+            await self.connector.get_order(exchange_order_id, symbol=symbol, **kwargs),
             symbol, **kwargs
         )
 
-    async def get_order_from_open_and_closed_orders(self, order_id: str, symbol: str = None, **kwargs: dict) -> dict:
+    async def get_order_from_open_and_closed_orders(self, exchange_order_id: str, symbol: str = None, **kwargs: dict) -> dict:
         for order in await self.get_open_orders(symbol, **kwargs):
-            if order[enums.ExchangeConstantsOrderColumns.ID.value] == order_id:
+            if order[enums.ExchangeConstantsOrderColumns.EXCHANGE_ID.value] == exchange_order_id:
                 return order
         for order in await self.get_closed_orders(symbol, **kwargs):
-            if order[enums.ExchangeConstantsOrderColumns.ID.value] == order_id:
+            if order[enums.ExchangeConstantsOrderColumns.EXCHANGE_ID.value] == exchange_order_id:
                 return order
         return None  # OrderNotFound
 
-    async def get_order_from_trades(self, symbol, order_id, order_to_update=None):
+    async def get_order_from_trades(self, symbol, exchange_order_id, order_to_update=None):
         order_to_update = order_to_update or {}
         trades = await self.get_my_recent_trades(symbol)
         # usually the right trade is within the last ones
         for trade in trades[::-1]:
-            if trade[ecoc.ORDER.value] == order_id:
+            if trade[ecoc.ORDER.value] == exchange_order_id:
                 return exchanges_util.update_raw_order_from_raw_trade(order_to_update, trade)
         return None  #OrderNotFound
 
@@ -505,47 +505,49 @@ class RestExchange(abstract_exchange.AbstractExchange):
         ]
 
     async def _ensure_orders_completeness(
-        self, raw_orders, symbol, since=None, limit=None, trades_by_order_id=None, **kwargs
+        self, raw_orders, symbol, since=None, limit=None, trades_by_exchange_order_id=None, **kwargs
     ):
         if not self.REQUIRE_ORDER_FEES_FROM_TRADES \
                 or not any(exchanges_util.is_missing_trading_fees(order) for order in raw_orders):
             return raw_orders
-        trades_by_order_id = trades_by_order_id or await self._get_trades_by_order_id(
+        trades_by_exchange_order_id = trades_by_exchange_order_id or await self._get_trades_by_exchange_order_id(
             symbol=symbol, since=since, limit=limit, **kwargs
         )
         return [
-            await self._ensure_order_completeness(order, symbol, trades_by_order_id=trades_by_order_id, **kwargs)
+            await self._ensure_order_completeness(
+                order, symbol, trades_by_exchange_order_id=trades_by_exchange_order_id, **kwargs
+            )
             for order in raw_orders
         ]
 
     async def _ensure_order_completeness(
-        self, raw_order, symbol, since=None, limit=None, trades_by_order_id=None, **kwargs
+        self, raw_order, symbol, since=None, limit=None, trades_by_exchange_order_id=None, **kwargs
     ):
         if not self.REQUIRE_ORDER_FEES_FROM_TRADES or not exchanges_util.is_missing_trading_fees(raw_order):
             return raw_order
-        trades_by_order_id = trades_by_order_id or await self._get_trades_by_order_id(
+        trades_by_exchange_order_id = trades_by_exchange_order_id or await self._get_trades_by_exchange_order_id(
             symbol=symbol, since=since, limit=limit, **kwargs
         )
-        exchanges_util.apply_trades_fees(raw_order, trades_by_order_id)
+        exchanges_util.apply_trades_fees(raw_order, trades_by_exchange_order_id)
         return raw_order
 
-    async def _get_trades_by_order_id(self, symbol=None, since=None, limit=None, **kwargs):
-        trades_by_order_id = {}
+    async def _get_trades_by_exchange_order_id(self, symbol=None, since=None, limit=None, **kwargs):
+        trades_by_exchange_order_id = {}
         for trade in await self.get_my_recent_trades(symbol=symbol, since=since, limit=limit, **kwargs):
-            order_id = trade[enums.ExchangeConstantsOrderColumns.ORDER.value]
-            if order_id in trades_by_order_id:
-                trades_by_order_id[order_id].append(trade)
+            exchange_order_id = trade[enums.ExchangeConstantsOrderColumns.ORDER.value]
+            if exchange_order_id in trades_by_exchange_order_id:
+                trades_by_exchange_order_id[exchange_order_id].append(trade)
             else:
-                trades_by_order_id[order_id] = [trade]
-        return trades_by_order_id
+                trades_by_exchange_order_id[exchange_order_id] = [trade]
+        return trades_by_exchange_order_id
 
     async def get_my_recent_trades(self, symbol: str = None, since: int = None, limit: int = None, **kwargs: dict) -> list:
         return await self.connector.get_my_recent_trades(symbol=symbol, since=since, limit=limit, **kwargs)
 
     async def cancel_order(
-            self, order_id: str, symbol: str, order_type: enums.TraderOrderType, **kwargs: dict
+            self, exchange_order_id: str, symbol: str, order_type: enums.TraderOrderType, **kwargs: dict
     ) -> enums.OrderStatus:
-        return await self.connector.cancel_order(order_id, symbol, order_type, **kwargs)
+        return await self.connector.cancel_order(exchange_order_id, symbol, order_type, **kwargs)
 
     def get_trade_fee(self, symbol, order_type, quantity, price, taker_or_maker):
         return self.connector.get_trade_fee(symbol, order_type, quantity, price, taker_or_maker)
@@ -836,8 +838,8 @@ class RestExchange(abstract_exchange.AbstractExchange):
     def parse_order_book_ticker(self, order_book_ticker):
         return self.connector.parse_order_book_ticker(order_book_ticker)
 
-    def parse_order_id(self, order):
-        return self.connector.parse_order_id(order)
+    def parse_exhange_order_id(self, order):
+        return self.connector.parse_exhange_order_id(order)
 
     def parse_order_symbol(self, order):
         return self.connector.parse_order_symbol(order)

{OctoBot-Trading-2.4.2 → OctoBot-Trading-2.4.4}/octobot_trading/exchanges/types/websocket_exchange.py

@@ -14,6 +14,7 @@
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
 import asyncio
+import sys
 import concurrent.futures as futures
 
 import octobot_commons.thread_util as thread_util
@@ -134,7 +135,8 @@ class WebSocketExchange(abstract_websocket.AbstractWebsocketExchange):
             try:
                 self.websocket_connectors_executors = futures.ThreadPoolExecutor(
                     max_workers=len(self.websocket_connectors),
-                    thread_name_prefix=f"{self.get_name()}-{self.exchange_name}-pool-executor"
+                    thread_name_prefix=f"{self.get_name()}-{self.exchange_name}-pool-executor",
+
                 )
 
                 self.websocket_connectors_tasks = [
@@ -201,7 +203,10 @@ class WebSocketExchange(abstract_websocket.AbstractWebsocketExchange):
             self.logger.error(f"Error when closing sockets : {e}")
         for websocket_task in self.websocket_connectors_tasks:
             websocket_task.cancel()
-        thread_util.stop_thread_pool_executor_non_gracefully(self.websocket_connectors_executors)
+        if sys.version_info.minor >= 9:
+            self.websocket_connectors_executors.shutdown(True)
+        else:
+            thread_util.stop_thread_pool_executor_non_gracefully(self.websocket_connectors_executors)
         self.websocket_connectors_executors = None
 
     def add_pairs(self, pairs, watching_only=False):