OctoBot-Trading 2.4.74__tar.gz → 2.4.76__tar.gz

{OctoBot-Trading-2.4.74 → OctoBot-Trading-2.4.76}/CHANGELOG.md

@@ -4,6 +4,18 @@ 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.76] - 2024-04-12
+### Added
+- [Exchanges] Handle order type open status for symbol
+### Updated
+- [Exchanges] Handle portfolio optimization using limit orders
+
+## [2.4.75] - 2024-04-11
+### Fixed
+- [Exchanges] Properly handle order not found errors
+- [Order] Rare synch issues on creation
+- [Order] Missing ungrouped stop orders when restarting
+
 ## [2.4.74] - 2024-04-07
 ### Added
 - [Exchanges] ExchangeCompliancyError error

{OctoBot-Trading-2.4.74 → OctoBot-Trading-2.4.76/OctoBot_Trading.egg-info}/PKG-INFO

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

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

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

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

{OctoBot-Trading-2.4.74 → OctoBot-Trading-2.4.76}/octobot_trading/constants.py

@@ -42,6 +42,9 @@ ALLOW_SIMULATED_ORDERS_INSTANT_FILL = os_util.parse_boolean_environment_var(
 ORDER_DATA_FETCHING_TIMEOUT = 5 * commons_constants.MINUTE_TO_SECONDS
 CHAINED_ORDER_PRICE_FETCHING_TIMEOUT = 1    # should be instant or ignored
 CHAINED_ORDERS_OUTDATED_PRICE_ALLOWANCE = decimal.Decimal("0.005")  # allows 0.5% outdated price error
+# create instantly filled limit orders 0.5% beyond market
+INSTANT_FILLED_LIMIT_ORDER_PRICE_DELTA = decimal.Decimal("0.005")
+CREATED_ORDER_FORCED_UPDATE_PERIOD = 5
 
 # Tentacles
 TRADING_MODE_REQUIRED_STRATEGIES = "required_strategies"
@@ -130,13 +133,13 @@ EXCHANGE_PERMISSION_ERRORS: typing.List[typing.Iterable[str]] = [
 
     # coinbase ex: coinbase {"error":"PERMISSION_DENIED",
     # "error_details":"Missing required scopes","message":"Missing required scopes"}
-    ("permission_denied", )
+    ("permission_denied", "required scopes"),
 ]
 
 # text content of errors due to exchange compliancy rules
 EXCHANGE_COMPLIANCY_ERRORS: typing.List[typing.Iterable[str]] = [
     # OKX ex: Trading of this pair or contract is restricted due to local compliance requirements
-    ("restricted ", "compliance"),
+    ("restricted", "compliance"),
 ]
 
 CONFIG_DEFAULT_FEES = 0.001

{OctoBot-Trading-2.4.74 → OctoBot-Trading-2.4.76}/octobot_trading/errors.py

@@ -93,6 +93,12 @@ class FailedRequest(Exception):
     """
 
 
+class UnavailableOrderTypeForMarketError(Exception):
+    """
+    Raised when an exchange refuses to create a given type of order that should normally be supported
+    """
+
+
 class AuthenticationError(Exception):
     """
     Raised when an exchange failed to authenticate

{OctoBot-Trading-2.4.74 → OctoBot-Trading-2.4.76}/octobot_trading/exchanges/__init__.py

@@ -78,6 +78,7 @@ from octobot_trading.exchanges.util import (
     get_exchange_details,
     is_api_permission_error,
     is_exchange_rules_compliancy_error,
+    is_error_on_this_type,
     force_disable_web_socket,
     check_web_socket_config,
     search_websocket_class,
@@ -164,6 +165,7 @@ __all__ = [
     "get_exchange_details",
     "is_api_permission_error",
     "is_exchange_rules_compliancy_error",
+    "is_error_on_this_type",
     "AbstractExchange",
     "is_channel_managed_by_websocket",
     "is_channel_fully_managed_by_websocket",

{OctoBot-Trading-2.4.74 → OctoBot-Trading-2.4.76}/octobot_trading/exchanges/abstract_exchange.py

@@ -17,6 +17,7 @@ import asyncio
 import typing
 import decimal
 import time
+import contextlib
 
 import octobot_commons.constants
 import octobot_commons.enums as common_enums
@@ -94,6 +95,8 @@ class AbstractExchange(tentacles_management.AbstractTentacle):
 
         self.is_unreachable = False
 
+        self._creating_exchange_order_ids = set()
+
         if self.exchange_manager.tentacles_setup_config is not None:
             self.load_user_inputs_from_class(self.exchange_manager.tentacles_setup_config, self.tentacle_config)
 
@@ -380,7 +383,7 @@ class AbstractExchange(tentacles_management.AbstractTentacle):
         """
         raise NotImplementedError("get_bundled_order_parameters is not implemented")
 
-    def is_supported_order_type(self, order_type):
+    def is_supported_order_type(self, order_type: enums.TraderOrderType) -> bool:
         """
         Check if the order type is supported by the current exchange instance
         Should be used to know if we should simulate this order or create it on the exchange
@@ -389,6 +392,12 @@ class AbstractExchange(tentacles_management.AbstractTentacle):
         """
         return order_type not in self.get_supported_elements(enums.ExchangeSupportedElements.UNSUPPORTED_ORDERS)
 
+    def is_market_open_for_order_type(self, symbol: str, order_type: enums.TraderOrderType) -> bool:
+        """
+        Override if necessary
+        """
+        return True
+
     def get_trade_fee(self, symbol: str, order_type: enums.TraderOrderType, quantity, price, taker_or_maker):
         """
         Calculates fees resulting to a trade
@@ -698,3 +707,19 @@ class AbstractExchange(tentacles_management.AbstractTentacle):
     def handle_token_error(self, error):
         self.logger.error(f"Exchange configuration is invalid : please check your configuration ! "
                           f"({error.__class__.__name__}: {error})")
+
+    @contextlib.contextmanager
+    def creating_order(self, creating_order: dict):
+        exchange_order_id = creating_order.get(
+            enums.ExchangeConstantsOrderColumns.EXCHANGE_ID.value
+        ) if creating_order else None
+        try:
+            self._creating_exchange_order_ids.add(exchange_order_id)
+            yield
+        finally:
+            self._creating_exchange_order_ids.remove(exchange_order_id)
+
+    def is_creating_order(self, exchange_order_id):
+        if exchange_order_id is None:
+            return False
+        return exchange_order_id in self._creating_exchange_order_ids

{OctoBot-Trading-2.4.74 → OctoBot-Trading-2.4.76}/octobot_trading/exchanges/connectors/ccxt/ccxt_connector.py

@@ -351,8 +351,12 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
                 # some exchanges are throwing this error when an order is cancelled (ex: coinbase pro)
                 raise octobot_trading.errors.NotSupported(e) from e
             except ccxt.ExchangeError as e:
-                # something went wrong and ccxt did not expect it
-                raise octobot_trading.errors.FailedRequest(e) from e
+                if self.exchange_manager.exchange.is_order_not_found_error(e):
+                    # when an OrderNotFound error should have been raised but is not for some reason
+                    pass
+                else:
+                    # something went wrong and ccxt did not expect it
+                    raise octobot_trading.errors.FailedRequest(e) from e
         else:
             # When fetch_order is not supported, uses get_open_orders or get_closed_orders and extract order id
             for method in (self.get_open_orders, self.get_closed_orders):

{OctoBot-Trading-2.4.74 → OctoBot-Trading-2.4.76}/octobot_trading/exchanges/traders/trader.py

@@ -279,7 +279,9 @@ class Trader(util.Initializable):
 
             if is_pending_creation:
                 # register order as pending order, it will then be added to live orders in order manager once open
-                self.exchange_manager.exchange_personal_data.orders_manager.register_pending_creation_order(updated_order)
+                self.exchange_manager.exchange_personal_data.orders_manager.register_pending_creation_order(
+                    updated_order
+                )
 
         await updated_order.initialize()
         if is_pending_creation and wait_for_creation \

{OctoBot-Trading-2.4.74 → OctoBot-Trading-2.4.76}/octobot_trading/exchanges/types/rest_exchange.py

@@ -89,6 +89,9 @@ class RestExchange(abstract_exchange.AbstractExchange):
     # Set when order cost is not (yet) accurately computed for a given exchange
     MAX_INCREASED_POSITION_QUANTITY_MULTIPLIER = constants.ONE
 
+    # text content of errors due to orders not found errors
+    EXCHANGE_ORDER_NOT_FOUND_ERRORS: typing.List[typing.Iterable[str]] = []
+
     DEFAULT_CONNECTOR_CLASS = ccxt_connector.CCXTConnector
 
     def __init__(self, config, exchange_manager, connector_class=None):
@@ -152,7 +155,8 @@ class RestExchange(abstract_exchange.AbstractExchange):
                 stop_price=stop_price, side=side, current_price=current_price,
                 reduce_only=reduce_only, params=params)
             self.logger.debug(f"Created order: {created_order}")
-            return await self._verify_order(created_order, order_type, symbol, price, side)
+            with self.creating_order(created_order):
+                return await self._verify_order(created_order, order_type, symbol, price, side)
         return None
 
     async def edit_order(self, exchange_order_id: str, order_type: enums.TraderOrderType, symbol: str,
@@ -192,30 +196,35 @@ class RestExchange(abstract_exchange.AbstractExchange):
             self.log_order_creation_error(e, order_type, symbol, quantity, price, stop_price)
             if self.__class__.PRINT_DEBUG_LOGS:
                 self.logger.warning(str(e))
-            raise errors.MissingFunds(e)
-        except ccxt.NotSupported:
-            raise errors.NotSupported
+            raise errors.MissingFunds(e) from e
+        except ccxt.NotSupported as err:
+            raise errors.NotSupported from err
         except ccxt.AuthenticationError as err:
             # invalid api key or missing trading rights
             raise errors.AuthenticationError(
                 f"Error when handling order {err}. Please make sure that trading permissions are on for this API key."
-            )
+            ) from err
         except ccxt.DDoSProtection as e:
             # raised upon rate limit issues, last response data might have details on what is happening
             if self.should_log_on_ddos_exception(e):
                 self.connector.log_ddos_error(e)
             raise errors.FailedRequest(f"Failed to order operation: {e.__class__.__name__} {e}") from e
         except Exception as e:
+            if not self.is_market_open_for_order_type(symbol, order_type):
+                raise errors.UnavailableOrderTypeForMarketError(
+                    f"Error when handling order {e}. "
+                    f"Exchange currently refuses to create orders of type {order_type} on {symbol}."
+                ) from e
             if exchanges_util.is_api_permission_error(e):
                 # invalid api key or missing trading rights
                 raise errors.AuthenticationError(
                     f"Error when handling order {e}. Please make sure that trading permissions are on for this API key."
-                )
+                ) from e
             if exchanges_util.is_exchange_rules_compliancy_error(e):
                 raise errors.ExchangeCompliancyError(
                     f"Error when handling order {e}. Exchange is refusing this order request on this account because "
                     f"of its compliancy requirements."
-                )
+                ) from e
             self.log_order_creation_error(e, order_type, symbol, quantity, price, stop_price)
             print(traceback.format_exc(), file=sys.stderr)
             self.logger.exception(e, False, f"Unexpected error during order operation: {e}")
