OctoBot-Trading 2.4.153__tar.gz → 2.4.155__tar.gz

{OctoBot-Trading-2.4.153 → OctoBot-Trading-2.4.155}/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.155] - 2025-02-03
+### Added
+[Exchanges] handle Socks proxies
+### Updated
+[Trader] enable edit_order when without enable_order_auto_synchronization
+
+## [2.4.154] - 2025-01-31
+### Added
+[Exchanges] handle InvalidAPIKeyIPWhitelistError
+
 ## [2.4.153] - 2025-01-29
 ### Updated
 [TradingMode] make register_chained_order more flexible

{OctoBot-Trading-2.4.153 → OctoBot-Trading-2.4.155/OctoBot_Trading.egg-info}/PKG-INFO

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

@@ -3,8 +3,9 @@ OctoBot-Backtesting<1.10,>=1.9
 Async-Channel<2.3,>=2.2
 OctoBot-Commons<1.10,>=1.9.64
 OctoBot-Tentacles-Manager<2.10,>=2.9
-trading-backend>=1.2.7
+trading-backend>=1.2.35
 ccxt==4.3.85
+aiohttp_socks==0.10.1
 cryptography
 sortedcontainers==2.4.0
 tinydb==4.5.2

{OctoBot-Trading-2.4.153/OctoBot_Trading.egg-info → OctoBot-Trading-2.4.155}/PKG-INFO

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

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

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

{OctoBot-Trading-2.4.153 → OctoBot-Trading-2.4.155}/octobot_trading/errors.py

@@ -147,6 +147,12 @@ class AuthenticationError(OctoBotExchangeError):
     """
 
 
+class InvalidAPIKeyIPWhitelistError(AuthenticationError):
+    """
+    Raised when an exchange failed to authenticate due to an IP whitelist issue
+    """
+
+
 class ExchangeInternalSyncError(OctoBotExchangeError):
     """
     Raised when an exchange is returning an error due to its internal sync process

{OctoBot-Trading-2.4.153 → OctoBot-Trading-2.4.155}/octobot_trading/exchanges/config/proxy_config.py

@@ -33,9 +33,13 @@ class ProxyConfig:
     # if set, will be called when exchange stops
     stop_proxy_callback: typing.Optional[typing.Callable] = None
     # if set, returns the last url given to a callback method that return "True", meaning the last url that used a proxy
-    get_last_proxied_request_url: typing.Optional[typing.Callable] = None
+    get_last_proxied_request_url: typing.Optional[typing.Callable[[], typing.Optional[str]]] = None
+    get_proxy_url: typing.Optional[typing.Callable[[], str]] = None
     # the host of this proxy, used to identify proxy connexion errors
     proxy_host: str = "DEFAULT PROXY HOST"
+    # if DNS cache should be disabled with this proxy config. Warning: in this case, DNS cache will be
+    # completely disabled for this exchange
+    disable_dns_cache: bool = False
 
     @classmethod
     def default_env_var_config(cls):

{OctoBot-Trading-2.4.153 → OctoBot-Trading-2.4.155}/octobot_trading/exchanges/connectors/ccxt/ccxt_client_util.py

@@ -14,7 +14,9 @@
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
 import asyncio
+import aiohttp_socks
 import os
+import ssl
 import aiohttp
 import copy
 import logging
