OctoBot-Trading 2.4.205__tar.gz → 2.4.206__tar.gz

{OctoBot-Trading-2.4.205 → OctoBot-Trading-2.4.206}/CHANGELOG.md

@@ -4,9 +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.206] - 2025-08-15
+### Updated
+[SubPortfolio] forward locked assets in resolved subportfolios
+[Portfolio] make available funds update more flexible
+
 ## [2.4.205] - 2025-08-07
 ### Updated
-[SubPortfolio] add filled/cancelled orders inferring enging
+[SubPortfolio] add filled/cancelled orders inferring engine
 
 ## [2.4.204] - 2025-08-04
 ### Updated

{OctoBot-Trading-2.4.205 → OctoBot-Trading-2.4.206/OctoBot_Trading.egg-info}/PKG-INFO

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

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

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

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

{OctoBot-Trading-2.4.205 → OctoBot-Trading-2.4.206}/octobot_trading/exchanges/traders/trader.py

@@ -205,7 +205,7 @@ class Trader(util.Initializable):
                             )
                 else:
                     # consider order as cancelled to release portfolio amounts
-                    self.exchange_manager.exchange_personal_data.portfolio_manager.portfolio.update_portfolio_available(
+                    self.exchange_manager.exchange_personal_data.portfolio_manager.refresh_portfolio_available_from_order(
                         order, is_new_order=False
                     )
                     updated_price = edited_stop_price if edited_price is None else edited_price
@@ -218,7 +218,7 @@ class Trader(util.Initializable):
                         current_price=edited_current_price,
                     )
                     # consider order as new order to lock portfolio amounts
-                    self.exchange_manager.exchange_personal_data.portfolio_manager.portfolio.update_portfolio_available(
+                    self.exchange_manager.exchange_personal_data.portfolio_manager.refresh_portfolio_available_from_order(
                         order, is_new_order=True
                     )
                 # push order edit into orders channel as edit update
@@ -262,9 +262,22 @@ class Trader(util.Initializable):
         self.logger.debug(
             f"Successfully edited order on {self.exchange_manager.exchange_name}, new order values: {edited_order}"
         )
+        if not self.exchange_manager.exchange_personal_data.portfolio_manager.enable_portfolio_exchange_sync:
+            # consider order as cancelled to release portfolio amounts before locking the updated value
+            self.exchange_manager.exchange_personal_data.portfolio_manager.refresh_portfolio_available_from_order(
+                order, is_new_order=False
+            )
         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)
+        if self.exchange_manager.exchange_personal_data.portfolio_manager.enable_portfolio_exchange_sync:
+            await self.exchange_manager.exchange_personal_data.handle_portfolio_and_position_update_from_order(
+                order, require_exchange_update=True
+            )
+        else:
+            # consider order as cancelled to release portfolio amounts before locking the updated value
+            self.exchange_manager.exchange_personal_data.portfolio_manager.refresh_portfolio_available_from_order(
+                order, is_new_order=True
+            )
         return changed
 
     async def _create_new_order(

{OctoBot-Trading-2.4.205 → OctoBot-Trading-2.4.206}/octobot_trading/personal_data/exchange_personal_data.py

@@ -242,6 +242,12 @@ class ExchangePersonalData(util.Initializable):
             await self.handle_order_update_notification(order, update_type)
         return order.state is not None
 
+    def on_completed_orders_fetch(self):
+        # store the fact that all orders have been fetched from exchange
+        self.orders_manager.are_exchange_orders_initialized = True
+        # available funds can now be updated from fetched open orders
+        self.portfolio_manager.enable_portfolio_available_update_from_order = True
+
     def _is_out_of_sync_order(self, exchange_order_id) -> bool:
         return self.trades_manager.has_closing_trade_with_exchange_order_id(exchange_order_id)
 

{OctoBot-Trading-2.4.205 → OctoBot-Trading-2.4.206}/octobot_trading/personal_data/orders/channel/orders_updater.py

@@ -106,7 +106,7 @@ class OrdersUpdater(orders_channel.OrdersProducer):
                                                    retry_till_success=retry_till_success)
         finally:
             if self.channel is not None:
-                self.channel.exchange_manager.exchange_personal_data.orders_manager.are_exchange_orders_initialized = True
+                self.channel.exchange_manager.exchange_personal_data.on_completed_orders_fetch()
         await asyncio.sleep(self.TIME_BETWEEN_ORDERS_REFRESH)
         try:
             # can raise, closed orders are not critical data