@@ -866,6 +875,11 @@ class RestExchange(abstract_exchange.AbstractExchange):
     def is_skipping_empty_candles_in_ohlcv_fetch(self):
         return self.IS_SKIPPING_EMPTY_CANDLES_IN_OHLCV_FETCH
 
+    def is_order_not_found_error(self, error: BaseException) -> bool:
+        if self.EXCHANGE_ORDER_NOT_FOUND_ERRORS:
+            return exchanges_util.is_error_on_this_type(error, self.EXCHANGE_ORDER_NOT_FOUND_ERRORS)
+        return False
+
     """
     Auto fetched and filled exchanges
     """

{OctoBot-Trading-2.4.74 → OctoBot-Trading-2.4.76}/octobot_trading/exchanges/util/__init__.py

@@ -46,6 +46,7 @@ from octobot_trading.exchanges.util.exchange_util import (
     get_exchange_details,
     is_api_permission_error,
     is_exchange_rules_compliancy_error,
+    is_error_on_this_type,
 )
 from octobot_trading.exchanges.util import websockets_util
 from octobot_trading.exchanges.util.websockets_util import (
@@ -80,6 +81,7 @@ __all__ = [
     "get_exchange_details",
     "is_api_permission_error",
     "is_exchange_rules_compliancy_error",
+    "is_error_on_this_type",
     "force_disable_web_socket",
     "check_web_socket_config",
     "search_websocket_class",

{OctoBot-Trading-2.4.74 → OctoBot-Trading-2.4.76}/octobot_trading/exchanges/util/exchange_util.py

@@ -429,14 +429,14 @@ def get_associated_symbol(exchange_manager, asset: str, target_asset: str) -> (t
 
 
 def is_api_permission_error(error: BaseException) -> bool:
-    return _is_error_on_this_type(error, constants.EXCHANGE_PERMISSION_ERRORS)
+    return is_error_on_this_type(error, constants.EXCHANGE_PERMISSION_ERRORS)
 
 
 def is_exchange_rules_compliancy_error(error: BaseException) -> bool:
-    return _is_error_on_this_type(error, constants.EXCHANGE_COMPLIANCY_ERRORS)
+    return is_error_on_this_type(error, constants.EXCHANGE_COMPLIANCY_ERRORS)
 
 
-def _is_error_on_this_type(error: BaseException, descriptions: typing.List[typing.Iterable[str]]) -> bool:
+def is_error_on_this_type(error: BaseException, descriptions: typing.List[typing.Iterable[str]]) -> bool:
     lower_error = str(error).lower()
     for identifiers in descriptions:
         if all(identifier in lower_error for identifier in identifiers):

{OctoBot-Trading-2.4.74 → OctoBot-Trading-2.4.76}/octobot_trading/modes/modes_util.py

@@ -120,6 +120,18 @@ async def convert_asset_to_target_asset(
             )
             return created_orders
 
+        if trading_personal_data.get_trade_order_type(order_type) is not trading_enums.TradeOrderType.MARKET:
+            # can't use market orders: use limit orders with price a bit under the current price to instant fill it.
+            price_delta = price * constants.INSTANT_FILLED_LIMIT_ORDER_PRICE_DELTA
+            if order_type is trading_enums.TraderOrderType.SELL_LIMIT:
+                price -= price_delta
+            elif order_type is trading_enums.TraderOrderType.BUY_LIMIT:
+                price += price_delta
+            else:
+                trading_mode.logger.error(
+                    f"Unhandled order type in convertor limit order price adapter: {order_type}"
+                )
+
         # get order quantity
         quantity = _get_available_or_target_quantity(trading_mode, symbol, order_type, price, asset_amount)
         symbol_market = trading_mode.exchange_manager.exchange.get_market_status(symbol, with_fixer=False)
@@ -147,6 +159,15 @@ def _get_associated_symbol_and_order_type(trading_mode, asset: str, target_asset
     symbol, reversed_symbol = exchange_util.get_associated_symbol(trading_mode.exchange_manager, asset, target_asset)
     order_type = trading_enums.TraderOrderType.BUY_MARKET if reversed_symbol else \
         trading_enums.TraderOrderType.SELL_MARKET
+    if not trading_mode.exchange_manager.exchange.is_market_open_for_order_type(symbol, order_type):
+        # can't use market orders: use limit orders instead
+        order_type = trading_enums.TraderOrderType.BUY_LIMIT if order_type is trading_enums.TraderOrderType.BUY_MARKET \
+            else trading_enums.TraderOrderType.SELL_LIMIT
+        if not trading_mode.exchange_manager.exchange.is_market_open_for_order_type(symbol, order_type):
+            # can't convert asset: still try with limit orders but it will probably fail
+            trading_mode.logger.error(
+                f"Both market and {order_type} order are currently unsupported. Trying limit orders anyway."
+            )
     return symbol, order_type
 
 

{OctoBot-Trading-2.4.74 → OctoBot-Trading-2.4.76}/octobot_trading/personal_data/orders/channel/orders.py

@@ -36,11 +36,19 @@ class OrdersProducer(exchanges_channel.ExchangeChannelProducer):
             pending_groups = {}  # Used when restoring orders from order storage:
             # a dict of order groups for which to check if associated self-managed orders are to be created
             for order in orders:
+                exchange_order_id: str = self.channel.exchange_manager.exchange.parse_exhange_order_id(order)
                 symbol = self.channel.exchange_manager.get_exchange_symbol(
                     self.channel.exchange_manager.exchange.parse_order_symbol(order)
                 )
+                if self.channel.exchange_manager.exchange.is_creating_order(exchange_order_id):
+                    # ignore orders that are being created
+                    self.logger.debug(
+                        f"Ignored update from order channel for {symbol} order with exchange order id "
+                        f"{exchange_order_id} as "
+                        f"this order is being created and will automatically be updated once creation is complete."
+                    )
+                    continue
                 symbols.add(symbol)
-                exchange_order_id: str = self.channel.exchange_manager.exchange.parse_exhange_order_id(order)
 
                 # if this order was not managed by order_manager before
                 is_new_order = not self.channel.exchange_manager.exchange_personal_data.orders_manager. \
@@ -83,6 +91,16 @@ class OrdersProducer(exchanges_channel.ExchangeChannelProducer):
         except Exception as e:
             self.logger.exception(e, True, f"Exception when triggering update: {e}")
 
+    async def _restore_required_virtual_orders(self):
+        """
+        Restore virtual orders that would not be restored otherwise
+        Should only be called once or will create the same virtual orders multiple times
+        """
+        pending_groups = {}
+        await orders_storage_operations.create_required_virtual_orders(
+            pending_groups, self.channel.exchange_manager
+        )
+
     async def _handle_open_order_update(
         self, symbol, order_dict, exchange_order_id, is_from_bot, is_new_order, pending_groups
     ):

{OctoBot-Trading-2.4.74 → OctoBot-Trading-2.4.76}/octobot_trading/personal_data/orders/channel/orders_updater.py

@@ -76,6 +76,7 @@ class OrdersUpdater(orders_channel.OrdersProducer):
                 self.DEPENDENCIES_TIMEOUT
             )
             await self.fetch_and_push(is_from_bot=False, retry_till_success=True)
+            await self._restore_required_virtual_orders()
         except errors.NotSupported:
             self.logger.error(f"{self.channel.exchange_manager.exchange_name} is not supporting open orders updates")
             await self.pause()

{OctoBot-Trading-2.4.74 → OctoBot-Trading-2.4.76}/octobot_trading/personal_data/orders/channel/orders_updater_simulator.py

@@ -33,3 +33,7 @@ class OrdersUpdaterSimulator(orders_updater.OrdersUpdater):
         """
         Used to subscribe at least one recent trades consumer during backtesting
         """
+
+    async def _restore_required_virtual_orders(self):
+        # nothing to do
+        pass

{OctoBot-Trading-2.4.74 → OctoBot-Trading-2.4.76}/octobot_trading/personal_data/orders/order_factory.py

@@ -13,6 +13,8 @@
 #
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
+import octobot_commons.logging as logging
+
 import octobot_trading.personal_data as personal_data
 import octobot_trading.enums as enums
 import octobot_trading.constants as constants
@@ -150,3 +152,4 @@ async def restore_chained_orders_from_storage_order_details(order, order_details
                 **chained_order.get(enums.StoredOrdersAttr.TRADER_CREATION_KWARGS.value, {}),
             )
             order.add_chained_order(chained_order_inst)
+            logging.get_logger(order.get_logger_name()).debug(f"Restored chained order: {chained_order_inst}")

{OctoBot-Trading-2.4.74 → OctoBot-Trading-2.4.76}/octobot_trading/personal_data/orders/orders_storage_operations.py

@@ -14,6 +14,7 @@
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
 import octobot_commons.logging as logging
+import octobot_trading.enums as enums
 import octobot_trading.personal_data.orders.order_factory as order_factory
 import octobot_trading.personal_data.orders.groups.group_util as group_util
 
@@ -30,6 +31,7 @@ async def apply_order_storage_details_if_any(order, exchange_manager, pending_gr
         order.exchange_order_id
     )
     if order_details:
+        logging.get_logger(LOGGER_NAME).debug(f"Updating fetched order {order} using stored order details")
         order.update_from_storage_order_details(order_details)
         await create_orders_storage_related_elements(order, order_details, exchange_manager, pending_groups)
 
@@ -45,21 +47,43 @@ async def create_orders_storage_related_elements(order, order_storage_details, e
     )
 
 
+async def create_order_from_storage_data(order_desc: dict, exchange_manager, pending_groups):
+    created_order = await order_factory.create_order_from_order_storage_details(
+        order_desc, exchange_manager, pending_groups
+    )
+    await created_order.initialize()
+    return created_order
+
+
 async def _create_storage_self_managed_orders_from_group(pending_group_id, exchange_manager, pending_groups):
     try:
         to_create_orders = exchange_manager.storage_manager.orders_storage \
             .get_startup_self_managed_orders_details_from_group(pending_group_id)
         for order_desc in to_create_orders:
-            created_order = await order_factory.create_order_from_order_storage_details(
-                order_desc, exchange_manager, pending_groups
-            )
-            await created_order.initialize()
+            await create_order_from_storage_data(order_desc, exchange_manager, pending_groups)
     except Exception as err:
         logging.get_logger(LOGGER_NAME).exception(
             err, True, f"Error when creating {pending_group_id} group self-managed orders with stored data: {err}"
         )
 
 
+async def create_required_virtual_orders(pending_groups, exchange_manager):
+    virtual_orders = exchange_manager.storage_manager.orders_storage.get_all_self_managed_startup_orders()
+    # virtual order that are not within a group will only be restored here
+    virtual_non_grouped_order_details = [
+        order
+        for order in virtual_orders
+        if order.get(enums.StoredOrdersAttr.GROUP.value, {}) == {}
+    ]
+    logger = logging.get_logger(LOGGER_NAME)
+    for order_details in virtual_non_grouped_order_details:
+        try:
+            order = await create_order_from_storage_data(order_details, exchange_manager, pending_groups)
+            logger.debug(f"Restored order from storage: {order}")
+        except Exception as err:
+            logger.exception(err, True, f"Error when restoring virtual order order using stored data: {err}")
+
+
 async def create_missing_self_managed_orders_from_storage_order_groups(pending_groups, exchange_manager):
     # create order groups' associated self-managed orders if any
     to_complete_groups = list(pending_groups.keys())

{OctoBot-Trading-2.4.74 → OctoBot-Trading-2.4.76}/octobot_trading/storage/orders_storage.py

@@ -124,10 +124,16 @@ class OrdersStorage(abstract_storage.AbstractStorage):
     def get_startup_self_managed_orders_details_from_group(self, group_id):
         return [
             order
-            for order in self.startup_orders.values()
+            for order in self.get_all_self_managed_startup_orders()
             if order.get(enums.StoredOrdersAttr.GROUP.value, {}).get(enums.StoredOrdersAttr.GROUP_ID.value, None)
             == group_id
-            and order.get(constants.STORAGE_ORIGIN_VALUE, {})
+        ]
+
+    def get_all_self_managed_startup_orders(self):
+        return [
+            order
+            for order in self.startup_orders.values()
+            if order.get(constants.STORAGE_ORIGIN_VALUE, {})
             .get(enums.ExchangeConstantsOrderColumns.SELF_MANAGED.value, False)
         ]
 

{OctoBot-Trading-2.4.74 → OctoBot-Trading-2.4.76}/octobot_trading/util/test_tools/exchanges_test_tools.py

@@ -21,6 +21,8 @@ import typing
 import octobot_commons.asyncio_tools as asyncio_tools
 import octobot_commons.enums as common_enums
 import octobot_commons.constants as commons_constants
+import octobot_commons.logging as logging
+import octobot_trading.constants as constants
 import octobot_trading.enums as enums
 import octobot_trading.api as trading_api
 import octobot_trading.exchanges as exchanges
@@ -172,7 +174,12 @@ async def get_trades(
     return trades
 
 
-async def create_orders(exchange_manager, exchange_data: exchange_data_import.ExchangeData, orders: list) -> list:
+async def create_orders(
+    exchange_manager,
+    exchange_data: exchange_data_import.ExchangeData,
+    orders: list,
+    order_creation_timeout: float
+) -> list:
     async def _create_order(order_dict) -> personal_data.Order:
         symbol = order_dict[enums.ExchangeConstantsOrderColumns.SYMBOL.value]
         side, order_type = personal_data.parse_order_type(order_dict)
@@ -186,8 +193,36 @@ async def create_orders(exchange_manager, exchange_data: exchange_data_import.Ex
             reduce_only=order_dict[enums.ExchangeConstantsOrderColumns.REDUCE_ONLY.value],
         )
         # is private, to use in tests context only
-        return personal_data.create_order_instance_from_raw(
+        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:
+            return order
+        if order.status is enums.OrderStatus.PENDING_CREATION and order_creation_timeout > 0:
+            try:
+                return await wait_for_other_status(order, order_creation_timeout)
+            except TimeoutError as err:
+                logging.get_logger(order.get_logger_name()).error(f"Created order can't be fetched: {err}")
+                return None
+        return order
 
     return await asyncio.gather(*(_create_order(order_dict) for order_dict in orders))
+
+
+async def wait_for_other_status(order: personal_data.Order, timeout) -> personal_data.Order:
+    t0 = time.time()
+    iterations = 0
+    origin_status = order.status.value
+    while time.time() - t0 < timeout:
+        raw_order = await order.exchange_manager.exchange.get_order(order.exchange_order_id, order.symbol)
+        iterations += 1
+        if raw_order is not None and raw_order[enums.ExchangeConstantsOrderColumns.STATUS.value] != origin_status:
+            logging.get_logger(order.get_logger_name()).info(
+                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
+            )
+        await asyncio.sleep(constants.CREATED_ORDER_FORCED_UPDATE_PERIOD)
+    raise TimeoutError(f"Order was not found with another status than {origin_status} within {timeout} seconds")

{OctoBot-Trading-2.4.74 → OctoBot-Trading-2.4.76}/tests/exchanges/util/test_exchange_util.py

@@ -245,25 +245,25 @@ async def test_get_exchange_details(tentacles_setup_config, supported_exchanges)
 
 
 def test_is_api_permission_error():
-    with mock.patch.object(exchange_util, "_is_error_on_this_type") as _is_error_on_this_type_mock:
+    with mock.patch.object(exchange_util, "is_error_on_this_type") as is_error_on_this_type_mock:
         err = Exception("plop")
         exchanges.is_api_permission_error(err)
-        _is_error_on_this_type_mock.assert_called_once_with(
+        is_error_on_this_type_mock.assert_called_once_with(
             err, constants.EXCHANGE_PERMISSION_ERRORS
         )
 
 
 def test_is_exchange_rules_compliancy_error():
-    with mock.patch.object(exchange_util, "_is_error_on_this_type") as _is_error_on_this_type_mock:
+    with mock.patch.object(exchange_util, "is_error_on_this_type") as is_error_on_this_type_mock:
         err = Exception("plop")
         exchanges.is_exchange_rules_compliancy_error(err)
-        _is_error_on_this_type_mock.assert_called_once_with(
+        is_error_on_this_type_mock.assert_called_once_with(
             err, constants.EXCHANGE_COMPLIANCY_ERRORS
         )
 
 
 def test_is_error_on_this_type():
-    assert exchange_util._is_error_on_this_type(Exception("plop"), constants.EXCHANGE_PERMISSION_ERRORS) is False
-    assert exchange_util._is_error_on_this_type(Exception("api key"), constants.EXCHANGE_PERMISSION_ERRORS) is True
-    assert exchange_util._is_error_on_this_type(Exception("api"), constants.EXCHANGE_PERMISSION_ERRORS) is False
-    assert exchange_util._is_error_on_this_type(Exception("api"), constants.EXCHANGE_COMPLIANCY_ERRORS) is False
+    assert exchange_util.is_error_on_this_type(Exception("plop"), constants.EXCHANGE_PERMISSION_ERRORS) is False
+    assert exchange_util.is_error_on_this_type(Exception("api key"), constants.EXCHANGE_PERMISSION_ERRORS) is True
+    assert exchange_util.is_error_on_this_type(Exception("api"), constants.EXCHANGE_PERMISSION_ERRORS) is False
+    assert exchange_util.is_error_on_this_type(Exception("api"), constants.EXCHANGE_COMPLIANCY_ERRORS) is False