[Linter] fixes

Author: GuillaumeDSM

packages/commons/octobot_commons/symbols/symbol.py

@@ -21,7 +21,7 @@
 _FULL_SYMBOL_GROUPS_REGEX = r"([^//]*)\/([^:]*):?([^-]*)-?([^-]*)-?([^-]*)-?([^-]*)"
 
 
-# pylint: disable=R0902
+# pylint: disable=R0902,R0913
 class Symbol:
     #                             base   /  quote : settlement-identifier-strike price-type
     # Inspired from CCXT https://docs.ccxt.com/#/README?id=contract-naming-conventions:
@@ -84,7 +84,7 @@ def parse_symbol(self, symbol_str: str):
         Parse the specified symbol
         :param symbol_str: the symbol to parse
         """
-        trading_symbol, self.network, self.dex = _extract_network_and_dex(
+        trading_symbol, self.network, self.dex = extract_network_and_dex(
             symbol_str, self.network_separator, self.dex_separator
         )
         if self.settlement_separator in trading_symbol:
@@ -258,11 +258,18 @@ def __repr__(self):
         return str(self)
 
 
-def _extract_network_and_dex(
+def extract_network_and_dex(
     symbol_str: str,
     network_separator: str = octobot_commons.NETWORK_SEPARATOR,
     dex_separator: str = octobot_commons.DEX_SEPARATOR,
 ) -> typing.Tuple[str, typing.Optional[str], typing.Optional[str]]:
+    """
+    Split a symbol into its trading part and optional network/DEX suffix.
+    :param symbol_str: the symbol to parse (e.g. ``BTC/USDT@SOL!RAYDIUM``)
+    :param network_separator: separator before the network suffix (default ``@``)
+    :param dex_separator: separator between network and dex (default ``!``)
+    :return: trading symbol, network name (or None), dex name (or None)
+    """
     if network_separator not in symbol_str:
         return symbol_str, None, None
     trading_symbol, network_and_dex = symbol_str.rsplit(network_separator, 1)

packages/commons/octobot_commons/symbols/symbol_util.py

@@ -43,7 +43,7 @@ def merge_symbol(symbol: str) -> str:
     :param symbol: the specified symbol
     :return: merged currency and market without /
     """
-    trading_symbol, _, _ = octobot_commons.symbols.symbol._extract_network_and_dex(symbol)
+    trading_symbol, _, _ = octobot_commons.symbols.symbol.extract_network_and_dex(symbol)
     return trading_symbol.replace(octobot_commons.MARKET_SEPARATOR, "").replace(
         octobot_commons.SETTLEMENT_ASSET_SEPARATOR, "_"
     )