{OctoBot-Trading-2.4.205 → OctoBot-Trading-2.4.206}/octobot_trading/personal_data/orders/channel/orders_updater_simulator.py

@@ -22,7 +22,8 @@ import octobot_trading.personal_data.orders.channel.orders_updater as orders_upd
 
 class OrdersUpdaterSimulator(orders_updater.OrdersUpdater):
     async def start(self):
-        self.channel.exchange_manager.exchange_personal_data.orders_manager.are_exchange_orders_initialized = True
+        # on simulator, orders are fetched from the start
+        self.channel.exchange_manager.exchange_personal_data.on_completed_orders_fetch()
         await exchange_channel.get_chan(constants.RECENT_TRADES_CHANNEL, self.channel.exchange_manager.id) \
             .new_consumer(self.ignore_recent_trades_update)
         for symbol in self.channel.exchange_manager.exchange_config.traded_symbol_pairs:

{OctoBot-Trading-2.4.205 → OctoBot-Trading-2.4.206}/octobot_trading/personal_data/orders/order.py

@@ -544,17 +544,23 @@ class Order(util.Initializable):
                 f"when creating active order from inactive order: {self}"
             )
 
-    async def on_pending_creation(self, is_from_exchange_data=False, enable_associated_orders_creation=True):
+    async def on_pending_creation(self, is_from_exchange_data=False, enable_associated_orders_creation=True,
+        is_already_counted_in_available_funds=False
+    ):
         with self.order_state_creation():
             state_class = orders_states.PendingCreationChainedOrderState if self.is_waiting_for_chained_trigger \
                 else orders_states.PendingCreationOrderState
             self.state = state_class(
                 self, is_from_exchange_data=is_from_exchange_data,
-                enable_associated_orders_creation=enable_associated_orders_creation
+                enable_associated_orders_creation=enable_associated_orders_creation,
+                is_already_counted_in_available_funds=is_already_counted_in_available_funds
             )
             await self.state.initialize()
 
-    async def on_open(self, force_open=False, is_from_exchange_data=False, enable_associated_orders_creation=True):
+    async def on_open(
+        self, force_open=False, is_from_exchange_data=False, enable_associated_orders_creation=True,
+        is_already_counted_in_available_funds=False
+    ):
         with self.order_state_creation():
             if isinstance(self.state, orders_states.PendingCreationOrderState):
                 await self.state.trigger_terminate()
@@ -566,11 +572,15 @@ class Order(util.Initializable):
                 return
             self.state = orders_states.OpenOrderState(
                 self, is_from_exchange_data=is_from_exchange_data,
-                enable_associated_orders_creation=enable_associated_orders_creation
+                enable_associated_orders_creation=enable_associated_orders_creation,
+                is_already_counted_in_available_funds=is_already_counted_in_available_funds
             )
             await self.state.initialize(forced=force_open)
 
-    async def on_fill(self, force_fill=False, is_from_exchange_data=False, enable_associated_orders_creation=None):
+    async def on_fill(
+        self, force_fill=False, is_from_exchange_data=False, enable_associated_orders_creation=None,
+        is_already_counted_in_available_funds=False
+    ):
         enable_associated_orders_creation = self.state.enable_associated_orders_creation \
             if (self.state and enable_associated_orders_creation is None) \
             else (True if enable_associated_orders_creation is None else enable_associated_orders_creation)
@@ -581,7 +591,8 @@ class Order(util.Initializable):
             with self.order_state_creation():
                 self.state = orders_states.FillOrderState(
                     self, is_from_exchange_data=is_from_exchange_data,
-                    enable_associated_orders_creation=enable_associated_orders_creation
+                    enable_associated_orders_creation=enable_associated_orders_creation,
+                    is_already_counted_in_available_funds=is_already_counted_in_available_funds
                 )
                 await self.state.initialize(forced=force_fill)
         else:
@@ -589,20 +600,23 @@ class Order(util.Initializable):
                                                              f"or canceled order: "
                                                              f"ignored fill call for {self}")
 
