OctoBot-Trading 2.4.154__tar.gz → 2.4.156__tar.gz

{OctoBot-Trading-2.4.154 → OctoBot-Trading-2.4.156}/CHANGELOG.md

@@ -4,6 +4,20 @@ 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.156] - 2025-02-10
+### Added
+[TradingModes] add init topic methods
+### Updated
+[Amount] improve amount error
+[Exchange] add proxy error details on ddos error
+[Trades] log more details on loaded historical trades
+
+## [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

{OctoBot-Trading-2.4.154 → OctoBot-Trading-2.4.156/OctoBot_Trading.egg-info}/PKG-INFO

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

@@ -5,6 +5,7 @@ OctoBot-Commons<1.10,>=1.9.64
 OctoBot-Tentacles-Manager<2.10,>=2.9
 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.154/OctoBot_Trading.egg-info → OctoBot-Trading-2.4.156}/PKG-INFO

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

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

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

{OctoBot-Trading-2.4.154 → OctoBot-Trading-2.4.156}/octobot_trading/exchanges/config/proxy_config.py

@@ -33,7 +33,8 @@ 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

{OctoBot-Trading-2.4.154 → OctoBot-Trading-2.4.156}/octobot_trading/exchanges/connectors/ccxt/ccxt_client_util.py

@@ -14,6 +14,7 @@
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
 import asyncio
+import aiohttp_socks
 import os
 import ssl
 import aiohttp
@@ -144,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, proxy_config)
+        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
 
 
@@ -305,15 +309,27 @@ 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.disable_dns_cache:
+    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()
-        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
+        _init_ccxt_client_session_requirements(client)
         if client.session:
             # should not happen
             asyncio.create_task(client.session.close())
@@ -328,6 +344,18 @@ def _use_proxy_if_necessary(client, proxy_config: proxy_config_import.ProxyConfi
         )
 
 
+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(
     exchange_class, options, headers, additional_config,
     api_key=None, secret=None, password=None, uid=None,
@@ -465,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.154 → OctoBot-Trading-2.4.156}/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
@@ -1022,7 +1023,7 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
             # raised upon rate limit issues, last response data might have details on what is happening
             if self.exchange_manager.exchange.should_log_on_ddos_exception(err):
                 self.log_ddos_error(err)
-            raise
+            self.raise_or_prefix_proxy_error_if_relevant(err, None)
         except ccxt.InvalidNonce as err:
             # use 2 index to get the caller of the context manager
             caller_function_name = inspect.stack()[2].function
@@ -1042,7 +1043,7 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
                 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(

{OctoBot-Trading-2.4.154 → OctoBot-Trading-2.4.156}/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.154 → OctoBot-Trading-2.4.156}/octobot_trading/modes/channel/abstract_mode_producer.py

@@ -16,6 +16,7 @@
 import contextlib
 import asyncio
 import concurrent.futures
+import typing
 
 import async_channel.enums as channel_enums
 
@@ -178,7 +179,19 @@ class AbstractTradingModeProducer(modes_channel.ModeChannelProducer):
                                                                          self.exchange_manager.id).matrix_id
             await self._subscribe_to_registration_topic(registration_topics, currency_filter, symbol_filter)
         await self.init_user_inputs(False)
-        await self._wait_for_bot_init(self.CONFIG_INIT_TIMEOUT)
+        await self._wait_for_bot_init(
+            self.CONFIG_INIT_TIMEOUT,
+            extra_symbol_topics=self.get_extra_init_symbol_topics(),
+            extra_global_topics=self.get_extra_global_topics()
+        )
+
+    def get_extra_init_symbol_topics(self) -> typing.Optional[list]:
+        # Implement if necessary
+        return None
+
+    def get_extra_global_topics(self) -> typing.Optional[list]:
+        # Implement if necessary
+        return None
 
     async def _subscribe_to_registration_topic(self, registration_topics, currency_filter, symbol_filter):
         for registration_topic in registration_topics:

{OctoBot-Trading-2.4.154 → OctoBot-Trading-2.4.156}/octobot_trading/modes/script_keywords/basic_keywords/amount.py

@@ -37,7 +37,7 @@ async def get_amount_from_input_amount(
     amount_type, amount_value = dsl.parse_quantity(input_amount)
 
     if amount_type is dsl.QuantityType.UNKNOWN or amount_value <= 0:
-        raise trading_errors.InvalidArgumentError("amount cant be zero or negative")
+        raise trading_errors.InvalidArgumentError("Amount cant be zero or negative (amount: {amount_value})")
 
     if amount_type in (dsl.QuantityType.DELTA, dsl.QuantityType.DELTA_BASE):
         # nothing to do

{OctoBot-Trading-2.4.154 → OctoBot-Trading-2.4.156}/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.154 → OctoBot-Trading-2.4.156}/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.154 → OctoBot-Trading-2.4.156}/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.154 → OctoBot-Trading-2.4.156}/octobot_trading/personal_data/trades/trades_manager.py

@@ -165,9 +165,17 @@ class TradesManager(util.Initializable):
         try:
             if self.trader.exchange_manager.storage_manager.trades_storage:
                 full_history = await self.trader.exchange_manager.storage_manager.trades_storage.get_history()
-                self.logger.debug(f"Loaded {len(full_history)} trades")
-                for trade_dict in full_history:
-                    self.upsert_trade_instance(personal_data.Trade.from_dict(self.trader, trade_dict))
+                self.logger.debug(
+                    f"Loading {len(full_history)} {self.trader.exchange_manager.exchange_name} historical trades ..."
+                )
+                if full_history:
+                    for trade_dict in full_history:
+                        self.upsert_trade_instance(personal_data.Trade.from_dict(self.trader, trade_dict))
+                    self.logger.debug(
+                        f"Included {dict(self._get_trades_count_by_symbols())} "
+                        f"{self.trader.exchange_manager.exchange_name} trades"
+                    )
+
                 if reset:
                     # reset uploaded trades history
                     await self.trader.exchange_manager.storage_manager.trades_storage.trigger_debounced_update_auth_data(
@@ -183,13 +191,25 @@ class TradesManager(util.Initializable):
         except Exception as err:
             self.logger.exception(err, True, f"Error when loading local trade history {err}")
 
+    def _get_trades_count_by_symbols(self, trades=None):
+        return collections.Counter(
+            trade.symbol
+            for trade in (trades or self.trades.values())
+        )
+
     def _remove_oldest_trades(self, nb_to_remove):
         self.logger.info(
-            f"Clearing the {nb_to_remove} oldest historical trades as the maximum count of trades ("
-            f"{self.MAX_TRADES_COUNT}) has been reached"
+            f"Clearing the {nb_to_remove} oldest historical {self.trader.exchange_manager.exchange_name} "
+            f"trades as the maximum count of trades ({self.MAX_TRADES_COUNT}) has been reached"
         )
+        popped = []
         for _ in range(nb_to_remove):
-            self.trades.popitem(last=False)
+            popped.append(self.trades.popitem(last=False)[1])
+        self.logger.info(
+            f"Cleared the {len(popped)} {self.trader.exchange_manager.exchange_name} oldest historical trades: "
+            f"{dict(self._get_trades_count_by_symbols(trades=popped))}"
+        )
+
 
     def _set_initialized_event(self, symbol):
         # set init in updater as it's the only place we know if we fetched trades or not regardless of trades existence

{OctoBot-Trading-2.4.154 → OctoBot-Trading-2.4.156}/requirements.txt

@@ -9,6 +9,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.154 → OctoBot-Trading-2.4.156}/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(