OctoBot-Trading 2.4.77__tar.gz → 2.4.79__tar.gz

{OctoBot-Trading-2.4.77 → OctoBot-Trading-2.4.79}/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.79] - 2024-04-24
+### Updated
+- [Keywords] add ignored orders to amount keyword
+
+## [2.4.78] - 2024-04-15
+### Added
+- [Exchanges] key adapter
+### Updated
+- CCXT to 4.2.95
+
 ## [2.4.77] - 2024-04-13
 ### Added
 - [Exchanges] Handle inactive markets

{OctoBot-Trading-2.4.77 → OctoBot-Trading-2.4.79/OctoBot_Trading.egg-info}/PKG-INFO

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

@@ -4,7 +4,7 @@ Async-Channel<2.3,>=2.2
 OctoBot-Commons<1.10,>=1.9.43
 OctoBot-Tentacles-Manager<2.10,>=2.9
 trading-backend>=1.2.7
-ccxt==4.2.77
+ccxt==4.2.95
 cryptography
 sortedcontainers==2.4.0
 tinydb==4.5.2

{OctoBot-Trading-2.4.77/OctoBot_Trading.egg-info → OctoBot-Trading-2.4.79}/PKG-INFO

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

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

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

{OctoBot-Trading-2.4.77 → OctoBot-Trading-2.4.79}/octobot_trading/exchanges/connectors/ccxt/ccxt_client_util.py

@@ -27,9 +27,11 @@ import octobot_trading.exchanges.connectors.ccxt.ccxt_clients_cache as ccxt_clie
 import octobot_trading.exchanges.util.exchange_util as exchange_util
 
 