-    async def on_close(self, force_close=False, is_from_exchange_data=False, enable_associated_orders_creation=None):
+    async def on_close(self, force_close=False, is_from_exchange_data=False, enable_associated_orders_creation=None,
+        is_already_counted_in_available_funds=False
+    ):
         enable_associated_orders_creation = self.state.enable_associated_orders_creation \
             if (self.state and enable_associated_orders_creation is None) \
             else (True if enable_associated_orders_creation is None else enable_associated_orders_creation)
         with self.order_state_creation():
             self.state = orders_states.CloseOrderState(
                 self, is_from_exchange_data=is_from_exchange_data,
-                enable_associated_orders_creation=enable_associated_orders_creation
+                enable_associated_orders_creation=enable_associated_orders_creation,
+                is_already_counted_in_available_funds=is_already_counted_in_available_funds
             )
             await self.state.initialize(forced=force_close)
 
     async def on_cancel(
         self, is_from_exchange_data=False, force_cancel=False, enable_associated_orders_creation=None,
-        ignored_order=None
+        ignored_order=None, is_already_counted_in_available_funds=False
     ):
         enable_associated_orders_creation = self.state.enable_associated_orders_creation \
             if (self.state and enable_associated_orders_creation is None) \
@@ -610,7 +624,8 @@ class Order(util.Initializable):
         with self.order_state_creation():
             self.state = orders_states.CancelOrderState(
                 self, is_from_exchange_data=is_from_exchange_data,
-                enable_associated_orders_creation=enable_associated_orders_creation
+                enable_associated_orders_creation=enable_associated_orders_creation,
+                is_already_counted_in_available_funds=is_already_counted_in_available_funds
             )
             await self.state.initialize(forced=force_cancel, ignored_order=ignored_order)
 
@@ -828,7 +843,9 @@ class Order(util.Initializable):
     def generate_executed_time(self):
         return self.exchange_manager.exchange.get_exchange_current_time()
 
