OctoBot-Trading 2.4.66__tar.gz → 2.4.67__tar.gz

{OctoBot-Trading-2.4.66 → OctoBot-Trading-2.4.67}/CHANGELOG.md

@@ -4,6 +4,11 @@ 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.67] - 2024-03-23
+### Updated
+- [TradingMode] Requirements for indexes
+- [Orders] Use creation_time in to_dict
+
 ## [2.4.66] - 2024-03-19
 ### Updated
 - [CCXT] to 4.2.77

{OctoBot-Trading-2.4.66 → OctoBot-Trading-2.4.67/OctoBot_Trading.egg-info}/PKG-INFO

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

@@ -1,7 +1,7 @@
 numpy==1.26.3
 OctoBot-Backtesting<1.10,>=1.9
 Async-Channel<2.3,>=2.2
-OctoBot-Commons<1.10,>=1.9
+OctoBot-Commons<1.10,>=1.9.43
 OctoBot-Tentacles-Manager<2.10,>=2.9
 trading-backend>=1.2.7
 ccxt==4.2.77

{OctoBot-Trading-2.4.66/OctoBot_Trading.egg-info → OctoBot-Trading-2.4.67}/PKG-INFO

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

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

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

{OctoBot-Trading-2.4.66 → OctoBot-Trading-2.4.67}/octobot_trading/api/__init__.py