-def create_client(exchange_class, exchange_manager, logger,
-                  options, headers, additional_config, 
-                  should_authenticate, unauthenticated_exchange_fallback=None):
+def create_client(
+    exchange_class, exchange_manager, logger, options, headers,
+    additional_config, should_authenticate, unauthenticated_exchange_fallback=None,
+    keys_adapter=None
+):
     """
     Exchange instance creation
     :return: the created ccxt (pro, async or sync) client
@@ -43,6 +45,8 @@ def create_client(exchange_class, exchange_manager, logger,
     if exchange_manager.ignore_config or exchange_manager.check_config(exchange_manager.exchange_name):
         try:
             key, secret, password = exchange_manager.get_exchange_credentials(exchange_manager.exchange_name)
+            if keys_adapter:
+                key, secret, password = keys_adapter(key, secret, password)
             if not (key and secret) and not exchange_manager.is_simulated and not exchange_manager.ignore_config:
                 logger.warning(f"No exchange API key set for {exchange_manager.exchange_name}. "
                                f"Enter your account details to enable real trading on this exchange.")

{OctoBot-Trading-2.4.77 → OctoBot-Trading-2.4.79}/octobot_trading/exchanges/connectors/ccxt/ccxt_connector.py

@@ -204,11 +204,12 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
     def _create_client(self, force_unauth=False):
         self.client, self.is_authenticated = self._client_factory(force_unauth)
 
-    def _client_factory(self, force_unauth) -> tuple:
+    def _client_factory(self, force_unauth, keys_adapter=None) -> tuple:
         return ccxt_client_util.create_client(
             self.exchange_type, self.exchange_manager, self.logger,
             self.options, self.headers, self.additional_config,
-            False if force_unauth else self._should_authenticate(), self.unauthenticated_exchange_fallback
+            False if force_unauth else self._should_authenticate(), self.unauthenticated_exchange_fallback,
+            keys_adapter=keys_adapter
         )
 
     def _should_authenticate(self):
@@ -218,7 +219,9 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
         )
 
     def unauthenticated_exchange_fallback(self, err):
-        self.handle_token_error(err)
+        if not self.exchange_manager.exchange_only:
+            # don't log error when auth is probably not necessary
+            self.handle_token_error(err)
         return ccxt_client_util.get_unauthenticated_exchange(
             self.exchange_type,
             self.options, self.headers, self.additional_config

{OctoBot-Trading-2.4.77 → OctoBot-Trading-2.4.79}/octobot_trading/modes/script_keywords/basic_keywords/account_balance.py

@@ -49,8 +49,10 @@ async def total_account_balance(context, side=trading_enums.PositionSide.BOTH.va
                               f"the reference market. reference market: {reference_market}, symbol: {context.symbol}")
 
 
-async def available_account_balance(context, side=trading_enums.TradeOrderSide.BUY.value, use_total_holding=False,
-                                    is_stop_order=False, reduce_only=True, target_price=None):
+async def available_account_balance(
+    context, side=trading_enums.TradeOrderSide.BUY.value, use_total_holding=False,
+    is_stop_order=False, reduce_only=True, target_price=None, orders_to_be_ignored=None
+):
     portfolio_type = commons_constants.PORTFOLIO_TOTAL if use_total_holding else commons_constants.PORTFOLIO_AVAILABLE
     current_symbol_holding, _, market_quantity, price, _ = \
         await trading_personal_data.get_pre_order_data(context.exchange_manager,
@@ -67,6 +69,21 @@ async def available_account_balance(context, side=trading_enums.TradeOrderSide.B
     already_locked_amount = trading_constants.ZERO
     if use_total_holding and is_stop_order:
         already_locked_amount = _get_locked_amount_in_stop_orders(context, side)
+    if orders_to_be_ignored:
+        for order_to_be_ignored in orders_to_be_ignored:
+            if order_to_be_ignored.side == trading_enums.TradeOrderSide.BUY:
+                market_quantity += order_to_be_ignored.origin_quantity
+            else:
+                current_symbol_holding += order_to_be_ignored.origin_quantity
+        total_symbol_holding, _, total_market_quantity, _, _ = \
+            await trading_personal_data.get_pre_order_data(context.exchange_manager,
+                                                           symbol=context.symbol,
+                                                           timeout=trading_constants.ORDER_DATA_FETCHING_TIMEOUT,
+                                                           portfolio_type=commons_constants.PORTFOLIO_TOTAL,
+                                                           target_price=target_price)
+        # ensure not using more than total amounts
+        current_symbol_holding = min(current_symbol_holding, total_symbol_holding)
+        market_quantity = min(market_quantity, total_market_quantity)
     return (market_quantity if side == trading_enums.TradeOrderSide.BUY.value else current_symbol_holding) \
         - already_locked_amount
 
@@ -80,11 +97,14 @@ def _get_locked_amount_in_stop_orders(context, side):
     return locked_amount
 
 
-async def adapt_amount_to_holdings(context, amount, side, use_total_holding, reduce_only,
-                                   is_stop_order, target_price=None):
-    available_acc_bal = await available_account_balance(context, side, use_total_holding=use_total_holding,
-                                                        is_stop_order=is_stop_order, reduce_only=reduce_only,
-                                                        target_price=target_price)
+async def adapt_amount_to_holdings(
+    context, amount, side, use_total_holding, reduce_only,
+    is_stop_order, target_price=None, orders_to_be_ignored=None
+):
+    available_acc_bal = await available_account_balance(
+        context, side, use_total_holding=use_total_holding, is_stop_order=is_stop_order,
+        reduce_only=reduce_only, target_price=target_price, orders_to_be_ignored=orders_to_be_ignored
+    )
     if available_acc_bal > amount:
         return amount
     else:

{OctoBot-Trading-2.4.77 → OctoBot-Trading-2.4.79}/octobot_trading/modes/script_keywords/basic_keywords/amount.py

@@ -13,7 +13,6 @@
 #
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
-
 import octobot_commons.symbols as commons_symbols
 import octobot_trading.modes.script_keywords.dsl as dsl
 import octobot_trading.modes.script_keywords.basic_keywords.account_balance as account_balance
@@ -32,6 +31,7 @@ async def get_amount_from_input_amount(
     use_total_holding=False,
     target_price=None,
     allow_holdings_adaptation=True,
+    orders_to_be_ignored=None,
 ):
     amount_type, amount_value = dsl.parse_quantity(input_amount)
 
@@ -81,7 +81,8 @@ async def get_amount_from_input_amount(
     else:
         raise trading_errors.InvalidArgumentError(f"Unsupported input: {input_amount} make sure to use a supported syntax for amount")
     adapted_amount = await account_balance.adapt_amount_to_holdings(
-        context, amount_value, side, use_total_holding, reduce_only, is_stop_order, target_price=target_price
+        context, amount_value, side, use_total_holding, reduce_only, is_stop_order,
+        target_price=target_price, orders_to_be_ignored=orders_to_be_ignored
     )
     if adapted_amount < amount_value and not allow_holdings_adaptation:
         raise trading_errors.MissingFunds(

{OctoBot-Trading-2.4.77 → OctoBot-Trading-2.4.79}/octobot_trading/personal_data/orders/order.py

@@ -546,16 +546,19 @@ class Order(util.Initializable):
         is_from_exchange = False
         price = self.origin_price if use_origin_quantity_and_price else self.filled_price
         quantity = self.origin_quantity if use_origin_quantity_and_price else self.filled_quantity
+        # consider worse case taker fees when using use_origin_quantity_and_price as the order is not filled yet
+        taker_or_maker = enums.ExchangeConstantsOrderColumns.TAKER.value \
+            if use_origin_quantity_and_price else self.taker_or_maker
         if self.fees_currency_side is enums.FeesCurrencySide.UNDEFINED:
             computed_fee = self.exchange_manager.exchange.get_trade_fee(
-                self.symbol, self.order_type, quantity, price, self.taker_or_maker
+                self.symbol, self.order_type, quantity, price, taker_or_maker
             )
             value = computed_fee[enums.FeePropertyColumns.COST.value]
             currency = computed_fee[enums.FeePropertyColumns.CURRENCY.value]
             is_from_exchange = computed_fee[enums.FeePropertyColumns.IS_FROM_EXCHANGE.value]
         else:
             symbol_fees = self.exchange_manager.exchange.get_fees(self.symbol)
-            fees = decimal.Decimal(f"{symbol_fees[self.taker_or_maker]}")
+            fees = decimal.Decimal(f"{symbol_fees[taker_or_maker]}")
             if self.fees_currency_side is enums.FeesCurrencySide.CURRENCY:
                 value = quantity / price * fees
                 currency = self.currency

{OctoBot-Trading-2.4.77 → OctoBot-Trading-2.4.79}/octobot_trading/personal_data/portfolios/types/spot_portfolio.py

@@ -31,6 +31,9 @@ class SpotPortfolio(portfolio_class.Portfolio):
         """
         base_fees = order.get_total_fees(order.currency)
         quote_fees = order.get_total_fees(order.market)