-    def is_counted_in_available_funds(self):
+    def is_counted_in_available_funds(self) -> bool:
+        if self.state and self.state.is_already_counted_in_available_funds:
+            return False
         if self.is_active:
             if self.trader.simulate or (
                 self.reduce_only and self.exchange_manager and self.exchange_manager.is_future

{OctoBot-Trading-2.4.205 → OctoBot-Trading-2.4.206}/octobot_trading/personal_data/orders/order_state.py

@@ -27,7 +27,9 @@ import octobot_trading.personal_data.state as state_class
 class OrderState(state_class.State):
     MAX_SYNCHRONIZATION_ATTEMPTS = -1   # implement self._force_final_state() when this is enabled
 
-    def __init__(self, order, is_from_exchange_data, enable_associated_orders_creation=True):
+    def __init__(self, order, is_from_exchange_data, enable_associated_orders_creation=True,
+        is_already_counted_in_available_funds=False
+    ):
         super().__init__(is_from_exchange_data)
 
         # ensure order has not been cleared
@@ -37,6 +39,7 @@ class OrderState(state_class.State):
         self.order = order
 
         self.enable_associated_orders_creation = enable_associated_orders_creation
+        self.is_already_counted_in_available_funds = is_already_counted_in_available_funds
 
     def is_created(self) -> bool:
         """

{OctoBot-Trading-2.4.205 → OctoBot-Trading-2.4.206}/octobot_trading/personal_data/orders/order_util.py

@@ -424,6 +424,9 @@ def get_orders_locked_amounts_by_asset(open_orders: list[order_import.Order]) ->
         return {}
     locked_funds_by_asset = {}
     for order in open_orders:
+        if not order.is_active:
+            # don't count inactive orders in locked funds
+            continue
         base, quote = symbol_util.parse_symbol(order.symbol).base_and_quote()
         # use get_order_locked_amount just like trader simulator to ensure locked funds integrity
         if order.side == enums.TradeOrderSide.BUY:

{OctoBot-Trading-2.4.205 → OctoBot-Trading-2.4.206}/octobot_trading/personal_data/orders/orders_manager.py

@@ -85,7 +85,7 @@ class OrdersManager(util.Initializable):
             until=until, limit=limit, tag=tag
         )
 
-    def get_order(self, order_id, exchange_order_id=None):
+    def get_order(self, order_id: typing.Optional[str], exchange_order_id: typing.Optional[str]=None) -> order_class.Order:
         if order_id is None:
             for order in self.orders.values():
                 if order.exchange_order_id == exchange_order_id:
@@ -93,7 +93,7 @@ class OrdersManager(util.Initializable):
             raise KeyError(exchange_order_id)
         return self.orders[order_id]
 
-    def get_order_from_group(self, group_name):
+    def get_order_from_group(self, group_name: str) -> list[order_class.Order]:
         return [
             order
             for order in self.orders.values()
@@ -101,7 +101,7 @@ class OrdersManager(util.Initializable):
         ]
 
     def get_or_create_group(
-        self, group_type, group_name,
+        self, group_type: type[order_group_import.OrderGroup], group_name: str,
         active_order_swap_strategy: typing.Optional[active_order_swap_strategy_import.ActiveOrderSwapStrategy] = None
     ):
         """
@@ -123,7 +123,7 @@ class OrdersManager(util.Initializable):
             )
 
     def create_group(
-        self, group_type, group_name=None,
+        self, group_type: type[order_group_import.OrderGroup], group_name: typing.Optional[str]=None,
         active_order_swap_strategy: typing.Optional[active_order_swap_strategy_import.ActiveOrderSwapStrategy] = None
     ):
         """
@@ -139,7 +139,7 @@ class OrdersManager(util.Initializable):
         self.order_groups[group_name] = group
         return group
 
-    async def upsert_order_from_raw(self, exchange_order_id, raw_order, is_from_exchange) -> (bool, order_class.Order):
+    async def upsert_order_from_raw(self, exchange_order_id: str, raw_order: dict, is_from_exchange: bool) -> tuple[bool, order_class.Order]:
         if not self.has_order(None, exchange_order_id=exchange_order_id):
             self.logger.info(f"Including new order fetched from exchange: {raw_order}")
             new_order = order_factory.create_order_instance_from_raw(self.trader, raw_order)
@@ -154,7 +154,7 @@ class OrdersManager(util.Initializable):
         order = self.get_order(None, exchange_order_id=exchange_order_id)
         return await _update_order_from_raw(order, raw_order), order
 
-    def register_pending_creation_order(self, pending_order):
+    def register_pending_creation_order(self, pending_order: order_class.Order):
         if self.trader.simulate:
             self.logger.error(f"Called register_pending_creation_order on an simulated trader, "
                               f"this should not happen. Order: {pending_order}")

{OctoBot-Trading-2.4.205 → OctoBot-Trading-2.4.206}/octobot_trading/personal_data/orders/states/cancel_order_state.py

@@ -25,9 +25,12 @@ import octobot_trading.personal_data.orders.states.order_state_factory as order_
 class CancelOrderState(order_state.OrderState):
     MAX_SYNCHRONIZATION_ATTEMPTS = 5
 
-    def __init__(self, order, is_from_exchange_data, enable_associated_orders_creation=True):
+    def __init__(self, order, is_from_exchange_data, enable_associated_orders_creation=True,
+        is_already_counted_in_available_funds=False
+    ):
         super().__init__(
-            order, is_from_exchange_data, enable_associated_orders_creation=enable_associated_orders_creation
+            order, is_from_exchange_data, enable_associated_orders_creation=enable_associated_orders_creation,
+            is_already_counted_in_available_funds=is_already_counted_in_available_funds
         )
         self.state = enums.OrderStates.CANCELING \
             if ((not self.order.simulated and not self.is_status_cancelled()) or self.is_status_pending()) \

{OctoBot-Trading-2.4.205 → OctoBot-Trading-2.4.206}/octobot_trading/personal_data/orders/states/close_order_state.py

@@ -19,9 +19,12 @@ import octobot_trading.personal_data.orders.order_state as order_state
 
 
 class CloseOrderState(order_state.OrderState):
-    def __init__(self, order, is_from_exchange_data, enable_associated_orders_creation=True, force_close=True):
+    def __init__(self, order, is_from_exchange_data, enable_associated_orders_creation=True,
+        is_already_counted_in_available_funds=False, force_close=True
+    ):
         super().__init__(
-            order, is_from_exchange_data, enable_associated_orders_creation=enable_associated_orders_creation
+            order, is_from_exchange_data, enable_associated_orders_creation=enable_associated_orders_creation,
+            is_already_counted_in_available_funds=is_already_counted_in_available_funds
         )
         self.state = enums.States.CLOSED if is_from_exchange_data or force_close or self.order.simulated \
             else enums.States.CLOSING

{OctoBot-Trading-2.4.205 → OctoBot-Trading-2.4.206}/octobot_trading/personal_data/orders/states/fill_order_state.py

@@ -25,9 +25,12 @@ import octobot_trading.personal_data.orders.states.order_state_factory as order_
 class FillOrderState(order_state.OrderState):
     MAX_SYNCHRONIZATION_ATTEMPTS = 5
 
-    def __init__(self, order, is_from_exchange_data, enable_associated_orders_creation=True):
+    def __init__(self, order, is_from_exchange_data, enable_associated_orders_creation=True,
+        is_already_counted_in_available_funds=False
+    )   :
         super().__init__(
-            order, is_from_exchange_data, enable_associated_orders_creation=enable_associated_orders_creation
+            order, is_from_exchange_data, enable_associated_orders_creation=enable_associated_orders_creation,
+            is_already_counted_in_available_funds=is_already_counted_in_available_funds
         )
         self.state = enums.OrderStates.FILLING \
             if ((

{OctoBot-Trading-2.4.205 → OctoBot-Trading-2.4.206}/octobot_trading/personal_data/orders/states/open_order_state.py

@@ -21,9 +21,12 @@ import octobot_trading.personal_data.orders.states.order_state_factory as order_
 
 
 class OpenOrderState(order_state.OrderState):
-    def __init__(self, order, is_from_exchange_data, enable_associated_orders_creation=True):
+    def __init__(self, order, is_from_exchange_data, enable_associated_orders_creation=True,
+        is_already_counted_in_available_funds=False
+    ):
         super().__init__(
-            order, is_from_exchange_data, enable_associated_orders_creation=enable_associated_orders_creation
+            order, is_from_exchange_data, enable_associated_orders_creation=enable_associated_orders_creation,
+            is_already_counted_in_available_funds=is_already_counted_in_available_funds
         )
         self.state = enums.States.OPEN if \
             is_from_exchange_data \
@@ -45,15 +48,18 @@ class OpenOrderState(order_state.OrderState):
         if forced:
             self.state = enums.States.OPEN
 
-        if self.order.exchange_manager.exchange_personal_data.orders_manager.are_exchange_orders_initialized:
+        if (
+            self.order.exchange_manager.exchange_personal_data.orders_manager.are_exchange_orders_initialized
+            or self.order.exchange_manager.exchange_personal_data.portfolio_manager.enable_portfolio_available_update_from_order
+        ):
             # update the availability of the currency in the portfolio if order is not
             # from exchange initialization (otherwise it's already taken into account in portfolio)
-            portfolio = self.order.exchange_manager.exchange_personal_data.portfolio_manager.portfolio
-            before_order_details = str(portfolio)
-            portfolio.update_portfolio_available(self.order, is_new_order=True)
+            portfolio_manager = self.order.exchange_manager.exchange_personal_data.portfolio_manager
+            before_order_details = str(portfolio_manager.portfolio)
+            portfolio_manager.refresh_portfolio_available_from_order(self.order, True)
             self.get_logger().debug(
                 f"Updated portfolio available after new open order. "
-                f"Before order: {before_order_details}. After order: {portfolio}"
+                f"Before order: {before_order_details}. After order: {portfolio_manager.portfolio}"
             )
 
         return await super().initialize_impl()

{OctoBot-Trading-2.4.205 → OctoBot-Trading-2.4.206}/octobot_trading/personal_data/orders/states/order_state_factory.py

@@ -18,28 +18,35 @@ import octobot_trading.constants as constants
 
 
 async def create_order_state(
-    order, is_from_exchange_data=False, enable_associated_orders_creation=True, ignore_states=None
+    order, is_from_exchange_data=False, enable_associated_orders_creation=True, 
+    is_already_counted_in_available_funds=False, ignore_states=None
 ):
     if ignore_states is None:
         ignore_states = []
 
     if order.status is enums.OrderStatus.PENDING_CREATION \
        and enums.States.PENDING_CREATION not in ignore_states:
-        await order.on_pending_creation(enable_associated_orders_creation=enable_associated_orders_creation)
+        await order.on_pending_creation(
+            enable_associated_orders_creation=enable_associated_orders_creation,
+            is_already_counted_in_available_funds=is_already_counted_in_available_funds
+        )
     elif order.status is enums.OrderStatus.OPEN and enums.States.OPEN not in ignore_states:
         await order.on_open(
             force_open=False, is_from_exchange_data=is_from_exchange_data,
-            enable_associated_orders_creation=enable_associated_orders_creation
+            enable_associated_orders_creation=enable_associated_orders_creation,
+            is_already_counted_in_available_funds=is_already_counted_in_available_funds
         )
     elif order.status in constants.FILL_ORDER_STATUS_SCOPE \
             and enums.OrderStates.FILLED not in ignore_states \
             and enums.States.CLOSED not in ignore_states:
         await order.on_fill(
             force_fill=False, is_from_exchange_data=is_from_exchange_data,
-            enable_associated_orders_creation=enable_associated_orders_creation
+            enable_associated_orders_creation=enable_associated_orders_creation,
+            is_already_counted_in_available_funds=is_already_counted_in_available_funds
         )
     elif order.status in constants.CANCEL_ORDER_STATUS_SCOPE and enums.OrderStates.CANCELED not in ignore_states:
         await order.on_cancel(
             force_cancel=False, is_from_exchange_data=is_from_exchange_data,
-            enable_associated_orders_creation=enable_associated_orders_creation
+            enable_associated_orders_creation=enable_associated_orders_creation,
+            is_already_counted_in_available_funds=is_already_counted_in_available_funds
         )

{OctoBot-Trading-2.4.205 → OctoBot-Trading-2.4.206}/octobot_trading/personal_data/orders/states/pending_creation_order_state.py

@@ -25,9 +25,12 @@ import octobot_trading.personal_data.orders.order_state as order_state
 
 class PendingCreationOrderState(order_state.OrderState):
 
-    def __init__(self, order, is_from_exchange_data, enable_associated_orders_creation=True):
+    def __init__(self, order, is_from_exchange_data, enable_associated_orders_creation=True,
+        is_already_counted_in_available_funds=False
+    ):
         super().__init__(
-            order, is_from_exchange_data, enable_associated_orders_creation=enable_associated_orders_creation
+            order, is_from_exchange_data, enable_associated_orders_creation=enable_associated_orders_creation,
+            is_already_counted_in_available_funds=is_already_counted_in_available_funds
         )
         self.state = enums.States.PENDING_CREATION
 

{OctoBot-Trading-2.4.205 → OctoBot-Trading-2.4.206}/octobot_trading/personal_data/portfolios/portfolio_manager.py

@@ -50,7 +50,9 @@ class PortfolioManager(util.Initializable):
         self.reference_market = None
         self._is_initialized_event_set = False
         self._forced_portfolio = None
-        self._enable_portfolio_update_from_order = True
+        self._enable_portfolio_total_update_from_order = True
+        self.enable_portfolio_exchange_sync = True
+        self.enable_portfolio_available_update_from_order = self.trader.simulate
 
     async def initialize_impl(self):
         """
