OctoBot-Trading 2.4.92__tar.gz → 2.4.93__tar.gz

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/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.93] - 2024-07-23
+### Added
+- [Trades] get_trade_pnl API
+- [Orders] allow disabled_order_auto_synchronization 
+### Fixed
+- [Exchanges] Websocket limit issues
+### Updated
+- [Trades] Increase default max trades history to 6000 
+- [Orders] Add logs on auto-refresh 
+
 ## [2.4.92] - 2024-07-15
 ### Fixed
 - [Trades] optimize trade storage RAM

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93/OctoBot_Trading.egg-info}/PKG-INFO

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

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

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

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

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/octobot_trading/api/__init__.py

@@ -51,6 +51,7 @@ from octobot_trading.api.symbol_data import (
 from octobot_trading.api.trades import (
     get_trade_history,
     get_completed_pnl_history,
+    get_trade_pnl,
     is_executed_trade,
     is_trade_after_or_at,
     get_total_paid_trading_fees,
@@ -94,6 +95,7 @@ from octobot_trading.api.exchange import (
     get_backtesting_data_files,
     get_backtesting_data_file,
     get_has_websocket,
+    get_has_reached_websocket_limit,
     supports_websockets,
     is_compatible_account,
     get_new_ccxt_client,
@@ -177,10 +179,12 @@ from octobot_trading.api.profitability import (
 )
 from octobot_trading.api.orders import (
     get_open_orders,
+    get_pending_creation_orders,
     get_order_exchange_name,
     order_to_dict,
     parse_order_type,
     parse_order_status,
+    is_order_pending,
     get_order_profitability,
     get_minimal_order_cost,
     create_order,
@@ -234,6 +238,7 @@ __all__ = [
     "get_config_symbols",
     "get_trade_history",
     "get_completed_pnl_history",
+    "get_trade_pnl",
     "is_executed_trade",
     "is_trade_after_or_at",
     "get_total_paid_trading_fees",
@@ -273,6 +278,7 @@ __all__ = [
     "get_backtesting_data_files",
     "get_backtesting_data_file",
     "get_has_websocket",
+    "get_has_reached_websocket_limit",
     "supports_websockets",
     "is_compatible_account",
     "get_new_ccxt_client",
@@ -346,10 +352,12 @@ __all__ = [
     "get_reference_market",
     "get_initializing_currencies_prices",
     "get_open_orders",
+    "get_pending_creation_orders",
     "get_order_exchange_name",
     "order_to_dict",
     "parse_order_type",
     "parse_order_status",
+    "is_order_pending",
     "get_order_profitability",
     "get_minimal_order_cost",
     "create_order",

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/octobot_trading/api/exchange.py

@@ -202,6 +202,13 @@ def get_has_websocket(exchange_manager) -> bool:
     return exchange_manager.has_websocket
 
 
+def get_has_reached_websocket_limit(exchange_manager) -> bool:
+    return (
+        exchange_manager.exchange_web_socket
+        and exchange_manager.exchange_web_socket.is_beyond_feed_exchange_limit
+    )
+
+
 def supports_websockets(exchange_name: str, tentacles_setup_config) -> bool:
     return exchanges.supports_websocket(exchange_name, tentacles_setup_config)
 
@@ -243,10 +250,14 @@ def get_fees(exchange_manager, symbol) -> dict:
 
 
 def get_max_handled_pair_with_time_frame(exchange_manager) -> int:
+    if get_has_reached_websocket_limit(exchange_manager):
+        return exchange_manager.exchange_web_socket.get_connector_max_handled_feeds()
     return exchange_manager.exchange.get_max_handled_pair_with_time_frame()
 
 
 def get_currently_handled_pair_with_time_frame(exchange_manager) -> int:
+    if get_has_reached_websocket_limit(exchange_manager):
+        return exchange_manager.exchange_web_socket.get_connector_feeds_count()
     return exchange_manager.get_currently_handled_pair_with_time_frame()
 
 

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/octobot_trading/api/orders.py

@@ -45,6 +45,10 @@ def get_open_orders(exchange_manager, symbol=None) -> list:
     return exchange_manager.exchange_personal_data.orders_manager.get_open_orders(symbol=symbol)
 
 
+def get_pending_creation_orders(exchange_manager) -> list:
+    return exchange_manager.exchange_personal_data.orders_manager.pending_creation_orders
+
+
 async def cancel_all_open_orders(exchange_manager, emit_trading_signals=True) -> bool:
     return await exchange_manager.trader.cancel_all_open_orders(emit_trading_signals=emit_trading_signals)
 
@@ -74,6 +78,10 @@ def parse_order_status(dict_order) -> octobot_trading.enums.OrderStatus:
     return personal_data.parse_order_status(dict_order)
 
 
+def is_order_pending(order: personal_data.Order) -> bool:
+    return order.status == octobot_trading.enums.OrderStatus.PENDING_CREATION
+
+
 def get_order_profitability(exchange_manager, order_id) -> float:
     try:
         return exchange_manager.exchange_personal_data.orders_manager.get_order(order_id).get_profitability()

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/octobot_trading/api/trades.py

@@ -14,6 +14,7 @@
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
 import decimal
+import typing
 
 import octobot_trading.enums
 import octobot_trading.personal_data as personal_data
@@ -38,6 +39,14 @@ def get_completed_pnl_history(exchange_manager, quote=None, symbol=None, since=N
     )
 
 
+def get_trade_pnl(
+    exchange_manager, trade_id: typing.Optional[str] = None, order_id: typing.Optional[str] = None
+) -> typing.Optional[personal_data.TradePnl]:
+    return exchange_manager.exchange_personal_data.trades_manager.get_completed_trade_pnl(
+        trade_id, order_id
+    )
+
+
 def _trade_filter(trade, quote=None, symbol=None, timestamp=None, include_cancelled=False) -> bool:
     if trade.status is octobot_trading.enums.OrderStatus.CANCELED and not include_cancelled:
         return False

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/octobot_trading/constants.py

@@ -177,7 +177,7 @@ BALANCE_CHANNEL = "Balance"
 BALANCE_PROFITABILITY_CHANNEL = "BalanceProfitability"
 POSITIONS_CHANNEL = "Positions"
 INDIVIDUAL_ORDER_SYNC_TIMEOUT = 1 * commons_constants.MINUTE_TO_SECONDS
-MAX_TRADES_COUNT = int(os.getenv("MAX_TRADES_COUNT", "2000"))    # larger values can use a large part of ram
+MAX_TRADES_COUNT = int(os.getenv("MAX_TRADES_COUNT", "6000"))    # larger values can use a large part of ram
 
 # History
 DEFAULT_SAVED_HISTORICAL_TIMEFRAMES = [commons_enums.TimeFrames.ONE_DAY]

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/octobot_trading/exchanges/abstract_websocket_exchange.py

@@ -42,6 +42,8 @@ class AbstractWebsocketExchange:
         octobot_trading.enums.WebsocketFeeds.CANDLE,
         octobot_trading.enums.WebsocketFeeds.KLINE,
     ]
+    # Feeds to create above which not to use websockets
+    MAX_HANDLED_FEEDS = octobot_trading.constants.NO_DATA_LIMIT
 
     def __init__(self, config, exchange_manager):
         self.config = config
@@ -212,6 +214,10 @@ class AbstractWebsocketExchange:
         """
         return octobot_trading.constants.INFINITE_MAX_HANDLED_PAIRS_WITH_TIMEFRAME
 
+    @classmethod
+    def get_feeds_count(cls, pairs, time_frames) -> int:
+        raise NotImplementedError(f"get_feeds_count is not implemented")
+
     def _should_authenticate(self):
         api_key, api_secret, _ = self.get_exchange_credentials()
         return not self.exchange_manager.without_auth \

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/octobot_trading/exchanges/connectors/ccxt/ccxt_websocket_connector.py

@@ -620,14 +620,14 @@ class CCXTWebsocketConnector(abstract_websocket_exchange.AbstractWebsocketExchan
                     if not already_got_closed_by_user_error:
                         count_error = False
                         self.logger.debug(
-                            f"{ws_des} connection automatically closed, reconnecting in {self.LONG_RECONNECT_DELAY} "
-                            f"seconds ({err})"
+                            f"{ws_des} connection automatically closed, reconnecting in {self.LONG_RECONNECT_DELAY}"
+                            f" seconds ({err})"
                         )
                         already_got_closed_by_user_error = True
                 if count_error:
                     error_count = self._increment_error_counter(g_kwargs.get("time_frame"), err)
-                    error_message = f"Unexpected error when handling {ws_des} feed: {err} ({err.__class__.__name__}) " \
-                                    f"({error_count} times)"
+                    error_message = f"Unexpected error when handling {ws_des} feed: {err} " \
+                                    f"({err.__class__.__name__}) ({error_count} times)"
                     if error_count == 1:
                         self.logger.exception(err, True, error_message)
                     elif error_count % spamming_logs_warning_interval == 0:
@@ -642,7 +642,7 @@ class CCXTWebsocketConnector(abstract_websocket_exchange.AbstractWebsocketExchan
     def _create_task_if_necessary(self, feed, feed_callback, feed_generator, **kwargs):
         identifier = self._get_feed_identifier(feed_generator, kwargs)
         if identifier not in self.feed_tasks:
-            self.logger.debug(f"Subscribing to {feed.value} with {kwargs}")
+            self.logger.debug(f"Subscribing to {feed.value} with {kwargs} ({len(self.feed_tasks)} total feeds)")
             self.feed_tasks[identifier] = asyncio.create_task(
                 self._feed_task(feed, feed_callback, feed_generator, **kwargs)
             )
@@ -771,6 +771,17 @@ class CCXTWebsocketConnector(abstract_websocket_exchange.AbstractWebsocketExchan
     def _is_pair_independent_feed(self, feed):
         return feed in self.PAIR_INDEPENDENT_CHANNELS
 
+    @classmethod
+    def get_feeds_count(cls, pairs, time_frames) -> int:
+        total_count = 0
+        if pairs:
+            # rounding: account for 1 feed per symbol
+            total_count = len(pairs)
+            if cls.get_exchange_feed(trading_enums.WebsocketFeeds.CANDLE):
+                # rounding: account for 1 per timeframe per symbol
+                total_count += len(pairs) * len(time_frames)
+        return total_count
+
     def _convert_book_prices_to_orders(self, book_prices_and_volumes, book_side):
         """
         Convert a book_prices format : {PRICE_1: SIZE_1, PRICE_2: SIZE_2...}

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/octobot_trading/exchanges/exchange_builder.py

@@ -17,6 +17,7 @@
 import typing
 import octobot_commons.logging as logging
 import octobot_commons.constants as commons_constants
+import octobot_commons.authentication as commons_authentication
 
 import octobot_trading.errors as errors
 import octobot_trading.modes as modes
@@ -120,6 +121,9 @@ class ExchangeBuilder:
 
     async def build_trading_modes(self, trading_mode_class):
         try:
+            # ensure authenticated data are fetched before starting trading modes
+            if not self.exchange_manager.is_backtesting:
+                await commons_authentication.Authenticator.wait_and_check_has_open_source_package()
             self._ensure_trading_mode_compatibility(trading_mode_class)
             return await modes.create_trading_modes(
                 self.config,

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/octobot_trading/exchanges/exchange_manager.py

@@ -107,10 +107,11 @@ class ExchangeManager(util.Initializable):
                 await self.exchange_web_socket.close_sockets()
             except Exception as err:
                 self.logger.exception(err, True, f"Error when stopping exchange websocket: {err}")
-            self.exchange_web_socket.clear()
-            self.exchange_web_socket = None
             if enable_logs:
                 self.logger.debug("Stopped websocket")
+        if self.exchange_web_socket:
+            self.exchange_web_socket.clear()
+            self.exchange_web_socket = None
 
         # stop trading modes
         if enable_logs:

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/octobot_trading/exchanges/exchange_websocket_factory.py

@@ -59,8 +59,12 @@ async def _create_websocket(exchange_manager, websocket_class_name, ws_exchange_
     try:
         exchange_manager.exchange_web_socket = ws_exchange_class(exchange_manager.config, exchange_manager)
         await _init_websocket(exchange_manager)
-        exchange_manager.logger.info(f"{ws_exchange_class.get_name()} connecting to "
-                                     f"{exchange_manager.exchange.name.capitalize()}")
+        if exchange_manager.exchange_web_socket.is_websocket_running:
+            exchange_manager.logger.info(
+                f"{ws_exchange_class.get_name()} connecting to {exchange_manager.exchange.name.capitalize()}"
+            )
+        else:
+            exchange_manager.has_websocket = False
     except Exception as e:
         exchange_manager.logger.error(f"Fail to init websocket for {websocket_class_name} "
                                       f"({exchange_manager.exchange.name}): {e}")

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/octobot_trading/exchanges/traders/trader.py

@@ -285,7 +285,8 @@ class Trader(util.Initializable):
 
         await updated_order.initialize()
         if is_pending_creation and wait_for_creation \
-                and updated_order.state is not None and updated_order.state.is_pending():
+                and updated_order.state is not None and updated_order.state.is_pending()\
+                and self.exchange_manager.exchange_personal_data.orders_manager.enable_order_auto_synchronization:
             await updated_order.state.wait_for_terminate(creation_timeout)
         return updated_order
 

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/octobot_trading/exchanges/types/websocket_exchange.py

@@ -18,6 +18,7 @@ import sys
 import concurrent.futures as futures
 
 import octobot_commons.thread_util as thread_util
+import octobot_trading.constants
 import octobot_trading.enums
 import octobot_trading.exchanges.abstract_websocket_exchange as abstract_websocket
 
@@ -42,6 +43,7 @@ class WebSocketExchange(abstract_websocket.AbstractWebsocketExchange):
 
         self.is_websocket_running = False
         self.is_websocket_authenticated = False
+        self.is_beyond_feed_exchange_limit = False
 
         self.restart_task = None
 
@@ -59,6 +61,13 @@ class WebSocketExchange(abstract_websocket.AbstractWebsocketExchange):
         self.time_frames = time_frames
 
         if self.pairs:
+            if self._has_too_many_feeds_to_handle():
+                self.logger.info(
+                    f"Disabling websocket: {self.get_connector_feeds_count()} "
+                    f"feeds are required and {self.get_connector_max_handled_feeds()} are supported at most."
+                )
+                self.is_beyond_feed_exchange_limit = True
+                return
             # unauthenticated
             await self.add_feed(octobot_trading.enums.WebsocketFeeds.TRADES)
             await self.add_feed(octobot_trading.enums.WebsocketFeeds.L1_BOOK)
@@ -91,8 +100,9 @@ class WebSocketExchange(abstract_websocket.AbstractWebsocketExchange):
             # ensure feeds are added
             self.create_feeds()
         else:
-            self.logger.warning(f"{self.exchange_manager.exchange_name.title()}'s "
-                                f"websocket has no symbol to feed")
+            self.logger.warning(
+                f"{self.exchange_manager.exchange_name.title()}'s websocket has no symbol to feed"
+            )
 
     async def add_feed(self, feed_name):
         if self.is_feed_available(feed_name):
@@ -213,6 +223,17 @@ class WebSocketExchange(abstract_websocket.AbstractWebsocketExchange):
         for websocket in self.websocket_connectors:
             websocket.add_pairs(pairs, watching_only=watching_only)
 
+    def _has_too_many_feeds_to_handle(self) -> bool:
+        if self.get_connector_max_handled_feeds() == octobot_trading.constants.NO_DATA_LIMIT:
+            return False
+        return self.get_connector_feeds_count() >= self.get_connector_max_handled_feeds()
+
+    def get_connector_feeds_count(self):
+        return self.websocket_connector.get_feeds_count(self.pairs, self.time_frames)
+
+    def get_connector_max_handled_feeds(self):
+        return self.websocket_connector.MAX_HANDLED_FEEDS
+
     def clear(self):
         super(WebSocketExchange, self).clear()
         for connector in self.websocket_connectors:

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/octobot_trading/modes/abstract_trading_mode.py

@@ -349,7 +349,7 @@ class AbstractTradingMode(abstract_tentacle.AbstractTentacle):
                 return created_orders
 
     async def single_exchange_process_optimize_initial_portfolio(
-        self, sellable_assets, target_asset: str, tickers: dict
+        self, sellable_assets: list, target_asset: str, tickers: dict
     ) -> list:
         raise NotImplementedError("single_exchange_process_optimize_initial_portfolio is not implemented")
 

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/octobot_trading/modes/modes_util.py

@@ -75,7 +75,7 @@ def get_assets_requiring_extra_price_data_to_convert(exchange_manager, sellable_
 
 async def convert_assets_to_target_asset(trading_mode, sellable_assets: list, target_asset: str, tickers: dict) -> list:
     created_orders = []
-    for asset in sellable_assets:
+    for asset in sorted(sellable_assets):
         new_orders = await convert_asset_to_target_asset(
             trading_mode, asset, target_asset, tickers, asset_amount=None
         )

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/octobot_trading/personal_data/orders/channel/orders.py

@@ -214,7 +214,7 @@ class OrdersProducer(exchanges_channel.ExchangeChannelProducer):
                                               wait_for_refresh=wait_for_refresh))
         except IndexError:
             if not self.channel.exchange_manager.is_simulated and create_order_producer_if_missing:
-                self.logger.debug("Missing orders producer, starting one...")
+                self.logger.info("Missing orders producer, starting one...")
                 await exchanges.create_authenticated_producer_from_parent(self.channel.exchange_manager,
                                                                           self.__class__,
                                                                           force_register_producer=True)

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/octobot_trading/personal_data/orders/order_state.py

@@ -106,6 +106,9 @@ class OrderState(state_class.State):
         """
         try:
             self.ensure_not_cleared(self.order)
+            self.get_logger().info(
+                f"Synchronizing order {self.order} with {self.order.exchange_manager.exchange_name} exchange"
+            )
             await exchange_channel.get_chan(
                 octobot_trading.constants.ORDERS_CHANNEL,
                 self.order.exchange_manager.id
@@ -126,6 +129,9 @@ class OrderState(state_class.State):
         if order.is_cleared():
             raise octobot_trading.errors.InvalidOrderState(f"Order has already been cleared. Order: {order}")
 
+    def _is_synchronization_enabled(self):
+        return self.order.exchange_manager.exchange_personal_data.orders_manager.enable_order_auto_synchronization
+
     def clear(self):
         """
         Clear references

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/octobot_trading/personal_data/orders/orders_manager.py

@@ -16,6 +16,7 @@
 import collections
 import uuid
 import typing
+import contextlib
 
 import octobot_commons.logging as logging
 
@@ -35,7 +36,8 @@ class OrdersManager(util.Initializable):
         super().__init__()
         self.logger = logging.get_logger(self.__class__.__name__)
         self.trader = trader
-        self.orders_initialized = False  # TODO
+        self.orders_initialized = False
+        self.enable_order_auto_synchronization = True
         self.orders = collections.OrderedDict()
         self.order_groups = {}
         # orders that are expected from exchange but have not yet been fetched: will be removed when fetched
@@ -222,6 +224,17 @@ class OrdersManager(util.Initializable):
         self._add_order(order.order_id, order)
         self._check_orders_size()
 
+    @contextlib.contextmanager
+    def disabled_order_auto_synchronization(self):
+        """
+        Can be used to locally disable orders auto refresh when an order is pending
+        """
+        self.enable_order_auto_synchronization = False
+        try:
+            yield
+        finally:
+            self.enable_order_auto_synchronization = True
+
     # private methods
     def _reset_orders(self):
         self.orders_initialized = False

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/octobot_trading/personal_data/orders/states/pending_creation_order_state.py

@@ -46,6 +46,9 @@ class PendingCreationOrderState(order_state.OrderState):
             # If it turns out to be instantly closed, OctoBot will miss it as is will never be fetched with
             # open orders refresh.
             self.ensure_not_cleared(self.order)
+            self.get_logger().info(
+                f"Synchronizing order {self.order} with {self.order.exchange_manager.exchange_name} exchange"
+            )
             while self.order.is_pending_creation() \
                     and time.time() - t0 < octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT:
                 iteration += 1

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/octobot_trading/personal_data/state.py

@@ -157,7 +157,7 @@ class State(util.Initializable):
             else:
                 raise
         finally:
-            self.has_already_been_synchronized_once = True
+            self.has_already_been_synchronized_once = self._is_synchronization_enabled()
 
     async def synchronize_with_exchange(self, force_synchronization: bool = False) -> None:
         """
@@ -166,6 +166,9 @@ class State(util.Initializable):
         Restore the previous state if the refresh process fails
         :param force_synchronization: When True, for the update of the order from the exchange
         """
+        if not self._is_synchronization_enabled():
+            self.get_logger().info(f"Skipped {self.__class__.__name__} exchange synchronization")
+            return
         if self.is_refreshing():
             self.log_event_message(enums.StatesMessages.ALREADY_SYNCHRONIZING)
         else:
@@ -236,6 +239,9 @@ class State(util.Initializable):
         """
         raise NotImplementedError("on_refresh_successful not implemented")
 
+    def _is_synchronization_enabled(self):
+        return True
+
     def clear(self):
         """
         Clear references

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/octobot_trading/personal_data/trades/trades_manager.py

@@ -14,6 +14,7 @@
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
 import collections
+import typing
 
 import octobot_commons.logging as logging
 import octobot_commons.tree as commons_tree
@@ -86,14 +87,23 @@ class TradesManager(util.Initializable):
                 self.logger.warning(f"Trade without any registered fee: {trade.to_dict()}")
         return total_fees
 
-    def get_completed_trades_pnl(self, trades=None) -> list:
-        trades = trades or self.get_trades()
+    def get_completed_trade_pnl(
+        self, trade_id: typing.Optional[str], order_id: typing.Optional[str]
+    ) -> typing.Optional[trade_pnl.TradePnl]:
+        pnls = []
+        trade = self.get_trade(trade_id) if trade_id else self.get_trade_from_order_id(order_id)
+        if trade:
+            pnls = self.get_completed_trades_pnl(selected_trades=[trade])
+        return pnls[0] if pnls else None
+
+    def get_completed_trades_pnl(self, trades_history=None, selected_trades=None) -> list[trade_pnl.TradePnl]:
+        trades = trades_history or self.get_trades()
         trades_by_order_id = {
             trade.origin_order_id: trade
             for trade in trades
         }
         exits_by_entry_id = {}
-        for trade in trades:
+        for trade in (selected_trades or trades):
             if trade.status is not enums.OrderStatus.CANCELED and trade.associated_entry_ids:
                 for entry_id in trade.associated_entry_ids:
                     if entry_id not in trades_by_order_id:
@@ -109,9 +119,14 @@ class TradesManager(util.Initializable):
             for entry_id, exit_trade in exits_by_entry_id.items()
         ]
 
-    def get_trade(self, trade_id):
+    def get_trade(self, trade_id: str):
         return self.trades[trade_id]
 
+    def get_trade_from_order_id(self, order_id: str):
+        if trades := self.get_trades(origin_order_id=order_id):
+            return trades[0]
+        return None
+
     def get_trades(self, origin_order_id=None, exchange_order_id=None):
         return [
             trade

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/octobot_trading/util/test_tools/exchanges_test_tools.py

@@ -155,6 +155,14 @@ async def get_open_orders(
     return open_orders
 
 
+async def get_order(
+    exchange_manager,
+    exchange_order_id: str,
+    symbol: str,
+) -> dict:
+    return await exchange_manager.exchange.get_order(exchange_order_id, symbol=symbol)
+
+
 async def get_cancelled_orders(
     exchange_manager,
     exchange_data: exchange_data_import.ExchangeData,
@@ -245,5 +253,7 @@ async def wait_for_other_status(order: personal_data.Order, timeout) -> personal
             return personal_data.create_order_instance_from_raw(
                 order.trader, raw_order, force_open_or_pending_creation=False
             )
+        if time.time() - t0 + constants.CREATED_ORDER_FORCED_UPDATE_PERIOD >= timeout:
+            break
         await asyncio.sleep(constants.CREATED_ORDER_FORCED_UPDATE_PERIOD)
     raise TimeoutError(f"Order was not found with another status than {origin_status} within {timeout} seconds")

{OctoBot-Trading-2.4.92 → OctoBot-Trading-2.4.93}/tests/exchanges/test_exchange_builder.py

@@ -13,9 +13,11 @@
 #
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
+import mock.mock
 import pytest
 import octobot_trading.api as api
 import octobot_trading.exchanges as exchanges
+import octobot_commons.authentication as commons_authentication
 
 from tests.exchanges import exchange_manager
 from tests import event_loop
@@ -36,7 +38,14 @@ async def test_build_trading_modes_if_required(exchange_manager):
 
     # with trader simulator: will attempt to create a trading mode and fail (because of the None arg)
     builder.is_simulated()
-    with pytest.raises(AttributeError):
+    with mock.patch.object(
+        commons_authentication.Authenticator, "has_open_source_package", mock.Mock(return_value=False)
+    ) as has_open_source_package_mock:
+        with pytest.raises(AttributeError):
+            await builder._build_trading_modes_if_required(None)
+        has_open_source_package_mock.assert_called_once()
+    # raised by default has_open_source_package (which should be overriden)
+    with pytest.raises(NotImplementedError):
         await builder._build_trading_modes_if_required(None)