+        forecasted_fees = order.get_computed_fee(use_origin_quantity_and_price=True)
+        forecasted_base_fees = order_util.get_fees_for_currency(forecasted_fees, order.currency)
+        forecasted_quote_fees = order_util.get_fees_for_currency(forecasted_fees, order.market)
 
         # update base
         if order.side == enums.TradeOrderSide.BUY:
@@ -38,12 +41,16 @@ class SpotPortfolio(portfolio_class.Portfolio):
             self._update_portfolio_data(order.currency, total_value=new_quantity, available_value=new_quantity)
         else:
             new_quantity = -order.filled_quantity - base_fees
-            self._update_portfolio_data(order.currency, total_value=new_quantity)
+            # Align available amount using really paid fees. Does nothing if forecasted fees == real fees
+            available_update = forecasted_base_fees - base_fees
+            self._update_portfolio_data(order.currency, total_value=new_quantity, available_value=available_update)
 
         # update quote
         if order.side == enums.TradeOrderSide.BUY:
             new_quantity = -(order.filled_quantity * order.filled_price) - quote_fees
-            self._update_portfolio_data(order.market, total_value=new_quantity)
+            # Align available amount using really paid fees. Does nothing if forecasted fees == real fees
+            available_update = forecasted_quote_fees - quote_fees
+            self._update_portfolio_data(order.market, total_value=new_quantity, available_value=available_update)
         else:
             new_quantity = (order.filled_quantity * order.filled_price) - quote_fees
             self._update_portfolio_data(order.market, total_value=new_quantity, available_value=new_quantity)

{OctoBot-Trading-2.4.77 → OctoBot-Trading-2.4.79}/octobot_trading/util/test_tools/exchanges_test_tools.py

