OctoBot-Trading 2.4.148__tar.gz → 2.4.150__tar.gz

{OctoBot-Trading-2.4.148 → OctoBot-Trading-2.4.150}/CHANGELOG.md

@@ -4,6 +4,14 @@ 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.150] - 2025-01-27
+### Added
+[Proxy] Proxy related errors and prefixes
+
+## [2.4.149] - 2025-01-22
+### Added
+[PersonalData] add get_trade_or_open_order and improve typing
+
 ## [2.4.148] - 2025-01-20
 ### Added
 [Exchanges] support custom domains

{OctoBot-Trading-2.4.148 → OctoBot-Trading-2.4.150/OctoBot_Trading.egg-info}/PKG-INFO

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

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

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

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

{OctoBot-Trading-2.4.148 → OctoBot-Trading-2.4.150}/octobot_trading/api/__init__.py

@@ -209,6 +209,7 @@ from octobot_trading.api.contracts import (
     is_perpetual_future_contract,
     get_pair_contracts,
     is_handled_contract,
+    ensure_supported_contract_configuration,
     has_pair_future_contract,
     update_pair_contract,
     load_pair_contract,
@@ -386,6 +387,7 @@ __all__ = [
     "is_perpetual_future_contract",
     "get_pair_contracts",
     "is_handled_contract",
+    "ensure_supported_contract_configuration",
     "has_pair_future_contract",
     "update_pair_contract",
     "load_pair_contract",

{OctoBot-Trading-2.4.148 → OctoBot-Trading-2.4.150}/octobot_trading/api/contracts.py

@@ -34,6 +34,10 @@ def is_handled_contract(contract) -> bool:
     return contract.is_handled_contract()
 
 
+def ensure_supported_contract_configuration(exchange_manager, pair: str):
+    get_pair_contracts(exchange_manager)[pair].ensure_supported_configuration()
+
+
 def has_pair_future_contract(exchange_manager, pair: str) -> bool:
     return exchange_manager.exchange.has_pair_future_contract(pair)
 
@@ -47,6 +51,6 @@ def load_pair_contract(exchange_manager, contract_dict: dict):
 
 
 def create_default_future_contract(
-    pair: str, leverage: decimal.Decimal, contract_type: enums.FutureContractType
+    pair: str, leverage: decimal.Decimal, contract_type: enums.FutureContractType, position_mode: enums.PositionMode
 ) -> exchange_data.FutureContract:
-    return exchange_data.create_default_future_contract(pair, leverage, contract_type)
+    return exchange_data.create_default_future_contract(pair, leverage, contract_type, position_mode)

{OctoBot-Trading-2.4.148 → OctoBot-Trading-2.4.150}/octobot_trading/errors.py

@@ -33,6 +33,12 @@ class MissingMinimalExchangeTradeVolume(OctoBotExchangeError):
     """
 
 
+class ExchangeProxyError(OctoBotExchangeError):
+    """
+    Raised when an issue related to an exchange proxy is encountered
+    """
+
+
 class TradingModeIncompatibility(Exception):
     """
     Raised when a trading mode is incompatible with the current situation
@@ -224,6 +230,18 @@ class UnhandledContractError(Exception):
     """
 
 
+class UnsupportedContractConfigurationError(Exception):
+    """
+    Raised when a contract configuration is not supported
+    """
+
+
+class UnsupportedHedgeContractError(UnsupportedContractConfigurationError):
+    """
+    Raised when a hedge contract configuration is not supported
+    """
+
+
 class TooManyOpenPositionError(Exception):
     """
     Raised when changing future contract attributes without closing positions first

{OctoBot-Trading-2.4.148 → OctoBot-Trading-2.4.150}/octobot_trading/exchange_data/contracts/contract_factory.py

@@ -79,7 +79,7 @@ def update_future_contract_from_dict(exchange_manager, contract: dict) -> bool:
 
 
 def create_default_future_contract(
-    pair: str, leverage: decimal.Decimal, contract_type: enums.FutureContractType
+    pair: str, leverage: decimal.Decimal, contract_type: enums.FutureContractType, position_mode: enums.PositionMode
 ) -> future_contract.FutureContract:
     return future_contract.FutureContract(
         pair=pair,
@@ -88,7 +88,7 @@ def create_default_future_contract(
         contract_type=contract_type,
         maximum_leverage=constants.DEFAULT_SYMBOL_MAX_LEVERAGE,
         current_leverage=leverage,
-        position_mode=constants.DEFAULT_SYMBOL_POSITION_MODE,
+        position_mode=position_mode,
         maintenance_margin_rate=constants.DEFAULT_SYMBOL_MAINTENANCE_MARGIN_RATE
     )
 

{OctoBot-Trading-2.4.148 → OctoBot-Trading-2.4.150}/octobot_trading/exchange_data/contracts/future_contract.py

@@ -17,6 +17,7 @@ import octobot_commons.logging as logging
 
 import octobot_trading.enums as enums
 import octobot_trading.constants as constants
+import octobot_trading.errors as errors
 
 import octobot_trading.exchange_data.contracts.margin_contract as margin_contract
 
@@ -95,6 +96,15 @@ class FutureContract(margin_contract.MarginContract):
         # unhandled / unknown contracts have None in self.contract_type
         return self.contract_type is not None
 
+    def ensure_supported_configuration(self):
+        """
+        will raise on unsupported configuration
+        """
+        if not self.is_one_way_position_mode():
+            raise errors.UnsupportedHedgeContractError(
+                f"{self.position_mode.value} position mode ({self.pair}) is not supported"
+            )
+
     def update_from_position(self, raw_position) -> bool:
         changed = super().update_from_position(raw_position)
         leverage = raw_position.get(enums.ExchangeConstantsPositionColumns.LEVERAGE.value, None)

{OctoBot-Trading-2.4.148 → OctoBot-Trading-2.4.150}/octobot_trading/exchange_data/contracts/margin_contract.py

@@ -78,6 +78,9 @@ class MarginContract:
         """
         return True
 
+    def ensure_supported_configuration(self):
+        pass
+
     def update_from_position(self, raw_position) -> bool:
         changed = False
         margin_type = raw_position.get(enums.ExchangeConstantsPositionColumns.MARGIN_TYPE.value, None)

{OctoBot-Trading-2.4.148 → OctoBot-Trading-2.4.150}/octobot_trading/exchanges/config/exchange_config_data.py

@@ -206,7 +206,7 @@ class ExchangeConfig(util.Initializable):
                 # add to global traded pairs
                 if is_enabled:
                     if not self.traded_cryptocurrencies[cryptocurrency]:
-                        self._logger.error(
+                        self._logger.warning(
                             f"{self.exchange_manager.exchange_name} is not supporting any {cryptocurrency} trading pair"
                             f" from the current configuration.")
                     traded_symbol_pairs_set = traded_symbol_pairs_set.union(
@@ -249,7 +249,7 @@ class ExchangeConfig(util.Initializable):
                 additional_details = f" Exchange sandbox is enabled, please make sure this pair is traded on " \
                                      f" the {self.exchange_manager.exchange_name} sandbox as sandboxes " \
                                      f"usually only support a subset of the real exchange's pairs."
-            self._logger.error(f"{self.exchange_manager.exchange_name} is not supporting the "
+            self._logger.warning(f"{self.exchange_manager.exchange_name} is not supporting the "
                                f"{symbol} trading pair.{additional_details}")
 
     @staticmethod

{OctoBot-Trading-2.4.148 → OctoBot-Trading-2.4.150}/octobot_trading/exchanges/config/proxy_config.py

@@ -32,6 +32,8 @@ class ProxyConfig:
     aiohttp_trust_env: bool = octobot_trading.constants.ENABLE_EXCHANGE_HTTP_PROXY_FROM_ENV
     # 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
 
     @classmethod
     def default_env_var_config(cls):

{OctoBot-Trading-2.4.148 → OctoBot-Trading-2.4.150}/octobot_trading/exchanges/connectors/ccxt/ccxt_adapter.py

@@ -289,7 +289,7 @@ class CCXTAdapter(adapters.AbstractAdapter):
                 if side == enums.PositionSide.LONG.value else enums.PositionSide.SHORT
             log_func = self.logger.debug
             if is_empty:
-                log_func = self.logger.error
+                log_func = self.logger.warning
             log_func(f"Unhandled {symbol} position mode ({position_mode.value}). This position can't be traded.")
         else:
             # One way position use BOTH side as there is always only one position per symbol.

{OctoBot-Trading-2.4.148 → OctoBot-Trading-2.4.150}/octobot_trading/exchanges/connectors/ccxt/ccxt_client_util.py

@@ -408,3 +408,33 @@ def _use_request_counter(identifier: str, ccxt_client: async_ccxt.Exchange):
 
 def ccxt_exchange_class_factory(exchange_name):
     return getattr(async_ccxt, exchange_name)
+
+def reraise_with_proxy_prefix_if_relevant(ccxt_connector, cause_error: Exception, raised_error: typing.Optional[Exception]):
+    if was_latest_request_proxied(ccxt_connector):
+        raised = raised_error or cause_error
+        raise raised.__class__(f"[Proxied request] {raised}") from cause_error
+
+
+def was_latest_request_proxied(ccxt_connector) -> bool:
+    if not (
+        ccxt_connector.exchange_manager.proxy_config
+        and ccxt_connector.exchange_manager.proxy_config.get_last_proxied_request_url
+    ):
+        return False
+    last_proxied_request_url = ccxt_connector.exchange_manager.proxy_config.get_last_proxied_request_url()
+    last_client_request_url = ccxt_connector.client.last_request_url
+    # if last requests are matching: it was proxied
+    return last_proxied_request_url == last_client_request_url
+
+
+def get_proxy_error_if_any(error: Exception) -> typing.Optional[Exception]:
+    if isinstance(error, (aiohttp.ClientProxyConnectionError, aiohttp.ClientHttpProxyError)):
+        return error
+    max_depth = 10
+    depth = 1
+    cause_error = error
+    while (cause_error := getattr(cause_error, "__cause__", None)) and depth < max_depth:
+        if isinstance(cause_error, (aiohttp.ClientProxyConnectionError, aiohttp.ClientHttpProxyError)):
+            return cause_error
+        depth += 1
+    return None

{OctoBot-Trading-2.4.148 → OctoBot-Trading-2.4.150}/octobot_trading/exchanges/connectors/ccxt/ccxt_connector.py

@@ -989,6 +989,21 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
         # 15 pairs, each on 3 time frames
         return 45
 
+    def raise_or_prefix_proxy_error_if_relevant(self, cause_error: Exception, raised_error: typing.Optional[Exception]):
+        """
+        Will raise octobot_trading.errors.ExchangeProxyError when the error is linked to a proxy
+        server of configuration issue.
+        Will re-raise a "[Proxied request] " prefix given error message if relevant, otherwise will just raise the error
+        """
+        if proxy_error := ccxt_client_util.get_proxy_error_if_any(cause_error):
+            raise octobot_trading.errors.ExchangeProxyError(proxy_error) from cause_error
+        # when api key is wrong or proxy is unavailable
+        ccxt_client_util.reraise_with_proxy_prefix_if_relevant(self, cause_error, raised_error)
+        # reraise_with_proxy_prefix_if_relevant did not raise, raise the error as is
+        if raised_error is None:
+            raise cause_error
+        raise raised_error from cause_error
+
     def log_ddos_error(self, error):
         self.logger.error(
             f"DDoSProtection triggered [{html_util.get_html_summary_if_relevant(error)} ({error.__class__.__name__})]. "
@@ -1003,26 +1018,32 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
     def error_describer(self):
         try:
             yield
-        except ccxt.DDoSProtection as e:
+        except ccxt.DDoSProtection as err:
             # 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(e):
-                self.log_ddos_error(e)
+            if self.exchange_manager.exchange.should_log_on_ddos_exception(err):
+                self.log_ddos_error(err)
             raise
         except ccxt.InvalidNonce as err:
             # use 2 index to get the caller of the context manager
             caller_function_name = inspect.stack()[2].function
             exchanges.log_time_sync_error(self.logger, self.name, err, caller_function_name)
             raise octobot_trading.errors.FailedRequest(html_util.get_html_summary_if_relevant(err)) from err
-        except ccxt.RequestTimeout as e:
+        except ccxt.RequestTimeout as err:
             raise octobot_trading.errors.FailedRequest(
-                f"Request timeout: {html_util.get_html_summary_if_relevant(e)}"
-            ) from e
+                f"Request timeout: {html_util.get_html_summary_if_relevant(err)}"
+            ) from err
         except ccxt.AuthenticationError as err:
-            raise octobot_trading.errors.AuthenticationError(html_util.get_html_summary_if_relevant(err)) from err
+            self.raise_or_prefix_proxy_error_if_relevant(
+                err,
+                octobot_trading.errors.AuthenticationError(html_util.get_html_summary_if_relevant(err))
+            )
         except ccxt.ExchangeNotAvailable as err:
-            raise octobot_trading.errors.FailedRequest(
-                f"Failed to execute request: {err.__class__.__name__}: {html_util.get_html_summary_if_relevant(err)}"
-            ) from err
+            self.raise_or_prefix_proxy_error_if_relevant(
+                err,
+                octobot_trading.errors.FailedRequest(
+                    f"Failed to execute request: {err.__class__.__name__}: {html_util.get_html_summary_if_relevant(err)}"
+                )
+            )
         except ccxt.ExchangeError as err:
             if self.exchange_manager.exchange.is_authentication_error(err):
                 # ensure this is not an unhandled authentication error

{OctoBot-Trading-2.4.148 → OctoBot-Trading-2.4.150}/octobot_trading/exchanges/implementations/exchange_simulator.py

@@ -161,7 +161,8 @@ class ExchangeSimulator(rest_exchange.RestExchange):
         contract = contract_factory.create_default_future_contract(
             pair,
             constants.DEFAULT_SYMBOL_LEVERAGE,
-            self.exchange_manager.exchange_config.backtesting_exchange_config.future_contract_type
+            self.exchange_manager.exchange_config.backtesting_exchange_config.future_contract_type,
+            constants.DEFAULT_SYMBOL_POSITION_MODE
         )
         return self.create_pair_contract(
             contract.pair,

{OctoBot-Trading-2.4.148 → OctoBot-Trading-2.4.150}/octobot_trading/modes/abstract_trading_mode.py

@@ -33,6 +33,7 @@ import octobot_tentacles_manager.configuration as tm_configuration
 
 import octobot_trading.constants as constants
 import octobot_trading.enums as enums
+import octobot_trading.errors as errors
 import octobot_trading.exchange_channel as exchanges_channel
 import octobot_trading.modes.modes_factory as modes_factory
 import octobot_trading.modes.channel.abstract_mode_producer as abstract_mode_producer
@@ -535,6 +536,13 @@ class AbstractTradingMode(abstract_tentacle.AbstractTentacle):
             common_constants.DEFAULT_IGNORED_VALUE
         )
 
+    def ensure_supported(self, symbol):
+        if self.exchange_manager.is_future:
+            try:
+                self.exchange_manager.exchange.pair_contracts[symbol].ensure_supported_configuration()
+            except KeyError:
+                raise errors.ContractExistsError(f"Missing contract for {symbol}")
+
     @contextlib.asynccontextmanager
     async def remote_signal_publisher(self, symbol: str):
         async with signals.remote_signal_publisher(self.exchange_manager, symbol, self.should_emit_trading_signal()) \

{OctoBot-Trading-2.4.148 → OctoBot-Trading-2.4.150}/octobot_trading/modes/channel/abstract_mode_consumer.py

@@ -63,6 +63,9 @@ class AbstractTradingModeConsumer(modes_channel.ModeChannelConsumer):
                               f"Future contract symbols contain the settlement currency after ':'. "
                               f"Example: use BTC/USDT:USDT for linear BTC/USDT contracts and "
                               f"BTC/USD:BTC for inverse BTC/USD contracts.")
+        except (errors.InvalidPositionSide, errors.UnsupportedContractConfigurationError) as err:
+            self.previous_call_error_per_symbol[symbol] = err
+            self.logger.error(f"Impossible to create {symbol} order: {err}.")
         except errors.OrderCreationError as err:
             self.previous_call_error_per_symbol[symbol] = err
             self.logger.info(f"Failed {symbol} order creation on: {self.exchange_manager.exchange_name} "
@@ -114,7 +117,10 @@ class AbstractTradingModeConsumer(modes_channel.ModeChannelConsumer):
                 if await self.can_create_order(symbol, state):
                     try:
                         return await self.create_new_orders(symbol, final_note, state, **kwargs)
-                    except (errors.MissingMinimalExchangeTradeVolume, errors.OrderCreationError):
+                    except (
+                        errors.MissingMinimalExchangeTradeVolume, errors.OrderCreationError,
+                        errors.InvalidPositionSide, errors.UnsupportedContractConfigurationError
+                    ):
                         raise
                     except errors.MissingFunds:
                         try:

{OctoBot-Trading-2.4.148 → OctoBot-Trading-2.4.150}/octobot_trading/personal_data/exchange_personal_data.py

@@ -15,6 +15,7 @@
 #  License along with this library.
 import asyncio
 import uuid
+import typing
 
 import octobot_commons.logging as logging
 
@@ -28,6 +29,7 @@ import octobot_trading.personal_data.orders.orders_manager as orders_manager
 import octobot_trading.personal_data.orders.order as order_import
 import octobot_trading.personal_data.orders.orders_storage_operations as orders_storage_operations
 import octobot_trading.personal_data.trades.trades_manager as trades_manager
+import octobot_trading.personal_data.trades.trade as trade_import
 import octobot_trading.personal_data.transactions.transactions_manager as transactions_manager
 import octobot_trading.personal_data.transactions.transaction_factory as transaction_factory
 import octobot_trading.util as util
@@ -44,11 +46,11 @@ class ExchangePersonalData(util.Initializable):
         self.trader = None
         self.exchange = None
 
-        self.portfolio_manager = None
-        self.trades_manager = None
-        self.orders_manager = None
-        self.positions_manager = None
-        self.transactions_manager = None
+        self.portfolio_manager: portfolio_manager.PortfolioManager = None
+        self.trades_manager: trades_manager.TradesManager = None
+        self.orders_manager: orders_manager.OrdersManager = None
+        self.positions_manager: positions_manager.PositionsManager = None
+        self.transactions_manager: transactions_manager.TransactionsManager = None
 
     async def initialize_impl(self):
         self.trader = self.exchange_manager.trader
@@ -361,6 +363,16 @@ class ExchangePersonalData(util.Initializable):
         except ValueError as e:
             self.logger.error(f"Failed to send position update notification : {e}")
 
+    def get_trade_or_open_order(self, order_id: str) -> (
+        typing.Optional[trade_import.Trade], typing.Optional[order_import.Order]
+    ):
+        trade = self.trades_manager.get_trade_from_order_id(order_id)
+        try:
+            order = self.orders_manager.get_order(order_id)
+        except KeyError:
+            order = None
+        return trade, order
+
     async def stop(self):
         if self.portfolio_manager is not None:
             await self.portfolio_manager.stop()

{OctoBot-Trading-2.4.148 → OctoBot-Trading-2.4.150}/octobot_trading/personal_data/orders/orders_manager.py

@@ -27,6 +27,7 @@ import octobot_trading.errors as errors
 import octobot_trading.personal_data.orders.order as order_class
 import octobot_trading.personal_data.orders.order_factory as order_factory
 import octobot_trading.personal_data.orders.order_util as order_util
+import octobot_trading.personal_data.orders.order_group as order_group_import
 
 
 class OrdersManager(util.Initializable):
@@ -38,10 +39,10 @@ class OrdersManager(util.Initializable):
         self.trader = trader
         self.orders_initialized = False
         self.enable_order_auto_synchronization = True
-        self.orders = collections.OrderedDict()
-        self.order_groups = {}
+        self.orders: collections.OrderedDict[str, order_class.Order] = collections.OrderedDict()
+        self.order_groups: dict[str, order_group_import.OrderGroup] = {}
         # orders that are expected from exchange but have not yet been fetched: will be removed when fetched
-        self.pending_creation_orders = []
+        self.pending_creation_orders: list[order_class.Order] = []
         # if this the orders manager completed the initial exchange orders sync phase (only on real trader)
         self.are_exchange_orders_initialized = self.trader.simulate
 

{OctoBot-Trading-2.4.148 → OctoBot-Trading-2.4.150}/octobot_trading/personal_data/positions/position.py

@@ -746,6 +746,9 @@ class Position(util.Initializable):
     def update_from_raw(self, raw_position):
         symbol = str(raw_position.get(enums.ExchangeConstantsPositionColumns.SYMBOL.value, None))
         currency, market = self.exchange_manager.get_exchange_quote_and_base(symbol)
+        position_id = (
+            self.position_id or raw_position.get(enums.ExchangeConstantsPositionColumns.LOCAL_ID.value) or symbol
+        )
         # side is managed locally, do not parse it
         return self._update(
             symbol=symbol,
@@ -763,7 +766,7 @@ class Position(util.Initializable):
             auto_deposit_margin=raw_position.get(
                 enums.ExchangeConstantsPositionColumns.AUTO_DEPOSIT_MARGIN.value, False
             ),
-            position_id=self.position_id or symbol,
+            position_id=position_id,
             exchange_position_id=str(raw_position.get(enums.ExchangeConstantsPositionColumns.ID.value, None) or symbol),
             timestamp=raw_position.get(enums.ExchangeConstantsPositionColumns.TIMESTAMP.value, 0),
             unrealized_pnl=raw_position.get(enums.ExchangeConstantsPositionColumns.UNREALIZED_PNL.value,

{OctoBot-Trading-2.4.148 → OctoBot-Trading-2.4.150}/octobot_trading/personal_data/trades/trades_manager.py

@@ -36,7 +36,7 @@ class TradesManager(util.Initializable):
         self.logger = logging.get_logger(self.__class__.__name__)
         self.trader = trader
         self.trades_initialized = False
-        self.trades = collections.OrderedDict()
+        self.trades: collections.OrderedDict[str, personal_data.Trade] = collections.OrderedDict()
 
     async def initialize_impl(self):
         await self.reload_history(False)

{OctoBot-Trading-2.4.148 → OctoBot-Trading-2.4.150}/octobot_trading/util/test_tools/exchanges_test_tools.py

@@ -116,13 +116,19 @@ async def add_symbols_details(
 ) -> exchange_data_import.ExchangeData:
 
     await ensure_symbol_markets(exchange_manager, reload=reload_markets, market_filter=market_filter)
-    await asyncio.gather(*(
-        _update_ohlcv(
-            exchange_manager, symbol, time_frame, exchange_data,
+    if len(symbols) == 1:
+        await _update_ohlcv(
+            exchange_manager, next(iter(symbols)), time_frame, exchange_data,
             history_size, start_time, end_time, close_price_only, include_latest_candle
         )
-        for symbol in symbols
-    ))
+    else:
+        await asyncio.gather(*(
+            _update_ohlcv(
+                exchange_manager, symbol, time_frame, exchange_data,
+                history_size, start_time, end_time, close_price_only, include_latest_candle
+            )
+            for symbol in symbols
+        ))
     return exchange_data
 
 
@@ -202,11 +208,13 @@ async def get_open_orders(
     ignore_unsupported_orders: bool = True,
 ) -> list:
     open_orders = []
-
     symbols = symbols or [market.symbol for market in exchange_data.markets]
-    await asyncio.gather(*(
-        _get_open_orders(exchange_manager, symbol, open_orders, ignore_unsupported_orders) for symbol in symbols
-    ))
+    if len(symbols) == 1:
+        await _get_open_orders(exchange_manager, next(iter(symbols)), open_orders, ignore_unsupported_orders)
+    else:
+        await asyncio.gather(*(
+            _get_open_orders(exchange_manager, symbol, open_orders, ignore_unsupported_orders) for symbol in symbols
+        ))
     return open_orders
 
 
@@ -235,10 +243,13 @@ async def get_cancelled_orders(
 ) -> list:
     cancelled_orders = []
     symbols = symbols or [market.symbol for market in exchange_data.markets]
-    await asyncio.gather(*(
-        _get_cancelled_orders(exchange_manager, symbol, cancelled_orders, ignore_unsupported_orders)
-        for symbol in symbols
-    ))
+    if len(symbols) == 1:
+        await _get_cancelled_orders(exchange_manager, next(iter(symbols)), cancelled_orders, ignore_unsupported_orders)
+    else:
+        await asyncio.gather(*(
+            _get_cancelled_orders(exchange_manager, symbol, cancelled_orders, ignore_unsupported_orders)
+            for symbol in symbols
+        ))
     return cancelled_orders
 
 
@@ -257,10 +268,13 @@ async def get_trades(
 ) -> list:
     trades = []
     symbols = symbols or [market.symbol for market in exchange_data.markets]
-    await asyncio.gather(*(
-        _get_trades(exchange_manager, symbol, trades)
-        for symbol in symbols
-    ))
+    if len(symbols) == 1:
+        await _get_trades(exchange_manager, next(iter(symbols)), trades)
+    else:
+        await asyncio.gather(*(
+            _get_trades(exchange_manager, symbol, trades)
+            for symbol in symbols
+        ))
     return trades
 
 
@@ -307,6 +321,10 @@ async def create_orders(
     order_creation_timeout: float,
     price_by_symbol: dict[str, float],
 ) -> list:
+    if len(orders) == 1:
+        return [
+            await _create_order(exchange_manager, next(iter(orders)), order_creation_timeout, price_by_symbol)
+        ]
     return await asyncio.gather(*(
         _create_order(exchange_manager, order_dict, order_creation_timeout, price_by_symbol)
         for order_dict in orders