@@ -91,7 +93,10 @@ class PortfolioManager(util.Initializable):
         portfolio changes using order data (as in trading simulator)
         :return: True if the portfolio was updated
         """
-        if self.trader.is_enabled and self._enable_portfolio_update_from_order:
+        if self.trader.is_enabled:
+            if not self.enable_portfolio_exchange_sync:
+                return self._refresh_simulated_trader_portfolio_from_order(order)
+
             async with self.portfolio_history_update():
                 if (self.trader.simulate or not order.is_active) or not require_exchange_update:
                     return self._refresh_simulated_trader_portfolio_from_order(order)
@@ -244,15 +249,21 @@ class PortfolioManager(util.Initializable):
                                  update_origin_crypto_currencies_values(symbol, mark_price))
 
     @contextlib.contextmanager
-    def disabled_portfolio_update_from_order(self):
+    def disabled_portfolio_update_from_order(self, enable_available_funds_update: bool = True):
         """
-        Can be used to locally disable portfolio refresh when an order is updated
+        Can be used to locally disable portfolio available/total refresh or sync when an order is updated
         """
-        self._enable_portfolio_update_from_order = False
+        previous_enable_portfolio_available_update_from_order = self.enable_portfolio_available_update_from_order
+        previous_enable_portfolio_exchange_sync = self.enable_portfolio_exchange_sync
+        self._enable_portfolio_total_update_from_order = False
+        self.enable_portfolio_available_update_from_order = enable_available_funds_update
+        self.enable_portfolio_exchange_sync = False
         try:
             yield
         finally:
-            self._enable_portfolio_update_from_order = True
+            self._enable_portfolio_total_update_from_order = True
+            self.enable_portfolio_available_update_from_order = previous_enable_portfolio_available_update_from_order
+            self.enable_portfolio_exchange_sync = previous_enable_portfolio_exchange_sync
 
     async def _refresh_real_trader_portfolio(self) -> bool:
         """