@@ -124,13 +124,13 @@ async def ensure_symbol_markets(
         await exchange_manager.exchange.connector.load_symbol_markets(reload=reload, market_filter=market_filter)
 
 
-async def get_portfolio(exchange_manager, as_float=False) -> dict:
+async def get_portfolio(exchange_manager, as_float=False, clear_empty=True) -> dict:
     balance = await exchange_manager.exchange.get_balance()
     # filter out 0 values
     return {
         asset: {key: float(val) if as_float else val for key, val in values.items()}  # use float for values
         for asset, values in balance.items()
-        if any(value for value in values.values())
+        if not clear_empty or (clear_empty and any(value for value in values.values()))
     }
 
 

{OctoBot-Trading-2.4.77 → OctoBot-Trading-2.4.79}/requirements.txt

@@ -8,7 +8,8 @@ OctoBot-Tentacles-Manager>=2.9, <2.10
 trading-backend>=1.2.7
 
 # Exchange connection requirements
-ccxt==4.2.77 # always ensure real exchanges tests (in tests_additional and authenticated exchange tests) are passing before changing the ccxt version
+# issue from 96, need ccxt==4.2.99
+ccxt==4.2.95 # always ensure real exchanges tests (in tests_additional and authenticated exchange tests) are passing before changing the ccxt version
 
 cryptography # Never specify a version (managed by https://github.com/Drakkar-Software/OctoBot-PyPi-Linux-Deployer)
 

{OctoBot-Trading-2.4.77 → OctoBot-Trading-2.4.79}/tests/exchanges/traders/test_trader.py

@@ -567,8 +567,9 @@ class TestTrader:
         with patch.object(ccxt.async_support.binanceus, "calculate_fee",
                           Mock(return_value=get_fees_mock("SOL"))) as calculate_fee_mock:
             await limit_buy.on_fill(force_fill=True)
-            # ensure call ccxt calculate_fee for order fees
-            calculate_fee_mock.assert_called_once()
+            # called twice: once for filled order fee calculation, once for forecasted fees calculation used to restore
+            # available amounts if relevant
+            assert calculate_fee_mock.call_count == 2
 
         # added filled orders as filled trades
         assert len(trades_manager.trades) == 1
@@ -611,7 +612,9 @@ class TestTrader:
         with patch.object(ccxt.async_support.binanceus, "calculate_fee", Mock(return_value=get_fees_mock("SOL"))) \
                 as calculate_fee_mock:
             await limit_buy.on_fill(force_fill=True)
-            calculate_fee_mock.assert_called_once()
+            # called twice: once for filled order fee calculation, once for forecasted fees calculation used to restore
+            # available amounts if relevant
+            assert calculate_fee_mock.call_count == 2
 
         assert limit_buy not in orders_manager.get_open_orders()
 

{OctoBot-Trading-2.4.77 → OctoBot-Trading-2.4.79}/tests/modes/script_keywords/basic_keywords/test_account_balance.py

@@ -47,8 +47,17 @@ async def test_total_account_balance(mock_context):
 async def test_available_account_balance(mock_context):
     current_symbol_holding = decimal.Decimal("100")
     market_quantity = decimal.Decimal("50")
-    ret_val = (current_symbol_holding, "current_market_holding", market_quantity, "current_price", "symbol_market")
-    with mock.patch.object(trading_personal_data, "get_pre_order_data", mock.AsyncMock(return_value=ret_val)) \
+
+    async def _get_pre_order_data(
+        exchange_manager, symbol: str, timeout: int = None,
+        portfolio_type=commons_constants.PORTFOLIO_AVAILABLE,
+        target_price=None
+    ):
+        if portfolio_type == commons_constants.PORTFOLIO_AVAILABLE:
+            return current_symbol_holding, "current_market_holding", market_quantity, "current_price", "symbol_market"
+        return current_symbol_holding*2, "current_market_holding", market_quantity*2, "current_price", "symbol_market"
+
+    with mock.patch.object(trading_personal_data, "get_pre_order_data", mock.AsyncMock(side_effect=_get_pre_order_data)) \
             as get_pre_order_data_mock, \
             mock.patch.object(account_balance, "_get_locked_amount_in_stop_orders",
                               mock.Mock(return_value=trading_constants.ONE)) as _get_locked_amount_in_stop_orders_mock:
@@ -62,7 +71,7 @@ async def test_available_account_balance(mock_context):
                                                         target_price=trading_constants.ZERO)
         get_pre_order_data_mock.reset_mock()
         _get_locked_amount_in_stop_orders_mock.assert_not_called()
