OctoBot-Trading 2.4.73__tar.gz → 2.4.75__tar.gz

{OctoBot-Trading-2.4.73 → OctoBot-Trading-2.4.75}/CHANGELOG.md

@@ -4,6 +4,16 @@ 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.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
+
 ## [2.4.73] - 2024-04-04
 ### Added
 - [Exchanges] BinanceUS to full history exchanges

{OctoBot-Trading-2.4.73 → OctoBot-Trading-2.4.75/OctoBot_Trading.egg-info}/PKG-INFO

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

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

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

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

{OctoBot-Trading-2.4.73 → OctoBot-Trading-2.4.75}/octobot_trading/api/__init__.py

@@ -121,6 +121,7 @@ from octobot_trading.api.exchange import (
     get_auto_filled_exchange_names,
     get_exchange_details,
     is_api_permission_error,
+    is_exchange_rules_compliancy_error,
     cancel_ccxt_throttle_task,
     stop_exchange,
 )
@@ -301,6 +302,7 @@ __all__ = [
     "get_auto_filled_exchange_names",
     "get_exchange_details",
     "is_api_permission_error",
+    "is_exchange_rules_compliancy_error",
     "cancel_ccxt_throttle_task",
     "stop_exchange",
     "get_trading_modes",

{OctoBot-Trading-2.4.73 → OctoBot-Trading-2.4.75}/octobot_trading/api/exchange.py

@@ -326,6 +326,10 @@ def is_api_permission_error(error: BaseException) -> bool:
     return exchanges.is_api_permission_error(error)
 
 
+def is_exchange_rules_compliancy_error(error: BaseException) -> bool:
+    return exchanges.is_exchange_rules_compliancy_error(error)
+
+
 def cancel_ccxt_throttle_task():
     for task in asyncio.all_tasks():
         # manually cancel ccxt async throttle task since it apparently can't be cancelled otherwise

{OctoBot-Trading-2.4.73 → OctoBot-Trading-2.4.75}/octobot_trading/constants.py

@@ -42,6 +42,7 @@ 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
+CREATED_ORDER_FORCED_UPDATE_PERIOD = 5
 
 # Tentacles
 TRADING_MODE_REQUIRED_STRATEGIES = "required_strategies"
@@ -104,6 +105,7 @@ TESTED_EXCHANGES = [
     "kucoin",
     "okx",
 ] + sorted([
+    "binanceus",
     "coinbase",
     "cryptocom",
     "htx",
@@ -115,7 +117,6 @@ TESTED_EXCHANGES = [
     "hollaex",
     "mexc",
     "bingx",
-    "bitget",
     "coinex",
 ])
 DEFAULT_FUTURE_EXCHANGES = sorted(["bybit"])
@@ -133,6 +134,12 @@ EXCHANGE_PERMISSION_ERRORS: typing.List[typing.Iterable[str]] = [
     ("permission_denied", )
 ]
 
+# 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"),
+]
+
 CONFIG_DEFAULT_FEES = 0.001
 CONFIG_DEFAULT_SIMULATOR_FEES = 0
 

{OctoBot-Trading-2.4.73 → OctoBot-Trading-2.4.75}/octobot_trading/errors.py

@@ -99,6 +99,12 @@ class AuthenticationError(Exception):
     """
 
 
+class ExchangeCompliancyError(Exception):
+    """
+    Raised when an exchange failed to execute the given request because of compliance rules for the current user account
+    """
+
+
 class PortfolioNegativeValueError(Exception):
     """
     Raised when the portfolio is being updated with a negative value

{OctoBot-Trading-2.4.73 → OctoBot-Trading-2.4.75}/octobot_trading/exchanges/__init__.py

@@ -77,6 +77,8 @@ from octobot_trading.exchanges.util import (
     get_auto_filled_exchange_names,
     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,
@@ -162,6 +164,8 @@ __all__ = [
     "get_auto_filled_exchange_names",
     "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.73 → OctoBot-Trading-2.4.75}/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)
 
@@ -698,3 +701,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.73 → OctoBot-Trading-2.4.75}/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.73 → OctoBot-Trading-2.4.75}/octobot_trading/exchanges/traders/trader.py

@@ -1,3 +1,4 @@
+# pylint: disable=W0706
 #  Drakkar-Software OctoBot-Trading
 #  Copyright (c) Drakkar-Software, All rights reserved.
 #
@@ -117,7 +118,7 @@ class Trader(util.Initializable):
                 self.logger.warning(f"Order not created on {self.exchange_manager.exchange_name} "
                                     f"(failed attempt to create: {order}). This is likely due to "
                                     f"the order being refused by the exchange.")
-        except errors.MissingFunds:
+        except (errors.MissingFunds, errors.AuthenticationError, errors.ExchangeCompliancyError):
             # forward errors that require actions to fix the situation
             raise
         except Exception as e:
@@ -278,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.73 → OctoBot-Trading-2.4.75}/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,
@@ -211,6 +215,11 @@ class RestExchange(abstract_exchange.AbstractExchange):
                 raise errors.AuthenticationError(
                     f"Error when handling order {e}. Please make sure that trading permissions are on for this API key."
                 )