@@ -143,7 +145,10 @@ def instantiate_exchange(
     client = exchange_class(config)
     _use_proxy_if_necessary(client, proxy_config)
     if constants.ENABLE_CCXT_REQUESTS_COUNTER and allow_request_counter:
-        _use_request_counter(identifier, client)
+        if proxy_config.socks_proxy or proxy_config.socks_proxy_callback:
+            commons_logging.get_logger(__name__).error("socks proxy and request counter can't yet be used together.")
+        else:
+            _use_request_counter(identifier, client, proxy_config)
     return client
 
 
@@ -304,6 +309,51 @@ def _use_proxy_if_necessary(client, proxy_config: proxy_config_import.ProxyConfi
         client.socks_proxy = proxy_config.socks_proxy
     if proxy_config.socks_proxy_callback:
         client.socks_proxy_callback = proxy_config.socks_proxy_callback
+    if proxy_config.socks_proxy or proxy_config.socks_proxy_callback:
+        # rewrite of async_ccxt.exchange.client.fetch() ProxyConnector creation
+        _init_ccxt_client_session_requirements(client)
+        proxy_url = proxy_config.get_proxy_url()
+        if (client.socks_proxy_sessions is None):
+            client.socks_proxy_sessions = {}
+        if (proxy_url not in client.socks_proxy_sessions):
+            connector = aiohttp_socks.ProxyConnector.from_url(
+                proxy_url,
+                # extra args copied from self.open()
+                ssl=client.ssl_context,
+                loop=client.asyncio_loop,
+                use_dns_cache=not proxy_config.disable_dns_cache,
+                enable_cleanup_closed=True
+            )
+            client.socks_proxy_sessions[proxy_url] = aiohttp.ClientSession(
+                loop=client.asyncio_loop, connector=connector, trust_env=client.aiohttp_trust_env
+            )
+    elif proxy_config.disable_dns_cache:
+        # rewrite of async_ccxt.exchange.client.open()
+        _init_ccxt_client_session_requirements(client)
+        if client.session:
+            # should not happen
+            asyncio.create_task(client.session.close())
+        connector = aiohttp.TCPConnector(
+            ssl=client.ssl_context, loop=client.asyncio_loop, enable_cleanup_closed=True,
+            # local overrides
+            use_dns_cache=False
+            # end local overrides
+        )
+        client.session = aiohttp.ClientSession(
+            loop=client.asyncio_loop, connector=connector, trust_env=client.aiohttp_trust_env
+        )
+
+
+def _init_ccxt_client_session_requirements(client):
+    # from async_ccxt.exchange.client.open()
+    if client.asyncio_loop is None:
+        client.asyncio_loop = asyncio.get_running_loop()
+        client.throttle.loop = client.asyncio_loop
+
+    if client.ssl_context is None:
+        # Create our SSL context object with our CA cert file
+        client.ssl_context = ssl.create_default_context(cafile=client.cafile) if client.verify else client.verify
+
 
 
 def _get_client_config(
@@ -372,7 +422,9 @@ def _get_patched_url_config(url_config: dict, old: str, new: str):
     return updated_config
 
 
-def _use_request_counter(identifier: str, ccxt_client: async_ccxt.Exchange):
+def _use_request_counter(
+    identifier: str, ccxt_client: async_ccxt.Exchange, proxy_config: proxy_config_import.ProxyConfig
+):
     """
     Replaces the given exchange async session by an aiohttp_util.CounterClientSession
     WARNING: should only be called right after creating the exchange and on the same async loop as
@@ -387,7 +439,8 @@ def _use_request_counter(identifier: str, ccxt_client: async_ccxt.Exchange):
         # same as in ccxt.async_support.exchange.py#open()
         # connector = aiohttp.TCPConnector(ssl=self.ssl_context, loop=self.asyncio_loop, enable_cleanup_closed=True)
         new_connector = aiohttp.TCPConnector(
-            ssl=ccxt_client.ssl_context, loop=ccxt_client.asyncio_loop, enable_cleanup_closed=True
+            ssl=ccxt_client.ssl_context, loop=ccxt_client.asyncio_loop,
+            enable_cleanup_closed=True, use_dns_cache=not proxy_config.disable_dns_cache
         )
         counter_session = aiohttp_util.CounterClientSession(
             identifier,
@@ -440,7 +493,9 @@ def get_proxy_error_if_any(ccxt_connector, error: Exception) -> typing.Optional[
     depth = 1
     cause_error = error
     while cause_error and depth < max_depth:
-        if isinstance(cause_error, (aiohttp.ClientProxyConnectionError, aiohttp.ClientHttpProxyError)) or (
+        if isinstance(cause_error, (
+            aiohttp.ClientProxyConnectionError, aiohttp.ClientHttpProxyError, aiohttp_socks.ProxyConnectionError
+        )) or (
             isinstance(cause_error, aiohttp.ClientConnectorError)
             and ccxt_connector.exchange_manager.proxy_config.proxy_host in str(cause_error)
         ):

{OctoBot-Trading-2.4.153 → OctoBot-Trading-2.4.155}/octobot_trading/exchanges/connectors/ccxt/ccxt_connector.py

@@ -18,6 +18,7 @@ import contextlib
 import decimal
 import ccxt.async_support as ccxt
 import ccxt.static_dependencies.ecdsa.der
+import aiohttp_socks
 import typing
 import inspect
 import binascii
@@ -79,7 +80,7 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
         self, config, exchange_manager, adapter_class=None, additional_config=None, rest_name=None, force_auth=False
     ):
         super().__init__(config, exchange_manager, None)
-        self.client = None
+        self.client: ccxt.Exchange = None
         self.exchange_type = None
         self.adapter = self.get_adapter_class(adapter_class)(self)
         self.all_currencies_price_ticker = None
@@ -1033,11 +1034,16 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
                 f"Request timeout: {html_util.get_html_summary_if_relevant(err)}"
             ) from err
         except ccxt.AuthenticationError as err:
+            error_class = (
+                octobot_trading.errors.InvalidAPIKeyIPWhitelistError
+                if self.exchange_manager.exchange.is_ip_whitelist_error(err)
+                else octobot_trading.errors.AuthenticationError
+            )
             self.raise_or_prefix_proxy_error_if_relevant(
                 err,
-                octobot_trading.errors.AuthenticationError(html_util.get_html_summary_if_relevant(err))
+                error_class(html_util.get_html_summary_if_relevant(err))
             )
-        except ccxt.ExchangeNotAvailable as err:
+        except (ccxt.ExchangeNotAvailable, aiohttp_socks.ProxyConnectionError) as err:
             self.raise_or_prefix_proxy_error_if_relevant(
                 err,
                 octobot_trading.errors.FailedRequest(
@@ -1045,8 +1051,12 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
                 )
             )
         except ccxt.ExchangeError as err:
+            error_message = html_util.get_html_summary_if_relevant(err)
+            if self.exchange_manager.exchange.is_ip_whitelist_error(err):
+                # ensure this is not an IP whitelist error
+                raise octobot_trading.errors.InvalidAPIKeyIPWhitelistError(error_message) from err
             if self.exchange_manager.exchange.is_authentication_error(err):
                 # ensure this is not an unhandled authentication error
-                raise octobot_trading.errors.AuthenticationError(html_util.get_html_summary_if_relevant(err)) from err
+                raise octobot_trading.errors.AuthenticationError(error_message) from err
             # otherwise just forward exception
             raise

{OctoBot-Trading-2.4.153 → OctoBot-Trading-2.4.155}/octobot_trading/exchanges/exchange_builder.py

@@ -257,6 +257,10 @@ class ExchangeBuilder:
         self.exchange_manager.without_auth = True
         return self
 
+    def disable_unauth_retry(self, disabled):
+        self.exchange_manager.disable_unauth_retry = disabled
+        return self
+
     def is_checking_credentials(self, check_credentials):
         self.exchange_manager.check_credentials = check_credentials
         return self

{OctoBot-Trading-2.4.153 → OctoBot-Trading-2.4.155}/octobot_trading/exchanges/exchange_factory.py

@@ -62,10 +62,13 @@ async def create_real_exchange(exchange_manager, exchange_config_by_exchange: ty
             return
         await _initialize_exchange_backend(exchange_manager)
     except errors.AuthenticationError as err:
-        if exchange_manager.without_auth or exchange_manager.exchange.REQUIRES_AUTHENTICATION:
+        if (
+            exchange_manager.without_auth or exchange_manager.exchange.REQUIRES_AUTHENTICATION
+            or exchange_manager.disable_unauth_retry
+        ):
             # auth is required or already retried, don't loop
             exchange_manager.logger.error(
-                f"Authentication is required and created an error: impossible to connect to "
+                f"Authentication is required and raised an error: impossible to connect to "
                 f"{exchange_manager.exchange_name} exchange: {err}"
             )
             raise

{OctoBot-Trading-2.4.153 → OctoBot-Trading-2.4.155}/octobot_trading/exchanges/exchange_manager.py

@@ -57,6 +57,7 @@ class ExchangeManager(util.Initializable):
         self.is_sandboxed: bool = False
         self.is_trading: bool = True
         self.without_auth: bool = False
+        self.disable_unauth_retry: bool = False
         self.check_credentials: bool = True
         self.enable_storage: bool = True
         self.proxy_config: exchanges.ProxyConfig = exchanges.ProxyConfig.default_env_var_config()

{OctoBot-Trading-2.4.153 → OctoBot-Trading-2.4.155}/octobot_trading/exchanges/traders/trader.py

@@ -183,38 +183,23 @@ class Trader(util.Initializable):
         previous_exchange_order_id = order.exchange_order_id
         try:
             async with order.lock:
+                disabled_state_updater = self.exchange_manager.exchange_personal_data \
+                    .orders_manager.enable_order_auto_synchronization is False
                 # now that we got the lock, ensure we can edit the order
-                if not self.simulate and not order.is_self_managed() and order.state is not None:
-                    # careful here: make sure we are not editing an order on exchange that is being updated
-                    # somewhere else
-                    async with order.state.refresh_operation():
-                        self.logger.info(f"Editing order: {order} ["
-                                         f"edited_quantity: {str(edited_quantity)} "
-                                         f"edited_price: {str(edited_price)} "
-                                         f"edited_stop_price: {str(edited_stop_price)} "
-                                         f"edited_current_price: {str(edited_current_price)}"
-                                         f"]")
-                        order_params = self.exchange_manager.exchange.get_order_additional_params(order)
-                        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.exchange_order_id,
-                            order.order_type,
-                            order.symbol,
-                            quantity=order.origin_quantity if edited_quantity is None else edited_quantity,
-                            price=order.origin_price if edited_price is None else edited_price,
-                            stop_price=edited_stop_price,
-                            side=order.side,
-                            current_price=edited_current_price,
-                            params=order_params
+                if not self.simulate and not order.is_self_managed() and (
+                    order.state is not None or disabled_state_updater
+                ):
+                    if disabled_state_updater:
+                        changed = await self._edit_order_on_exchange(
+                            order, edited_quantity, edited_price, edited_stop_price, edited_current_price, params
                         )
-                        # apply new values from returned order (even order id might have changed)
-                        self.logger.debug(f"Successfully edited order on {self.exchange_manager.exchange_name}, "
-                                          f"new order values: {edited_order}")
-                        changed = order.update_from_raw(edited_order)
-                        # update portfolio from exchange
-                        await self.exchange_manager.exchange_personal_data.\
-                            handle_portfolio_and_position_update_from_order(order)
+                    else:
+                        # careful here: make sure we are not editing an order on exchange that is being updated
+                        # somewhere else
+                        async with order.state.refresh_operation():
+                            changed = await self._edit_order_on_exchange(
+                                order, edited_quantity, edited_price, edited_stop_price, edited_current_price, params
+                            )
                 else:
                     # consider order as cancelled to release portfolio amounts
                     self.exchange_manager.exchange_personal_data.portfolio_manager.portfolio.update_portfolio_available(
@@ -242,6 +227,41 @@ class Trader(util.Initializable):
                 # order id changed: update orders_manager to keep consistency
                 self.exchange_manager.exchange_personal_data.orders_manager.replace_order(order.order_id, order)
 
+    async def _edit_order_on_exchange(
+        self, order,
+        edited_quantity: decimal.Decimal,
+        edited_price: decimal.Decimal,
+        edited_stop_price: decimal.Decimal,
+        edited_current_price: decimal.Decimal,
+        params: dict
+    ) -> bool:
+        self.logger.info(
+            f"Editing order: {order} [edited_quantity: {str(edited_quantity)} edited_price: {str(edited_price)} "
+            f"edited_stop_price: {str(edited_stop_price)} edited_current_price: {str(edited_current_price)}]"
+        )
+        order_params = self.exchange_manager.exchange.get_order_additional_params(order)
+        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.exchange_order_id,
+            order.order_type,
+            order.symbol,
+            quantity=order.origin_quantity if edited_quantity is None else edited_quantity,
+            price=order.origin_price if edited_price is None else edited_price,
+            stop_price=edited_stop_price,
+            side=order.side,
+            current_price=edited_current_price,
+            params=order_params
+        )
+        # apply new values from returned order (even order id might have changed)
+        self.logger.debug(
+            f"Successfully edited order on {self.exchange_manager.exchange_name}, new order values: {edited_order}"
+        )
+        changed = order.update_from_raw(edited_order)
+        # update portfolio from exchange
+        await self.exchange_manager.exchange_personal_data.handle_portfolio_and_position_update_from_order(order)
+        return changed
+
     async def _create_new_order(self, new_order, params: dict,
                                 wait_for_creation=True,
                                 creation_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT) -> object:

{OctoBot-Trading-2.4.153 → OctoBot-Trading-2.4.155}/octobot_trading/exchanges/types/rest_exchange.py

@@ -124,6 +124,8 @@ class RestExchange(abstract_exchange.AbstractExchange):
     EXCHANGE_ACCOUNT_TRADED_SYMBOL_PERMISSION_ERRORS: typing.List[typing.Iterable[str]] = []
     # text content of errors due to unhandled authentication issues
     EXCHANGE_AUTHENTICATION_ERRORS: typing.List[typing.Iterable[str]] = []
+    # text content of errors due to unhandled IP white list issues
+    EXCHANGE_IP_WHITELIST_ERRORS: typing.List[typing.Iterable[str]] = []
     # text content of errors due to a closed position on the exchange. Relevant for reduce-only orders
     EXCHANGE_CLOSED_POSITION_ERRORS: typing.List[typing.Iterable[str]] = []
     # text content of errors due to an order that would immediately trigger if created. Relevant for stop losses
@@ -1063,6 +1065,11 @@ class RestExchange(abstract_exchange.AbstractExchange):
             return exchanges_util.is_error_on_this_type(error, self.EXCHANGE_AUTHENTICATION_ERRORS)
         return False
 
+    def is_ip_whitelist_error(self, error: BaseException) -> bool:
+        if self.EXCHANGE_IP_WHITELIST_ERRORS:
+            return exchanges_util.is_error_on_this_type(error, self.EXCHANGE_IP_WHITELIST_ERRORS)
+        return False
+
     """
     Auto fetched and filled exchanges
     """

{OctoBot-Trading-2.4.153 → OctoBot-Trading-2.4.155}/octobot_trading/exchanges/util/exchange_util.py

@@ -221,6 +221,7 @@ async def get_local_exchange_manager(
     exchange_name: str, exchange_config: dict, tentacles_setup_config,
     is_sandboxed: bool, ignore_config=False, builder=None, use_cached_markets=True,
     is_broker_enabled: bool = False, exchange_config_by_exchange: typing.Optional[dict[str, dict]] = None,
+    disable_unauth_retry: bool = False,
     market_filter: typing.Union[None, typing.Callable[[dict], bool]] = None
 ):
     exchange_type = exchange_config.get(common_constants.CONFIG_EXCHANGE_TYPE, get_default_exchange_type(exchange_name))
@@ -230,6 +231,7 @@ async def get_local_exchange_manager(
     )
     exchange_manager = await builder.use_tentacles_setup_config(tentacles_setup_config) \
         .is_checking_credentials(False) \
+        .disable_unauth_retry(disable_unauth_retry) \
         .is_sandboxed(is_sandboxed) \
         .is_using_exchange_type(exchange_type) \
         .use_exchange_config_by_exchange(exchange_config_by_exchange) \
@@ -289,6 +291,12 @@ async def is_compatible_account(exchange_name: str, exchange_config: dict, tenta
                 return True, True, None
         except trading_backend.TimeSyncError:
             return False, False, _get_time_sync_error_message(exchange_name, "backend.is_valid_account")
+        except trading_backend.APIKeyPermissionsError as err:
+            return False, False, f"Please update your API Key permissions: {err}"
+        except trading_backend.APIKeyIPWhitelistError as err:
+            return False, False, f"Please update your API Key IP whitelist: {err}"
+        except trading_backend.UnexpectedError as err:
+            return False, False, f"Impossible to check API key: {err}"
         except trading_backend.ExchangeAuthError:
             message = f"Invalid {exchange_name.capitalize()} authentication details"
             if is_sandboxed:
@@ -297,8 +305,6 @@ async def is_compatible_account(exchange_name: str, exchange_config: dict, tenta
                           f"{exchange_name.capitalize()} to trade and validate your api key. " \
                           f"Disable sandbox in your accounts configuration if this is not intended."
             return False, False, message
-        except trading_backend.APIKeyPermissionsError as err:
-            return False, False, f"Please update your API Key permissions: {err}"
         except (AttributeError, Exception) as e:
             return True, False, f"Error when loading exchange account: {e}"
 

{OctoBot-Trading-2.4.153 → OctoBot-Trading-2.4.155}/octobot_trading/personal_data/orders/groups/balanced_take_profit_and_stop_order_group.py

@@ -116,7 +116,7 @@ class BalancedTakeProfitAndStopOrderGroup(order_group.OrderGroup):
                     self.logger.error(f"Skipping order cancel: {err}")
                 updated_orders = True
             for update_data in take_profit_actions[self.UPDATE] + stop_actions[self.UPDATE]:
-                self.logger.info(f"Updating order side to {update_data[self.UPDATED_QUANTITY]} to keep balance, "
+                self.logger.info(f"Updating order quantity to {update_data[self.UPDATED_QUANTITY]} to keep balance, "
                                  f"order: {update_data[self.ORDER]}")
                 order = update_data[self.ORDER]
                 async with signals.remote_signal_publisher(order.trader.exchange_manager, order.symbol, True):
@@ -131,9 +131,11 @@ class BalancedTakeProfitAndStopOrderGroup(order_group.OrderGroup):
             self.logger.exception(e, True, f"Error when balancing orders: {e}")
         finally:
             # remove locally_balancing_orders from self.balancing_orders
-            self.balancing_orders = [order
-                                     for order in self.balancing_orders
-                                     if order not in locally_balancing_orders]
+            self.balancing_orders = [
+                order
+                for order in self.balancing_orders
+                if order not in locally_balancing_orders
+            ]
 
     def _get_balance(self, closed_order, ignored_orders):
         balance = {
@@ -141,9 +143,11 @@ class BalancedTakeProfitAndStopOrderGroup(order_group.OrderGroup):
             self.STOP: _SideBalance()
         }
         for order in self.get_group_open_orders():
-            if order is not closed_order \
-                    and (ignored_orders is None or order not in ignored_orders) \
-                    and order not in self.balancing_orders:
+            if (
+                order is not closed_order
+                and (ignored_orders is None or order not in ignored_orders)
+                and order not in self.balancing_orders
+            ):
                 if order_util.is_stop_order(order.order_type):
                     balance[self.STOP].add_order(order)
                 else:

{OctoBot-Trading-2.4.153 → OctoBot-Trading-2.4.155}/octobot_trading/personal_data/orders/order.py

@@ -227,7 +227,7 @@ class Order(util.Initializable):
                 should_update_total_cost = True
 
         if self.trader.simulate:
-            if quantity and not self.filled_quantity:
+            if quantity and self.filled_quantity != quantity:
                 self.filled_quantity = quantity
                 changed = True
                 should_update_total_cost = True

{OctoBot-Trading-2.4.153 → OctoBot-Trading-2.4.155}/octobot_trading/personal_data/orders/order_util.py

@@ -433,7 +433,7 @@ def is_stop_trade_order_type(order_type: enums.TradeOrderType):
     ]
 
 
-def is_take_profit_order(order_type):
+def is_take_profit_order(order_type: enums.TraderOrderType):
     return order_type in [
         enums.TraderOrderType.TAKE_PROFIT, enums.TraderOrderType.TAKE_PROFIT_LIMIT,
     ]

{OctoBot-Trading-2.4.153 → OctoBot-Trading-2.4.155}/requirements.txt

@@ -5,10 +5,11 @@ OctoBot-Backtesting>=1.9, <1.10
 Async-Channel>=2.2, <2.3
 OctoBot-Commons>=1.9.64, <1.10
 OctoBot-Tentacles-Manager>=2.9, <2.10
-trading-backend>=1.2.7
+trading-backend>=1.2.35
 
 # Exchange connection requirements
 ccxt==4.3.85 # always ensure real exchanges tests (in tests_additional and authenticated exchange tests) are passing before changing the ccxt version
+aiohttp_socks==0.10.1   # used by ccxt socks proxy aiohttp connectors
 
 cryptography # Never specify a version (managed by https://github.com/Drakkar-Software/OctoBot-PyPi-Linux-Deployer)
 

{OctoBot-Trading-2.4.153 → OctoBot-Trading-2.4.155}/tests/exchanges/connectors/ccxt/test_ccxt_connector.py

@@ -18,6 +18,7 @@ import decimal
 import ccxt
 import aiohttp
 import aiohttp.client_reqrep
+import aiohttp_socks
 
 import mock
 from mock import patch
@@ -265,7 +266,13 @@ async def test_error_describer(ccxt_connector):
     with pytest.raises(octobot_trading.errors.ExchangeProxyError):
         # proxy connection error
         with ccxt_connector.error_describer():
-            raise ccxt.AuthenticationError from aiohttp.ClientProxyConnectionError(
+            raise ccxt.AuthenticationError from aiohttp_socks.ProxyConnectionError(
+                aiohttp.client_reqrep.ConnectionKey("host", 11, True, True, None, None, None), OSError("plop")
+            )
+    with pytest.raises(octobot_trading.errors.ExchangeProxyError):
+        # proxy connection error
+        with ccxt_connector.error_describer():
+            raise aiohttp_socks.ProxyConnectionError(
                 aiohttp.client_reqrep.ConnectionKey("host", 11, True, True, None, None, None), OSError("plop")
             )
     with mock.patch.object(