-        assert current_symbol_holding == await script_keywords.available_account_balance(
+        assert current_symbol_holding * 2 == await script_keywords.available_account_balance(
             mock_context, side=trading_enums.TradeOrderSide.SELL.value, use_total_holding=True)
         get_pre_order_data_mock.assert_called_once_with(mock_context.exchange_manager, symbol=mock_context.symbol,
                                                         timeout=trading_constants.ORDER_DATA_FETCHING_TIMEOUT,
@@ -70,7 +79,7 @@ async def test_available_account_balance(mock_context):
                                                         target_price=None)
         get_pre_order_data_mock.reset_mock()
         _get_locked_amount_in_stop_orders_mock.assert_not_called()
-        assert current_symbol_holding - trading_constants.ONE == await script_keywords.available_account_balance(
+        assert current_symbol_holding * 2 - trading_constants.ONE == await script_keywords.available_account_balance(
             mock_context, side=trading_enums.TradeOrderSide.SELL.value, use_total_holding=True, is_stop_order=True)
         get_pre_order_data_mock.assert_called_once_with(mock_context.exchange_manager, symbol=mock_context.symbol,
                                                         timeout=trading_constants.ORDER_DATA_FETCHING_TIMEOUT,
@@ -80,7 +89,7 @@ async def test_available_account_balance(mock_context):
                                                                        trading_enums.TradeOrderSide.SELL.value)
         get_pre_order_data_mock.reset_mock()
         _get_locked_amount_in_stop_orders_mock.reset_mock()
-        assert market_quantity - trading_constants.ONE == await script_keywords.available_account_balance(
+        assert market_quantity * 2 - trading_constants.ONE == await script_keywords.available_account_balance(
             mock_context, side=trading_enums.TradeOrderSide.BUY.value, use_total_holding=True, is_stop_order=True)
         get_pre_order_data_mock.assert_called_once_with(mock_context.exchange_manager, symbol=mock_context.symbol,
                                                         timeout=trading_constants.ORDER_DATA_FETCHING_TIMEOUT,
@@ -91,6 +100,25 @@ async def test_available_account_balance(mock_context):
         get_pre_order_data_mock.reset_mock()
         _get_locked_amount_in_stop_orders_mock.reset_mock()
 
+        buy_1 = trading_personal_data.BuyLimitOrder(mock_context.trader)
+        buy_1.origin_quantity = decimal.Decimal("10")
+        buy_1.origin_price = decimal.Decimal("100")
+        buy_2 = trading_personal_data.BuyLimitOrder(mock_context.trader)
+        buy_2.origin_quantity = decimal.Decimal("3")
+        buy_2.origin_price = decimal.Decimal("40")
+        sell_1 = trading_personal_data.SellLimitOrder(mock_context.trader)
+        sell_1.origin_quantity = decimal.Decimal("2.21")
+        sell_1.origin_price = decimal.Decimal("200")
+        assert market_quantity + buy_1.origin_quantity + buy_2.origin_quantity == \
+           await script_keywords.available_account_balance(
+                mock_context, side=trading_enums.TradeOrderSide.BUY.value, use_total_holding=False, is_stop_order=False,
+                orders_to_be_ignored=[buy_1, buy_2, sell_1]
+            )
+        assert get_pre_order_data_mock.call_count == 2
+        _get_locked_amount_in_stop_orders_mock.assert_not_called()
+        get_pre_order_data_mock.reset_mock()
+        _get_locked_amount_in_stop_orders_mock.reset_mock()
+
 
 async def test_adapt_amount_to_holdings(null_context):
     with mock.patch.object(account_balance, "available_account_balance",
@@ -106,18 +134,21 @@ async def test_adapt_amount_to_holdings(null_context):
         available_account_balance_mock.assert_called_once_with(null_context, trading_enums.TradeOrderSide.SELL,
                                                                use_total_holding=False, is_stop_order="is_stop_order",
                                                                reduce_only="reduce_only",
-                                                               target_price=trading_constants.ONE_HUNDRED)
+                                                               target_price=trading_constants.ONE_HUNDRED,
+                                                               orders_to_be_ignored=None)
         available_account_balance_mock.reset_mock()
         assert await script_keywords.adapt_amount_to_holdings(null_context,
                                                               decimal.Decimal(1),
                                                               trading_enums.TradeOrderSide.SELL,
                                                               True,
                                                               "reduce_only",
-                                                              "is_stop_order") == decimal.Decimal(1)
+                                                              "is_stop_order",
+                                                              orders_to_be_ignored=["plop"]) == decimal.Decimal(1)
         available_account_balance_mock.assert_called_once_with(null_context, trading_enums.TradeOrderSide.SELL,
                                                                use_total_holding=True, is_stop_order="is_stop_order",
                                                                reduce_only="reduce_only",
-                                                               target_price=None)
+                                                               target_price=None,
+                                                               orders_to_be_ignored=["plop"])
         assert await script_keywords.adapt_amount_to_holdings(null_context,
                                                               decimal.Decimal(2),
                                                               trading_enums.TradeOrderSide.SELL,

{OctoBot-Trading-2.4.77 → OctoBot-Trading-2.4.79}/tests/modes/script_keywords/basic_keywords/test_amount.py

@@ -59,7 +59,8 @@ async def test_get_amount_from_input_amount(null_context):
                 assert await script_keywords.get_amount_from_input_amount(null_context, "1", "buy") \
                        == decimal.Decimal(1)
                 adapt_amount_to_holdings_mock.assert_called_once_with(null_context, decimal.Decimal(2), "buy",
-                                                                      False, True, False, target_price=None)
+                                                                      False, True, False, target_price=None,
+                                                                      orders_to_be_ignored=None)
                 parse_quantity_mock.assert_called_once_with("1")
                 parse_quantity_mock.reset_mock()
                 adapt_amount_to_holdings_mock.reset_mock()
@@ -67,10 +68,11 @@ async def test_get_amount_from_input_amount(null_context):
                 with pytest.raises(errors.MissingFunds):
                     # raises as 1 != 2
                     await script_keywords.get_amount_from_input_amount(
-                        null_context, "1", "buy", allow_holdings_adaptation=False
+                        null_context, "1", "buy", allow_holdings_adaptation=False, orders_to_be_ignored=[]
                     )
                 adapt_amount_to_holdings_mock.assert_called_once_with(null_context, decimal.Decimal(2), "buy",
-                                                                      False, True, False, target_price=None)
+                                                                      False, True, False, target_price=None,
+                                                                      orders_to_be_ignored=[])
                 parse_quantity_mock.assert_called_once_with("1")
                 adapt_amount_to_holdings_mock.reset_mock()
 
@@ -80,10 +82,12 @@ async def test_get_amount_from_input_amount(null_context):
                 for allow_holdings_adaptation in (True, False):
                     # doesn't raise as 1 == 1
                     assert await script_keywords.get_amount_from_input_amount(
-                        null_context, "1", "buy", allow_holdings_adaptation=allow_holdings_adaptation
+                        null_context, "1", "buy", allow_holdings_adaptation=allow_holdings_adaptation,
+                        orders_to_be_ignored=["plip"]
                     ) == decimal.Decimal(1)
                     adapt_amount_to_holdings_mock.assert_called_once_with(null_context, decimal.Decimal(1), "buy",
-                                                                          False, True, False, target_price=None)
+                                                                          False, True, False, target_price=None,
+                                                                          orders_to_be_ignored=["plip"])
                     parse_quantity_mock.assert_called_once_with("1")
                     parse_quantity_mock.reset_mock()
                     adapt_amount_to_holdings_mock.reset_mock()