+            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."
+                )
             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}")
@@ -861,6 +870,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.73 → OctoBot-Trading-2.4.75}/octobot_trading/exchanges/util/__init__.py

@@ -45,6 +45,8 @@ from octobot_trading.exchanges.util.exchange_util import (
     get_auto_filled_exchange_names,
     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 (
@@ -78,6 +80,8 @@ __all__ = [
     "get_auto_filled_exchange_names",
     "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.73 → OctoBot-Trading-2.4.75}/octobot_trading/exchanges/util/exchange_util.py

@@ -429,8 +429,16 @@ 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)
+
+
+def is_exchange_rules_compliancy_error(error: BaseException) -> bool:
+    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:
     lower_error = str(error).lower()
-    for identifiers in constants.EXCHANGE_PERMISSION_ERRORS:
+    for identifiers in descriptions:
         if all(identifier in lower_error for identifier in identifiers):
             return True
     return False

{OctoBot-Trading-2.4.73 → OctoBot-Trading-2.4.75}/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.73 → OctoBot-Trading-2.4.75}/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.73 → OctoBot-Trading-2.4.75}/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.73 → OctoBot-Trading-2.4.75}/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.73 → OctoBot-Trading-2.4.75}/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.73 → OctoBot-Trading-2.4.75}/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.73 → OctoBot-Trading-2.4.75}/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.73 → OctoBot-Trading-2.4.75}/tests/exchanges/traders/test_trader.py

@@ -18,6 +18,7 @@ import os
 import ccxt.async_support
 import decimal
 
+import mock
 import pytest
 import time
 from mock import AsyncMock, patch, Mock
@@ -28,6 +29,7 @@ import octobot_commons.constants as commons_constants
 from octobot_commons.asyncio_tools import wait_asyncio_next_cycle
 from octobot_commons.tests.test_config import load_test_config
 from octobot_trading.personal_data.orders import Order
+import octobot_trading.errors as errors
 from octobot_trading.enums import TraderOrderType, TradeOrderSide, TradeOrderType, OrderStatus, \
     ExchangeConstantsPositionColumns, PositionMode, MarginType, TakeProfitStopLossMode, ExchangeSupportedElements
 from octobot_trading.exchanges.exchange_manager import ExchangeManager
@@ -1080,6 +1082,37 @@ async def test__has_open_position(future_trader_simulator_with_default_linear):
     assert trader_inst._has_open_position(DEFAULT_FUTURE_SYMBOL)
 
 
+async def test_create_order(future_trader_simulator_with_default_linear):
+    _, exchange_manager_inst, trader_inst, default_contract = future_trader_simulator_with_default_linear
+    order_mock = mock.Mock()
+    with mock.patch.object(trader_inst, "_create_new_order", mock.AsyncMock()) as _create_new_order_mock:
+        assert await trader_inst.create_order(order_mock)
+        _create_new_order_mock.assert_called_once_with(
+            order_mock, {}, wait_for_creation=True, creation_timeout=constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT
+        )
+    for err in (errors.MissingFunds, errors.AuthenticationError, errors.ExchangeCompliancyError):
+        with mock.patch.object(
+                trader_inst, "_create_new_order", mock.AsyncMock(side_effect=err)
+        ) as _create_new_order_mock:
+            with pytest.raises(err):
+                assert await trader_inst.create_order(
+                    order_mock, params="params", wait_for_creation=False, creation_timeout=1
+                )
+            _create_new_order_mock.assert_called_once_with(
+                order_mock, "params", wait_for_creation=False, creation_timeout=1
+            )
+        with mock.patch.object(
+            trader_inst, "_create_new_order", mock.AsyncMock(side_effect=ZeroDivisionError)
+        ) as _create_new_order_mock:
+            # does not raise
+            assert await trader_inst.create_order(
+                order_mock, params="params", wait_for_creation=False, creation_timeout=1
+            ) is None
+            _create_new_order_mock.assert_called_once_with(
+                order_mock, "params", wait_for_creation=False, creation_timeout=1
+            )
+
+
 def make_coroutine(response):
     async def coroutine(*args, **kwargs):
         return response

{OctoBot-Trading-2.4.73 → OctoBot-Trading-2.4.75}/tests/exchanges/util/test_exchange_util.py

@@ -19,7 +19,9 @@ import mock
 import trading_backend.exchanges
 import octobot_commons.constants as commons_constants
 import octobot_commons.configuration as commons_configuration
+import octobot_trading.constants as constants
 import octobot_trading.exchanges as exchanges
+import octobot_trading.exchanges.util.exchange_util as exchange_util
 
 from tests import event_loop
 from tests.exchanges import MockedRestExchange, MockedAutoFillRestExchange
@@ -240,3 +242,28 @@ async def test_get_exchange_details(tentacles_setup_config, supported_exchanges)
             )
             assert details == supported_exchanges["blip"]
             get_tentacle_config_mock.assert_called_once()
+
+
+def test_is_api_permission_error():
+    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(
+            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:
+        err = Exception("plop")
+        exchanges.is_exchange_rules_compliancy_error(err)
+        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