@@ -304,10 +315,11 @@ class PortfolioManager(util.Initializable):
         """
         try:
             if order.is_filled():
-                self.portfolio.update_portfolio_from_filled_order(order)
+                if self._enable_portfolio_total_update_from_order:
+                    self.portfolio.update_portfolio_from_filled_order(order)
             else:
                 # order cancelled
-                self.portfolio.update_portfolio_available(order, is_new_order=False)
+                self.refresh_portfolio_available_from_order(order, is_new_order=False)
             return True
         except errors.PortfolioNegativeValueError as portfolio_negative_value_error:
             self.logger.exception(portfolio_negative_value_error, True,
@@ -315,6 +327,15 @@ class PortfolioManager(util.Initializable):
                                   f"for order {order.to_dict()}")
         return False
 
+    def refresh_portfolio_available_from_order(self, order, is_new_order):
+        """
+        Refresh portfolio available from an order
+        :param order: the order to take into account
+        :param is_new_order: True if this is a newly opened order, false if it is a cancelled order
+        """
+        if self.enable_portfolio_available_update_from_order:
+            self.portfolio.update_portfolio_available(order, is_new_order=is_new_order)
+
     def _load_portfolio(self, reset_from_config):
         """
         Load simulated portfolio from config if required

{OctoBot-Trading-2.4.205 → OctoBot-Trading-2.4.206}/octobot_trading/personal_data/portfolios/portfolio_util.py