@@ -97,7 +101,8 @@ async def test_get_amount_from_input_amount(null_context):
                         null_context, "1", "buy", allow_holdings_adaptation=allow_holdings_adaptation
                     ) == decimal.Decimal(1)
                     adapt_amount_to_holdings_mock.assert_called_once_with(null_context, decimal.Decimal("0.5"), "buy",
-                                                                          False, True, False, target_price=None)
+                                                                          False, True, False, target_price=None,
+                                                                          orders_to_be_ignored=None)
                     parse_quantity_mock.assert_called_once_with("1")
                     parse_quantity_mock.reset_mock()
                     adapt_amount_to_holdings_mock.reset_mock()
@@ -117,7 +122,7 @@ async def test_get_amount_from_input_amount(null_context):
                 # without target_price
                 adapt_amount_to_holdings_mock.assert_called_once_with(
                     null_context, decimal.Decimal(2) / decimal.Decimal(100), "buy",
-                    False, True, False, target_price=None
+                    False, True, False, target_price=None, orders_to_be_ignored=None
                 )
                 parse_quantity_mock.assert_called_once_with("1")
                 adapt_amount_to_holdings_mock.reset_mock()
@@ -130,7 +135,7 @@ async def test_get_amount_from_input_amount(null_context):
                 get_up_to_date_price_mock.assert_not_called()
                 adapt_amount_to_holdings_mock.assert_called_once_with(
                     null_context, decimal.Decimal(2) / decimal.Decimal(23), "buy",
-                    False, True, False, target_price=decimal.Decimal(23)
+                    False, True, False, target_price=decimal.Decimal(23), orders_to_be_ignored=None
                 )
                 parse_quantity_mock.assert_called_once_with("1")
                 adapt_amount_to_holdings_mock.reset_mock()