@@ -126,6 +126,7 @@ from octobot_trading.api.exchange import (
 from octobot_trading.api.modes import (
     get_trading_modes,
     get_trading_mode_symbol,
+    is_trading_mode_symbol_wildcard,
     get_trading_mode_followed_strategy_signals_identifier,
     get_trading_mode_current_state,
     get_activated_trading_mode,
@@ -301,6 +302,7 @@ __all__ = [
     "stop_exchange",
     "get_trading_modes",
     "get_trading_mode_symbol",
+    "is_trading_mode_symbol_wildcard",
     "get_trading_mode_followed_strategy_signals_identifier",
     "get_trading_mode_current_state",
     "get_activated_trading_mode",

{OctoBot-Trading-2.4.66 → OctoBot-Trading-2.4.67}/octobot_trading/api/modes.py

@@ -26,6 +26,10 @@ def get_trading_mode_symbol(trading_mode) -> list:
     return trading_mode.symbol
 
 
+def is_trading_mode_symbol_wildcard(trading_mode) -> bool:
+    return trading_mode.get_is_symbol_wildcard()
+
+
 def get_trading_mode_followed_strategy_signals_identifier(trading_mode) -> str:
     if trading_mode.is_following_trading_signals():
         return trading_mode.trading_config.get(commons_constants.CONFIG_TRADING_SIGNALS_STRATEGY, "")

{OctoBot-Trading-2.4.66 → OctoBot-Trading-2.4.67}/octobot_trading/constants.py

@@ -195,6 +195,7 @@ CANCEL_ORDER_STATUS_SCOPE = [enums.OrderStatus.PENDING_CANCEL,
 
 DEFAULT_INITIALIZATION_EVENT_TOPICS = [
     commons_enums.InitializationEventExchangeTopics.BALANCE,
+    commons_enums.InitializationEventExchangeTopics.PROFITABILITY,
     commons_enums.InitializationEventExchangeTopics.ORDERS,
     commons_enums.InitializationEventExchangeTopics.TRADES,
     commons_enums.InitializationEventExchangeTopics.CANDLES,

{OctoBot-Trading-2.4.66 → OctoBot-Trading-2.4.67}/octobot_trading/modes/channel/abstract_mode_consumer.py

@@ -69,17 +69,24 @@ class AbstractTradingModeConsumer(modes_channel.ModeChannelConsumer):
                              f"the order being refused by the exchange.")
 
     def get_minimal_funds_error(self, symbol, final_note):
-        market_status = self.exchange_manager.exchange.get_market_status(symbol, price_example=None, with_fixer=False)
-        try:
-            base, quote = symbol_util.parse_symbol(symbol).base_and_quote()
-            portfolio = self.exchange_manager.exchange_personal_data.portfolio_manager.portfolio
-            funds = {
-                base: portfolio.get_currency_portfolio(base),
-                quote: portfolio.get_currency_portfolio(quote)
-            }
-        except Exception as err:
-            self.logger.error(f"Error when getting funds for {symbol}: {err}")
-            funds = {}
+        if symbol is None:
+            return (
+                f"Not enough funds to create new orders after {final_note} evaluation: "
+                f"{self.exchange_manager.exchange_name} exchange minimal order "
+                f"volume has not been reached."
+            )
+        else:
+            market_status = self.exchange_manager.exchange.get_market_status(symbol, price_example=None, with_fixer=False)
+            try:
+                base, quote = symbol_util.parse_symbol(symbol).base_and_quote()
+                portfolio = self.exchange_manager.exchange_personal_data.portfolio_manager.portfolio
+                funds = {
+                    base: portfolio.get_currency_portfolio(base),
+                    quote: portfolio.get_currency_portfolio(quote)
+                }
+            except Exception as err:
+                self.logger.error(f"Error when getting funds for {symbol}: {err}")
+                funds = {}
         return (
             f"Not enough funds to create a new {symbol} order after {final_note} evaluation: "
             f"{self.exchange_manager.exchange_name} exchange minimal order "
@@ -135,6 +142,9 @@ class AbstractTradingModeConsumer(modes_channel.ModeChannelConsumer):
 
     # Can be overwritten
     async def can_create_order(self, symbol, state):
+        if symbol is None:
+            # can't check
+            return True
         currency, market = symbol_util.parse_symbol(symbol).base_and_quote()
         portfolio = self.exchange_manager.exchange_personal_data.portfolio_manager.portfolio
 
@@ -191,10 +201,6 @@ class AbstractTradingModeConsumer(modes_channel.ModeChannelConsumer):
         self.logger.debug("can_create_order: return False")
         return False
 
-    def get_holdings_ratio(self, currency):
-        return self.exchange_manager.exchange_personal_data.portfolio_manager.portfolio_value_holder \
-            .get_currency_holding_ratio(currency)
-
     def get_number_of_traded_assets(self):
         return len(self.exchange_manager.exchange_personal_data.portfolio_manager.portfolio_value_holder
                    .origin_crypto_currencies_values)

{OctoBot-Trading-2.4.66 → OctoBot-Trading-2.4.67}/octobot_trading/modes/channel/abstract_mode_producer.py

@@ -508,6 +508,16 @@ class AbstractTradingModeProducer(modes_channel.ModeChannelProducer):
                                                common_enums.InitializationEventExchangeTopics.CONTRACTS.value)
             await script_keywords.set_leverage(context, await script_keywords.user_select_leverage(context))
 
+    async def _wait_for_symbol_prices_and_profitability_init(self, timeout) -> bool:
+        try:
+            await util.wait_for_topic_init(self.exchange_manager, timeout,
+                                           common_enums.InitializationEventExchangeTopics.PRICE.value)
+            await util.wait_for_topic_init(self.exchange_manager, timeout,
+                                           common_enums.InitializationEventExchangeTopics.PROFITABILITY.value)
+        except (asyncio.TimeoutError, concurrent.futures.TimeoutError):
+            self.logger.error(f"Symbol price initialization took more than {timeout} seconds")
+        return False
+
     @classmethod
     def producer_exchange_wide_lock(cls, exchange_manager) -> asyncio_tools.RLock():
         try:

{OctoBot-Trading-2.4.66 → OctoBot-Trading-2.4.67}/octobot_trading/modes/script_keywords/basic_keywords/account_balance.py

@@ -71,22 +71,6 @@ async def available_account_balance(context, side=trading_enums.TradeOrderSide.B
         - already_locked_amount
 
 
-def get_holdings_value(context, assets, target_unit):
-    total_value = trading_constants.ZERO
-    portfolio = context.exchange_manager.exchange_personal_data.portfolio_manager.portfolio.portfolio
-    converter = context.exchange_manager.exchange_personal_data.portfolio_manager.portfolio_value_holder.value_converter
-    for asset, asset_holdings in portfolio.items():
-        if asset not in assets:
-            continue
-        try:
-            total_value += converter.evaluate_value(
-                asset, asset_holdings.total, raise_error=True, target_currency=target_unit, init_price_fetchers=False
-            )
-        except trading_errors.MissingPriceDataError:
-            context.logger.info(f"Missing {asset} price conversion, ignoring {float(asset_holdings.total)} holdings.")
-    return total_value
-
-
 def _get_locked_amount_in_stop_orders(context, side):
     locked_amount = trading_constants.ZERO
     for order in context.exchange_manager.exchange_personal_data.orders_manager.get_open_orders(context.symbol):

{OctoBot-Trading-2.4.66 → OctoBot-Trading-2.4.67}/octobot_trading/modes/script_keywords/basic_keywords/amount.py

@@ -59,7 +59,10 @@ async def get_amount_from_input_amount(
         if not context.symbol:
             raise trading_errors.InvalidArgumentError(f"{amount_type} input types requires context.symbol to be set")
         base, quote = commons_symbols.parse_symbol(context.symbol).base_and_quote()
-        total_symbol_assets_holdings_value = account_balance.get_holdings_value(context, (base, quote), base)
+        total_symbol_assets_holdings_value = context.exchange_manager.exchange_personal_data.portfolio_manager.\
+            portfolio_value_holder.get_assets_holdings_value(
+                (base, quote), commons_symbols.parse_symbol(context.symbol).base
+            )
         amount_value = total_symbol_assets_holdings_value * amount_value / trading_constants.ONE_HUNDRED
     elif amount_type is dsl.QuantityType.TRADED_SYMBOLS_ASSETS_PERCENT:
         if not context.symbol:
@@ -68,9 +71,10 @@ async def get_amount_from_input_amount(
         for symbol in context.exchange_manager.exchange_config.traded_symbols:
             assets.add(symbol.base)
             assets.add(symbol.quote)
-        total_symbol_assets_holdings_value = account_balance.get_holdings_value(
-            context, assets, commons_symbols.parse_symbol(context.symbol).base
-        )
+        total_symbol_assets_holdings_value = context.exchange_manager.exchange_personal_data.portfolio_manager.\
+            portfolio_value_holder.get_assets_holdings_value(
+                assets, commons_symbols.parse_symbol(context.symbol).base
+            )
         amount_value = total_symbol_assets_holdings_value * amount_value / trading_constants.ONE_HUNDRED
     elif amount_type is dsl.QuantityType.POSITION_PERCENT:
         raise NotImplementedError(amount_type)

{OctoBot-Trading-2.4.66 → OctoBot-Trading-2.4.67}/octobot_trading/personal_data/orders/order.py

@@ -784,7 +784,7 @@ class Order(util.Initializable):
             enums.ExchangeConstantsOrderColumns.SYMBOL.value: self.symbol,
             enums.ExchangeConstantsOrderColumns.PRICE.value: filled_price,
             enums.ExchangeConstantsOrderColumns.STATUS.value: self.status.value,
-            enums.ExchangeConstantsOrderColumns.TIMESTAMP.value: self.timestamp,
+            enums.ExchangeConstantsOrderColumns.TIMESTAMP.value: self.creation_time or self.timestamp,
             enums.ExchangeConstantsOrderColumns.TYPE.value: self.exchange_order_type.value
             if self.exchange_order_type else None,
             enums.ExchangeConstantsOrderColumns.SIDE.value: self.side.value,

{OctoBot-Trading-2.4.66 → OctoBot-Trading-2.4.67}/octobot_trading/personal_data/portfolios/portfolio_profitability.py

@@ -15,6 +15,8 @@
 #  License along with this library.
 import octobot_commons.logging as logging
 import octobot_commons.symbols as symbol_util
+import octobot_commons.tree as commons_tree
+import octobot_commons.enums as commons_enums
 
 import octobot_trading.util as util
 import octobot_trading.constants as constants
@@ -66,14 +68,25 @@ class PortfolioProfitability:
         """
         self._reset_before_profitability_calculation()
         try:
+            set_init_event = self.portfolio_manager.portfolio_value_holder.portfolio_current_value == constants.ZERO
             self.portfolio_manager.handle_profitability_recalculation(force_recompute_origin_portfolio)
             self._update_profitability_calculation()
+            if set_init_event:
+                self._set_initialized_event()
             return self.profitability_diff != constants.ZERO
         except KeyError as missing_data_exception:
             self.logger.warning(f"Missing {missing_data_exception} ticker data to calculate profitability")
         except Exception as missing_data_exception:
             self.logger.exception(missing_data_exception, True, str(missing_data_exception))
 
+    def _set_initialized_event(self):
+        commons_tree.EventProvider.instance().trigger_event(
+            self.portfolio_manager.exchange_manager.bot_id, commons_tree.get_exchange_path(
+                self.portfolio_manager.exchange_manager.exchange_name,
+                commons_enums.InitializationEventExchangeTopics.PROFITABILITY.value
+            )
+        )
+
     def _reset_before_profitability_calculation(self):
         """
         Prepare profitability calculation

{OctoBot-Trading-2.4.66 → OctoBot-Trading-2.4.67}/octobot_trading/personal_data/portfolios/portfolio_value_holder.py

@@ -20,6 +20,7 @@ import octobot_commons.symbols as symbol_util
 
 import octobot_trading.constants as constants
 import octobot_trading.errors as errors
+import octobot_trading.enums as enums
 import octobot_trading.personal_data.portfolios.value_converter as value_converter
 
 
@@ -116,17 +117,49 @@ class PortfolioValueHolder:
             for currency in holdings.keys()
         }
 
-    def get_currency_holding_ratio(self, currency):
-        """
-        Return the holdings ratio for the specified currency
-        :return: the holdings ratio
-        """
-        if self.portfolio_current_value:
-            return self.value_converter.evaluate_value(
-                currency,
-                self.portfolio_manager.portfolio.get_currency_portfolio(currency).total
-            ) / self.portfolio_current_value
-        return constants.ZERO
+    def get_assets_holdings_value(self, assets, target_unit, init_price_fetchers=False):
+        total_value = constants.ZERO
+        for asset, asset_holdings in self.portfolio_manager.portfolio.portfolio.items():
+            if asset not in assets:
+                continue
+            try:
+                total_value += self.value_converter.evaluate_value(
+                    asset, asset_holdings.total, raise_error=True,
+                    target_currency=target_unit, init_price_fetchers=init_price_fetchers
+                )
+            except errors.MissingPriceDataError:
+                self.logger.info(f"Missing {asset} price conversion, ignoring {float(asset_holdings.total)} holdings.")
+        return total_value
+
+    def get_holdings_ratio(self, currency, traded_symbols_only=False, include_assets_in_open_orders=False):
+        if traded_symbols_only:
+            # only consider traded assets for total_holdings_value
+            assets = set()
+            for symbol in self.portfolio_manager.exchange_manager.exchange_config.traded_symbols:
+                assets.add(symbol.base)
+                assets.add(symbol.quote)
+            total_holdings_value = self.get_assets_holdings_value(
+                assets, self.portfolio_manager.reference_market
+            )
+        else:
+            # consider all assets for total_holdings_value
+            total_holdings_value = self.portfolio_current_value
+        if not total_holdings_value:
+            return constants.ZERO
+        currency_holdings = self.portfolio_manager.portfolio.get_currency_portfolio(currency).total
+        if include_assets_in_open_orders:
+            # add assets in open orders to currency_holdings
+            assets_in_open_orders = constants.ZERO
+            for order in self.portfolio_manager.exchange_manager.exchange_personal_data.orders_manager.get_open_orders():
+                symbol = symbol_util.parse_symbol(order.symbol)
+                if order.side is enums.TradeOrderSide.BUY and symbol.base == currency:
+                    assets_in_open_orders += order.origin_quantity
+                elif order.side is enums.TradeOrderSide.SELL and symbol.quote == currency:
+                    assets_in_open_orders += order.total_cost
+            currency_holdings += assets_in_open_orders
+        # compute ration
+        current_holdings_value = self.value_converter.evaluate_value(currency, currency_holdings)
+        return current_holdings_value / total_holdings_value
 
     def handle_profitability_recalculation(self, force_recompute_origin_portfolio):
         """

{OctoBot-Trading-2.4.66 → OctoBot-Trading-2.4.67}/requirements.txt

@@ -3,7 +3,7 @@ numpy==1.26.3
 # Drakkar-Software requirements
 OctoBot-Backtesting>=1.9, <1.10
 Async-Channel>=2.2, <2.3
-OctoBot-Commons>=1.9, <1.10
+OctoBot-Commons>=1.9.43, <1.10
 OctoBot-Tentacles-Manager>=2.9, <2.10
 trading-backend>=1.2.7
 

{OctoBot-Trading-2.4.66 → OctoBot-Trading-2.4.67}/tests/modes/script_keywords/basic_keywords/test_account_balance.py

@@ -92,24 +92,6 @@ async def test_available_account_balance(mock_context):
         _get_locked_amount_in_stop_orders_mock.reset_mock()
 
 
-async def test_get_holdings_value(mock_context):
-    portfolio = mock_context.exchange_manager.exchange_personal_data.portfolio_manager.portfolio.portfolio
-    last_prices = mock_context.exchange_manager.exchange_personal_data.portfolio_manager.portfolio_value_holder.\
-        value_converter.last_prices_by_trading_pair
-    # no provided input asset
-    assert account_balance.get_holdings_value(mock_context, (), "USDT") == trading_constants.ZERO
-    # missing currency
-    assert account_balance.get_holdings_value(mock_context, {"BTC", "ETH"}, "PLOP") == trading_constants.ZERO
-    assert account_balance.get_holdings_value(mock_context, ("BTC"), "BTC") == portfolio["BTC"].total
-    assert account_balance.get_holdings_value(mock_context, ("BTC"), "BTC") != portfolio["BTC"].available
-    assert account_balance.get_holdings_value(mock_context, ("BTC"), "USDT") == \
-           portfolio["BTC"].total * last_prices["BTC/USDT"]
-    assert account_balance.get_holdings_value(mock_context, {"BTC", "ETH"}, "USDT") == \
-           portfolio["BTC"].total * last_prices["BTC/USDT"] + portfolio["ETH"].total * last_prices["ETH/USDT"]
-    assert account_balance.get_holdings_value(mock_context, {"BTC", "ETH"}, "ETH") == \
-           portfolio["BTC"].total / last_prices["ETH/BTC"] + portfolio["ETH"].total
-
-
 async def test_adapt_amount_to_holdings(null_context):
     with mock.patch.object(account_balance, "available_account_balance",
                            mock.AsyncMock(return_value=decimal.Decimal(1))) as available_account_balance_mock:

{OctoBot-Trading-2.4.66 → OctoBot-Trading-2.4.67}/tests/modes/script_keywords/basic_keywords/test_amount.py

@@ -33,6 +33,13 @@ pytestmark = pytest.mark.asyncio
 
 
 async def test_get_amount_from_input_amount(null_context):
+    null_context.exchange_manager = mock.Mock(
+        exchange_personal_data=mock.Mock(
+            portfolio_manager=mock.Mock(
+                portfolio_value_holder=mock.Mock()
+            )
+        )
+    )
     with pytest.raises(errors.InvalidArgumentError):
         await script_keywords.get_amount_from_input_amount(null_context, "-1")
 
@@ -175,10 +182,10 @@ async def test_get_amount_from_input_amount(null_context):
         with mock.patch.object(dsl, "parse_quantity",
                                mock.Mock(return_value=(
                                        script_keywords.QuantityType.CURRENT_SYMBOL_ASSETS_PERCENT, decimal.Decimal(75)))) \
-                as parse_quantity_mock, \
-                mock.patch.object(account_balance, "get_holdings_value",
-                                  mock.Mock(return_value=decimal.Decimal(2))) \
-                as get_holdings_value_mock:
+                as parse_quantity_mock, mock.patch.object(
+            null_context.exchange_manager.exchange_personal_data.portfolio_manager.portfolio_value_holder,
+            "get_assets_holdings_value", mock.Mock(return_value=decimal.Decimal(2))
+        ) as get_holdings_value_mock:
             null_context.symbol = None
             with pytest.raises(errors.InvalidArgumentError):
                 # context.symbol is None
@@ -191,16 +198,16 @@ async def test_get_amount_from_input_amount(null_context):
             adapt_amount_to_holdings_mock.assert_called_once_with(null_context, decimal.Decimal("1.5"), "buy",
                                                                   False, True, False, target_price=None)
             parse_quantity_mock.assert_called_once_with("50")
-            get_holdings_value_mock.assert_called_once_with(null_context, ("BTC", "USDT"), "BTC")
+            get_holdings_value_mock.assert_called_once_with(("BTC", "USDT"), "BTC")
             adapt_amount_to_holdings_mock.reset_mock()
 
         with mock.patch.object(dsl, "parse_quantity",
                                mock.Mock(return_value=(
                                        script_keywords.QuantityType.TRADED_SYMBOLS_ASSETS_PERCENT, decimal.Decimal(75)))) \
-                as parse_quantity_mock, \
-                mock.patch.object(account_balance, "get_holdings_value",
-                                  mock.Mock(return_value=decimal.Decimal(10))) \
-                as get_holdings_value_mock:
+            as parse_quantity_mock, mock.patch.object(
+                null_context.exchange_manager.exchange_personal_data.portfolio_manager.portfolio_value_holder,
+                "get_assets_holdings_value", mock.Mock(return_value=decimal.Decimal(10))
+            ) as get_holdings_value_mock:
             null_context.symbol = None
             with pytest.raises(errors.InvalidArgumentError):
                 # context.symbol is None
@@ -208,19 +215,21 @@ async def test_get_amount_from_input_amount(null_context):
                     1)
             parse_quantity_mock.reset_mock()
             null_context.symbol = "BTC/USDT"
+            exchange_personal_data = null_context.exchange_manager.exchange_personal_data
             null_context.exchange_manager = mock.Mock(
                 exchange_config=mock.Mock(
                     traded_symbols=[
                         commons_symbols.parse_symbol("BTC/USDT"),
                         commons_symbols.parse_symbol("ETH/BTC"),
                         commons_symbols.parse_symbol("SOL/USDT"),
-                    ]
-                )
+                    ],
+                ),
+                exchange_personal_data=exchange_personal_data
             )
 
             assert await script_keywords.get_amount_from_input_amount(null_context, "50", "buy") == decimal.Decimal(1)
             adapt_amount_to_holdings_mock.assert_called_once_with(null_context, decimal.Decimal("7.5"), "buy",
                                                                   False, True, False, target_price=None)
             parse_quantity_mock.assert_called_once_with("50")
-            get_holdings_value_mock.assert_called_once_with(null_context, {'BTC', 'ETH', 'SOL', 'USDT'}, "BTC")
+            get_holdings_value_mock.assert_called_once_with({'BTC', 'ETH', 'SOL', 'USDT'}, "BTC")
             adapt_amount_to_holdings_mock.reset_mock()

{OctoBot-Trading-2.4.66 → OctoBot-Trading-2.4.67}/tests/modes/test_abstract_mode_consumer.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 mock
 import pytest
 
 import octobot_commons.constants as commons_constants
@@ -24,6 +25,7 @@ from octobot_trading.modes.channel.abstract_mode_consumer import AbstractTrading
 from octobot_trading.enums import EvaluatorStates
 import octobot_trading.constants as constants
 import octobot_trading.errors as errors
+import octobot_trading.enums as enums
 from octobot_trading.exchanges.exchange_manager import ExchangeManager
 from octobot_trading.modes import AbstractTradingMode
 import octobot_trading.personal_data.portfolios.assets as portfolio_assets
@@ -133,42 +135,6 @@ async def test_valid_create_new_order():
         await consumer.create_new_orders(symbol, -1, EvaluatorStates.LONG, xyz=1, aaa="bbb")
 
 
-async def test_get_holdings_ratio():
-    exchange_manager, symbol, consumer = await _get_tools()
-    exchange_manager.client_symbols = [symbol]
-    exchange_manager.exchange_personal_data.portfolio_manager.portfolio_value_holder.\
-        value_converter.last_prices_by_trading_pair[symbol] = decimal.Decimal("1000")
-    exchange_manager.exchange_personal_data.portfolio_manager.portfolio_value_holder.\
-        portfolio_current_value = decimal.Decimal("11")
-    exchange_manager.exchange_personal_data.portfolio_manager.portfolio.portfolio = {}
-    exchange_manager.exchange_personal_data.portfolio_manager.portfolio.portfolio["BTC"] = \
-        portfolio_assets.SpotAsset(name="BTC", available=decimal.Decimal("10"), total=decimal.Decimal("10"))
-    exchange_manager.exchange_personal_data.portfolio_manager.portfolio.portfolio["USDT"] = \
-        portfolio_assets.SpotAsset(name="USDT", available=decimal.Decimal("1000"), total=decimal.Decimal("1000"))
-
-    assert consumer.get_holdings_ratio("BTC") == decimal.Decimal('0.9090909090909090909090909091')
-    assert consumer.get_holdings_ratio("USDT") == decimal.Decimal('0.09090909090909090909090909091')
-
-    exchange_manager.exchange_personal_data.portfolio_manager.portfolio.portfolio.pop("USDT")
-    exchange_manager.exchange_personal_data.portfolio_manager.portfolio_value_holder.\
-        portfolio_current_value = decimal.Decimal("10")
-    assert consumer.get_holdings_ratio("BTC") == constants.ONE
-    # add ETH and try to get ratio without symbol price
-    exchange_manager.exchange_personal_data.portfolio_manager.portfolio.\
-        get_currency_portfolio("ETH").total = decimal.Decimal(10)
-    # force not backtesting mode
-    exchange_manager.is_backtesting = False
-    # force add symbol in exchange symbols
-    exchange_manager.client_symbols.append("ETH/BTC")
-    with pytest.raises(errors.MissingPriceDataError):
-        ratio = consumer.get_holdings_ratio("ETH")
-    # let channel register proceed
-    await wait_asyncio_next_cycle()
-    assert consumer.get_holdings_ratio("BTC") == constants.ONE
-    assert consumer.get_holdings_ratio("USDT") == constants.ZERO
-    assert consumer.get_holdings_ratio("XYZ") == constants.ZERO
-
-
 async def test_get_number_of_traded_assets():
     exchange_manager, symbol, consumer = await _get_tools()
     exchange_manager.exchange_personal_data.portfolio_manager.portfolio_value_holder.\

{OctoBot-Trading-2.4.66 → OctoBot-Trading-2.4.67}/tests/personal_data/orders/test_order_factory.py

@@ -118,31 +118,55 @@ class TestOrderFactory:
         await self.stop(exchange_manager)
 
     async def test_create_order_from_order_storage_details_with_simple_order(self):
-        _, exchange_manager, trader_inst = await self.init_default()    
+        _, exchange_manager, trader_inst = await self.init_default()
+        try:
         
-        order = personal_data.BuyLimitOrder(trader_inst)
-        order.update(order_type=TraderOrderType.BUY_LIMIT,
-                     symbol="BTC/USDT",
-                     current_price=decimal.Decimal("70"),
-                     quantity=decimal.Decimal("10"),
-                     price=decimal.Decimal("70"))
-        order_storage_details = orders_storage._format_order(order, exchange_manager)
-        order_storage_details[StoredOrdersAttr.ENTRIES.value] = ["11111"]
-    
-        pending_groups = {}
-        created_order = await personal_data.create_order_from_order_storage_details(
-            order_storage_details, exchange_manager, pending_groups
-        )
-        assert pending_groups == {}
-    
-        assert created_order.exchange_manager is exchange_manager
-        assert created_order.origin_quantity == order.origin_quantity
-        assert created_order.origin_price == order.origin_price
-        assert created_order.__class__ is order.__class__
-        # associated_entry_ids are added from order_storage_details but not in original order
-        assert created_order.associated_entry_ids == ["11111"]
-        assert order.associated_entry_ids is None
-        await self.stop(exchange_manager)
+            order = personal_data.BuyLimitOrder(trader_inst)
+            order.update(order_type=TraderOrderType.BUY_LIMIT,
+                         symbol="BTC/USDT",
+                         current_price=decimal.Decimal("70"),
+                         quantity=decimal.Decimal("10"),
+                         price=decimal.Decimal("70"))
+            order_storage_details = orders_storage._format_order(order, exchange_manager)
+            order_storage_details[StoredOrdersAttr.ENTRIES.value] = ["11111"]
+
+            pending_groups = {}
+            created_order = await personal_data.create_order_from_order_storage_details(
+                order_storage_details, exchange_manager, pending_groups
+            )
+            assert pending_groups == {}
+
+            assert created_order.exchange_manager is exchange_manager
+            assert created_order.origin_quantity == order.origin_quantity
+            assert created_order.timestamp == order.timestamp
+            assert created_order.creation_time == order.creation_time
+            assert created_order.origin_price == order.origin_price
+            assert created_order.__class__ is order.__class__
+            # associated_entry_ids are added from order_storage_details but not in original order
+            assert created_order.associated_entry_ids == ["11111"]
+            assert order.associated_entry_ids is None
+
+            # updated creation_time (as with chained orders): creation_time is used to restore order
+            assert created_order.creation_time != 123
+            order.creation_time = 123
+
+            order_storage_details = orders_storage._format_order(order, exchange_manager)
+            created_order = await personal_data.create_order_from_order_storage_details(
+                order_storage_details, exchange_manager, pending_groups
+            )
+            assert pending_groups == {}
+            assert created_order.exchange_manager is exchange_manager
+            assert created_order.origin_quantity == order.origin_quantity
+            assert created_order.timestamp == 123   # aligned with creation time
+            assert created_order.creation_time == 123   # aligned with creation time
+            assert created_order.origin_price == order.origin_price
+            assert created_order.__class__ is order.__class__
+            # associated_entry_ids are added from order_storage_details but not in original order
+            assert created_order.associated_entry_ids is None
+            assert order.associated_entry_ids is None
+
+        finally:
+            await self.stop(exchange_manager)
     
     async def test_create_order_from_order_storage_details_with_groups(self):
         _, exchange_manager, trader_inst = await self.init_default()  

{OctoBot-Trading-2.4.66 → OctoBot-Trading-2.4.67}/tests/personal_data/orders/test_order_util.py

@@ -346,16 +346,25 @@ async def test_create_as_chained_order_regular_order(trader_simulator):
                       quantity=decimal.Decimal("10"),
                       price=decimal.Decimal("70"))
     base_order.is_waiting_for_chained_trigger = True
+    base_order.creation_time = 123
+    origin_time = base_order.creation_time
+    assert base_order.to_dict()[enums.ExchangeConstantsOrderColumns.TIMESTAMP.value] \
+           == origin_time
     # base_order.state is None since no state has been associated to it (not initiliazed)
     assert base_order.state is None
     assert base_order.is_initialized is False
 
     await personal_data.create_as_chained_order(base_order)
+    assert base_order.creation_time > origin_time   # creation_time got update using current time
     assert base_order.is_waiting_for_chained_trigger is False
     assert base_order.is_created() is True
     assert base_order.is_initialized is True
     assert isinstance(base_order.state, personal_data.OpenOrderState)
 
+    # use chained order creation time
+    assert base_order.to_dict()[enums.ExchangeConstantsOrderColumns.TIMESTAMP.value] \
+           == base_order.creation_time
+
 
 @pytest.mark.asyncio
 async def test_create_as_chained_order_bundled_order_no_open_order(trader_simulator):