@@ -118,7 +118,7 @@ def convert_symbol(
     :return:
     """
     if base_and_quote_only:
-        symbol, _, _ = octobot_commons.symbols.symbol._extract_network_and_dex(symbol)
+        symbol, _, _ = octobot_commons.symbols.symbol.extract_network_and_dex(symbol)
         symbol = symbol.split(octobot_commons.SETTLEMENT_ASSET_SEPARATOR)[0]
     if should_uppercase:
         return symbol.replace(symbol_separator, new_symbol_separator).upper()

packages/flow/tests/functionnal_tests/trading_modes_actions/simulator/test_index_trading_mode_action.py

@@ -430,7 +430,7 @@ async def test_simulator_index_rebalance_after_index_content_switch_btc_eth_to_b
             assert insert_trading_signal_mock.await_count == 3
             _assert_trading_signal_btc_eth_usdt_index_portfolio(insert_trading_signal_mock.await_args_list[0].args[0])
             _assert_trading_signal_btc_eth_sol_usdt_after_btc_sol_rebalance(insert_trading_signal_mock.await_args_list[1].args[0])
-            _assert_trading_signal_btc_eth_sol_usdt_after_btc_sol_rebalance(insert_trading_signal_mock.await_args_list[2].args[0])
+            _assert_trading_signal_btc_eth_sol_usdt_after_btc_sol_rebalance(insert_trading_signal_mock.await_args_list[2].args[0], allow_zero_ratio_assets=frozenset({"ETH"}))
         else:
             insert_trading_signal_mock.assert_not_awaited()
 

packages/sync/octobot_sync/constants.py

@@ -38,3 +38,11 @@
 # changing it changes every user's derived identity — and MUST be identical on the
 # client (cap provider) and server (allowlist + bridge wallet resolver).
 SYNC_BOOTSTRAP_CHALLENGE = "octobot:sync-bootstrap"
+
+EXCHANGE_ACCOUNTS_STATE_VERSION = "1.0.0"
+USER_ACCOUNTS_AUTH_STATE_VERSION = "1.0.0"
+USER_ACCOUNTS_TRADING_STATE_VERSION = "1.0.0"
+USER_STRATEGIES_STATE_VERSION = "1.0.0"
+USER_DATA_STATE_VERSION = "1.0.0"
+USER_ACTIONS_STATE_VERSION = "1.0.0"
+DEBUG_STATE_VERSION = "1.0.0"

packages/sync/tests/sync/collection_providers/test_account_trading_backend.py

@@ -139,8 +139,8 @@ def test_save_and_load_state_per_account_id(self, tmp_path):
             loaded_state = provider.load_state(_TEST_ADDRESS, _TEST_ACCOUNT_ID)
             provider.save_state(_TEST_ADDRESS, _TEST_ACCOUNT_ID, updated_state)
             reloaded_state = provider.load_state(_TEST_ADDRESS, _TEST_ACCOUNT_ID)
-        assert loaded_state.updated_at == fixture_time
-        assert reloaded_state.updated_at == updated_time
+        assert loaded_state.account_trading[0].updated_at == fixture_time
+        assert reloaded_state.account_trading[0].updated_at == updated_time
 
     def test_load_state_encrypted_reads_persisted_blob(self, tmp_path):
         provider = trading_provider_module.AccountTradingProvider(base_folder=str(tmp_path))

packages/trading/octobot_trading/exchanges/connectors/ccxt/ccxt_connector.py

@@ -257,6 +257,10 @@ async def load_symbol_markets(
             try:
                 await self._load_markets(self.client, reload, market_filter=market_filter)
                 ccxt_client_util.set_ccxt_client_cache(self.client, authenticated_cache)
+            except ccxt.async_support.OBIPWhitelistError as err:
+                raise octobot_trading.errors.InvalidAPIKeyIPWhitelistError(
+                    f"Invalid IP whitelist error: {html_util.get_html_summary_if_relevant(err)}"
+                ) from err
             except (
                 ccxt.async_support.AuthenticationError,
                 ccxt.async_support.ArgumentsRequired,
@@ -283,10 +287,6 @@ async def load_symbol_markets(
                     f"Failed to load_symbol_markets: {err.__class__.__name__} "
                     f"on {html_util.get_html_summary_if_relevant(err)}"
                 ) from err
-            except ccxt.async_support.OBIPWhitelistError as err:
-                raise octobot_trading.errors.InvalidAPIKeyIPWhitelistError(
-                    f"Invalid IP whitelist error: {html_util.get_html_summary_if_relevant(err)}"
-                ) from err
             except ccxt.async_support.ExchangeError as err:
                 # includes AuthenticationError but also auth error not identified as such by ccxt
                 if not self.force_authentication and self.is_authenticated:

packages/trading/octobot_trading/exchanges/connectors/simulator/ccxt_client_simulation.py

@@ -18,6 +18,7 @@
 import cachetools
 import ccxt.async_support as async_ccxt
 
+import octobot_commons.logging as commons_logging
 import octobot_trading.exchanges.connectors.ccxt.ccxt_client_util as ccxt_client_util
 import octobot_trading.enums as enums
 
@@ -44,20 +45,31 @@ def get_contract_size(market_status: dict) -> decimal.Decimal:
 def get_option_value(
     exchange_name: str, option_key: enums.ExchangeClientOptions
 ) -> typing.Union[bool, float, int, str, None]:
-    return ccxt_client_util.get_option_value(_temp_client(exchange_name), option_key)
+    return ccxt_client_util.get_option_value(_temp_client(exchange_name, allow_fallback=True), option_key)
 
 
 @cachetools.cached(cachetools.LRUCache(maxsize=256))
 def supports_bundled_orders(exchange_name: str, exchange_type: enums.ExchangeTypes, order_type: enums.TradeOrderType) -> bool:
     return ccxt_client_util.supports_bundled_orders(
-        _temp_client(exchange_name), exchange_type, order_type
+        _temp_client(exchange_name, allow_fallback=True), exchange_type, order_type
     )
 
 
-def _temp_client(exchange_name: str, additional_client_config: typing.Optional[dict] = None) -> async_ccxt.Exchange:
-    exchange_class = ccxt_client_util.ccxt_exchange_class_factory(exchange_name)
-    config = {
-        **(additional_client_config or {}),
-        **ccxt_client_util.get_custom_domain_config(exchange_class)
-    }
-    return exchange_class(config)
+def _temp_client(
+    exchange_name: str, additional_client_config: typing.Optional[dict] = None, allow_fallback: bool = False
+) -> async_ccxt.Exchange:
+    try:
+        exchange_class = ccxt_client_util.ccxt_exchange_class_factory(exchange_name)
+        config = {
+            **(additional_client_config or {}),
+            **ccxt_client_util.get_custom_domain_config(exchange_class)
+        }
+        return exchange_class(config)
+    except AttributeError as err:
+        if not allow_fallback:
+            raise
+        commons_logging.get_logger("ccxt_client_simulation").warning(
+            f"Error creating temporary client for {exchange_name}: {err}. Using fallback generic exchange."
+        )
+        return async_ccxt.Exchange()
+    

packages/trading/octobot_trading/personal_data/orders/decimal_order_adapter.py

@@ -21,7 +21,6 @@
 import octobot_trading.constants as constants
 import octobot_trading.errors as errors
 import octobot_trading.enums as enums
-import octobot_trading.exchanges as exchanges
 import octobot_trading.personal_data as personal_data
 from octobot_trading.enums import ExchangeConstantsMarketStatusColumns as Ecmsc
 

packages/trading/tests/exchanges/connectors/simulator/test_ccxt_client_simulation.py

@@ -0,0 +1,109 @@
+#  Drakkar-Software OctoBot-Trading
+#  Copyright (c) Drakkar-Software, All rights reserved.
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 3.0 of the License, or (at your option) any later version.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with this library.
+import mock
+import pytest
+
+import octobot_trading.exchanges.connectors.ccxt.ccxt_client_util as ccxt_client_util
+import octobot_trading.exchanges.connectors.simulator.ccxt_client_simulation as ccxt_client_simulation_module
+
+
+class TestTempClient:
+    def test_returns_client_with_merged_config(self):
+        exchange_instance = mock.Mock()
+        exchange_class = mock.Mock(return_value=exchange_instance)
+        custom_domain_config = {"hostname": "custom"}
+        with (
+            mock.patch.object(
+                ccxt_client_util,
+                "ccxt_exchange_class_factory",
+                return_value=exchange_class,
+            ) as factory_mock,
+            mock.patch.object(
+                ccxt_client_util,
+                "get_custom_domain_config",
+                return_value=custom_domain_config,
+            ) as domain_config_mock,
+        ):
+            client = ccxt_client_simulation_module._temp_client(
+                "binance",
+                additional_client_config={"apiKey": "k"},
+            )
+        factory_mock.assert_called_once_with("binance")
+        domain_config_mock.assert_called_once_with(exchange_class)
+        exchange_class.assert_called_once_with({"apiKey": "k", "hostname": "custom"})
+        assert client is exchange_instance
+
+    def test_uses_empty_config_when_additional_client_config_is_none(self):
+        exchange_instance = mock.Mock()
+        exchange_class = mock.Mock(return_value=exchange_instance)
+        custom_domain_config = {"hostname": "custom"}
+        with (
+            mock.patch.object(
+                ccxt_client_util,
+                "ccxt_exchange_class_factory",
+                return_value=exchange_class,
+            ),
+            mock.patch.object(
+                ccxt_client_util,
+                "get_custom_domain_config",
+                return_value=custom_domain_config,
+            ),
+        ):
+            client = ccxt_client_simulation_module._temp_client("binance")
+        exchange_class.assert_called_once_with(custom_domain_config)
+        assert client is exchange_instance
+
+    def test_raises_attribute_error_when_factory_fails_without_fallback(self):
+        with mock.patch.object(
+            ccxt_client_util,
+            "ccxt_exchange_class_factory",
+            side_effect=AttributeError("unknown exchange"),
+        ):
+            with pytest.raises(AttributeError, match="unknown exchange"):
+                ccxt_client_simulation_module._temp_client(
+                    "unknown_exchange",
+                    allow_fallback=False,
+                )
+
+    def test_returns_generic_exchange_when_factory_fails_with_allow_fallback(self):
+        fallback_exchange = mock.Mock()
+        logger_mock = mock.Mock()
+        simulation_module_path = "octobot_trading.exchanges.connectors.simulator.ccxt_client_simulation"
+        with (
+            mock.patch.object(
+                ccxt_client_util,
+                "ccxt_exchange_class_factory",
+                side_effect=AttributeError("unknown exchange"),
+            ),
+            mock.patch(
+                f"{simulation_module_path}.async_ccxt.Exchange",
+                return_value=fallback_exchange,
+            ) as exchange_ctor,
+            mock.patch(
+                f"{simulation_module_path}.commons_logging.get_logger",
+                return_value=logger_mock,
+            ),
+        ):
+            client = ccxt_client_simulation_module._temp_client(
+                "unknown_exchange",
+                allow_fallback=True,
+            )
+        exchange_ctor.assert_called_once_with()
+        logger_mock.warning.assert_called_once()
+        error_message = logger_mock.warning.call_args[0][0]
+        assert "unknown_exchange" in error_message
+        assert "fallback generic exchange" in error_message
+        assert client is fallback_exchange