@@ -142,7 +147,8 @@ async def test_get_amount_from_input_amount(null_context):
                         null_context, "1", "buy",  target_price=decimal.Decimal("0.5"), allow_holdings_adaptation=False
                     )
                 adapt_amount_to_holdings_mock.assert_called_once_with(
-                    null_context, decimal.Decimal(4), "buy", False, True, False, target_price=decimal.Decimal("0.5")
+                    null_context, decimal.Decimal(4), "buy", False, True, False, target_price=decimal.Decimal("0.5"),
+                    orders_to_be_ignored=None
                 )
                 parse_quantity_mock.assert_called_once_with("1")
                 adapt_amount_to_holdings_mock.reset_mock()
@@ -158,7 +164,8 @@ async def test_get_amount_from_input_amount(null_context):
                                                                       is_stop_order=True,
                                                                       target_price=constants.ZERO) == decimal.Decimal(1)
             adapt_amount_to_holdings_mock.assert_called_once_with(null_context, decimal.Decimal("1.5"), "buy",
-                                                                  True, False, True, target_price=constants.ZERO)
+                                                                  True, False, True, target_price=constants.ZERO,
+                                                                  orders_to_be_ignored=None)
             parse_quantity_mock.assert_called_once_with("50")
             available_account_balance_mock.assert_called_once_with(null_context, "buy",
                                                                    use_total_holding=True, reduce_only=False)
@@ -173,7 +180,8 @@ async def test_get_amount_from_input_amount(null_context):
                 as available_account_balance_mock:
             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("1.5"), "buy",
-                                                                  False, True, False, target_price=None)
+                                                                  False, True, False, target_price=None,
+                                                                  orders_to_be_ignored=None)
             parse_quantity_mock.assert_called_once_with("50")
             available_account_balance_mock.assert_called_once_with(null_context, "buy",
                                                                    use_total_holding=False, reduce_only=True)
@@ -196,7 +204,8 @@ async def test_get_amount_from_input_amount(null_context):
 
             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("1.5"), "buy",
-                                                                  False, True, False, target_price=None)
+                                                                  False, True, False, target_price=None,
+                                                                  orders_to_be_ignored=None)
             parse_quantity_mock.assert_called_once_with("50")
             get_holdings_value_mock.assert_called_once_with(("BTC", "USDT"), "BTC")
             adapt_amount_to_holdings_mock.reset_mock()
@@ -229,7 +238,8 @@ async def test_get_amount_from_input_amount(null_context):
 
             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)
+                                                                  False, True, False, target_price=None,
+                                                                  orders_to_be_ignored=None)
             parse_quantity_mock.assert_called_once_with("50")
             get_holdings_value_mock.assert_called_once_with({'BTC', 'ETH', 'SOL', 'USDT'}, "BTC")
             adapt_amount_to_holdings_mock.reset_mock()