@@ -303,6 +303,7 @@ def _resolve_sub_portfolio(
         sub_portfolio.unit,
         funds_deltas=funds_deltas,
         missing_funds=missing_funds,
+        locked_funds_by_asset=sub_portfolio.locked_funds_by_asset,
     )
 
 

OctoBot-Trading-2.4.206/tests/personal_data/orders/states/__init__.py

@@ -0,0 +1,74 @@
+#  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 octobot_trading.enums as enums
+import typing
+
+
+async def inner_test_initialize_without_kwargs(order, status: enums.OrderStatus, mocked_method_name: typing.Optional[str]):
+    order.status = status
+    order.exchange_manager.is_backtesting = True
+    pre_call_states = []
+    if mocked_method_name is not None:
+        async def _side_effect(*args, **kwargs):
+            pre_call_states.append(order.state)
+            return await origin_method(*args, **kwargs)
+
+        origin_method = getattr(order, mocked_method_name)
+        with mock.patch.object(order, mocked_method_name, mock.AsyncMock(side_effect=_side_effect)) as method_mock:
+            await order.initialize()
+            method_mock.assert_awaited_once()
+    else:
+        await order.initialize()
+        pre_call_states.append(order.state)
+    pre_call_state = pre_call_states[0]
+    assert pre_call_state.is_from_exchange_data is False
+    assert pre_call_state.enable_associated_orders_creation is True
+    assert pre_call_state.is_already_counted_in_available_funds is False
+    order.clear()
+
+
+async def inner_test_initialize_with_kwargs(
+    order, status: enums.OrderStatus, 
+    mocked_method_name: typing.Optional[str], 
+    expected_is_from_exchange_data: bool = True
+):
+    order.status = status
+    order.exchange_manager.is_backtesting = True
+    pre_call_states = []
+    if mocked_method_name is not None:
+        async def _side_effect(*args, **kwargs):
+            pre_call_states.append(order.state)
+            return await origin_method(*args, **kwargs)
+
+        origin_method = getattr(order, mocked_method_name)
+        with mock.patch.object(order, mocked_method_name, mock.AsyncMock(side_effect=_side_effect)) as method_mock:
+            await order.initialize(
+                is_from_exchange_data=True, enable_associated_orders_creation=False, 
+                is_already_counted_in_available_funds=True
+            )
+            method_mock.assert_awaited_once()
+    else:
+        await order.initialize(
+            is_from_exchange_data=True, enable_associated_orders_creation=False, 
+            is_already_counted_in_available_funds=True
+        )
+        pre_call_states.append(order.state)
+    pre_call_state = pre_call_states[0]
+    assert pre_call_state.is_from_exchange_data is expected_is_from_exchange_data
+    assert pre_call_state.enable_associated_orders_creation is False
+    assert pre_call_state.is_already_counted_in_available_funds is True
+    order.clear()