OctoBot-Trading 2.4.185__tar.gz → 2.4.187__tar.gz

{OctoBot-Trading-2.4.185 → OctoBot-Trading-2.4.187}/CHANGELOG.md

@@ -4,6 +4,15 @@ 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.187] - 2025-06-08
+### Updated
+[Exchanges] make fees more flexible
+
+## [2.4.186] - 2025-06-05
+### Updated
+[Orders] add ensure_orders_limit
+[Exchange] add get_max_orders_count
+
 ## [2.4.185] - 2025-06-04
 ### Updated
 [Exchanges] add supports_api_leverage_update

{OctoBot-Trading-2.4.185 → OctoBot-Trading-2.4.187/OctoBot_Trading.egg-info}/PKG-INFO

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

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

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

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

{OctoBot-Trading-2.4.185 → OctoBot-Trading-2.4.187}/octobot_trading/constants.py

@@ -46,6 +46,8 @@ CHAINED_ORDERS_OUTDATED_PRICE_ALLOWANCE = decimal.Decimal("0.005")  # allows 0.5
 # create instantly filled limit orders 0.5% beyond market
 INSTANT_FILLED_LIMIT_ORDER_PRICE_DELTA = decimal.Decimal("0.005")
 CREATED_ORDER_FORCED_UPDATE_PERIOD = 5
+DEFAULT_MAX_DEFAULT_ORDERS_COUNT = 50
+DEFAULT_MAX_STOP_ORDERS_COUNT = 5
 
 # Portfolio
 MAX_PORTFOLIO_SYNC_ATTEMPTS = 1

{OctoBot-Trading-2.4.185 → OctoBot-Trading-2.4.187}/octobot_trading/enums.py

@@ -399,6 +399,13 @@ class ExchangeConstantsMarketPropertyColumns(enum.Enum):
     TAKER = "taker"  # trading
     MAKER = "maker"  # trading
     FEE = "fee"  # withdraw
+    FEE_SIDE = "feeSide"  # pay fees in the currency you give or get
+
+
+class ExchangeFeeSides(enum.Enum):
+    GET = "get"  # the fee is always in the currency you get
+    GIVE = "give"  # the fee is always in the currency you give
+    QUOTE = "quote"  # the fee is always in quote currency
 
 
 class ExchangeConstantsLeveragePropertyColumns(enum.Enum):

{OctoBot-Trading-2.4.185 → OctoBot-Trading-2.4.187}/octobot_trading/errors.py

@@ -63,6 +63,12 @@ class UntradableSymbolError(OrderCreationError):
     """
 
 
+class MaxOpenOrderReachedForSymbolError(OrderCreationError):
+    """
+    Raised when an order can't be created because the maximum amount of orders of this time has been reached
+    """
+
+
 class OrderEditError(OctoBotExchangeError):
     """
     Raised upon a failed order edition
@@ -348,3 +354,9 @@ class ExhaustedTrailingProfileError(Exception):
     """
     Raised when a trailing profile has no new price to produce anymore
     """
+
+
+class MissingFeeDetailsError(Exception):
+    """
+    Raised when fee info are not available
+    """

{OctoBot-Trading-2.4.185 → OctoBot-Trading-2.4.187}/octobot_trading/exchanges/connectors/ccxt/ccxt_connector.py

@@ -599,8 +599,8 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
 
     def _add_stop_loss_price_param(self, params: dict, price: float):
         params = params or {}
-        if ccxt_enums.ExchangeOrderCCXTUnifiedParams.STOP_LOSS_PRICE.value not in params:
-            params[ccxt_enums.ExchangeOrderCCXTUnifiedParams.STOP_LOSS_PRICE.value] = price
+        if self.exchange_manager.exchange.STOP_LOSS_CREATE_PRICE_PARAM not in params:
+            params[self.exchange_manager.exchange.STOP_LOSS_CREATE_PRICE_PARAM] = price
         return params
 
     def _add_edit_stop_loss_price_param(self, params: dict, price: float):
@@ -889,19 +889,7 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
         raise RuntimeError(f"Unknown order type: {order_type}")
 
     def get_trade_fee(self, symbol: str, order_type: enums.TraderOrderType, quantity, price, taker_or_maker):
-        limit_or_market_order_type = (
-            enums.TradeOrderType.MARKET
-            if taker_or_maker == enums.ExchangeConstantsMarketPropertyColumns.TAKER.value
-            else enums.TradeOrderType.LIMIT
-        )
-        fees = self.client.calculate_fee(
-            symbol=symbol,
-            type=limit_or_market_order_type.value,
-            side=exchanges.get_order_side(order_type),
-            amount=float(quantity),
-            price=float(price),
-            takerOrMaker=taker_or_maker
-        )
+        fees = self.calculate_fees(symbol, order_type, quantity, price, taker_or_maker)
         fees[enums.FeePropertyColumns.IS_FROM_EXCHANGE.value] = False
         fees[enums.FeePropertyColumns.COST.value] = decimal.Decimal(
             str(fees.get(enums.FeePropertyColumns.COST.value) or 0)
@@ -920,6 +908,24 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
                 fees[enums.FeePropertyColumns.CURRENCY.value] = parsed_symbol.quote
         return fees
 
+    def calculate_fees(
+        self, symbol: str, order_type: enums.TraderOrderType,
+        quantity: decimal.Decimal, price: decimal.Decimal, taker_or_maker: str
+    ):
+        limit_or_market_order_type = (
+            enums.TradeOrderType.MARKET
+            if taker_or_maker == enums.ExchangeConstantsMarketPropertyColumns.TAKER.value
+            else enums.TradeOrderType.LIMIT
+        )
+        return self.client.calculate_fee(
+            symbol=symbol,
+            type=limit_or_market_order_type.value,
+            side=exchanges.get_order_side(order_type),
+            amount=float(quantity),
+            price=float(price),
+            takerOrMaker=taker_or_maker
+        )
+
     def get_fees(self, symbol):
         try:
             return ccxt_client_util.get_fees(self.client.market(symbol))

{OctoBot-Trading-2.4.185 → OctoBot-Trading-2.4.187}/octobot_trading/exchanges/connectors/simulator/ccxt_client_simulation.py

@@ -18,9 +18,12 @@ import decimal
 import octobot_trading.exchanges.connectors.ccxt.ccxt_client_util as ccxt_client_util
 
 
-def parse_markets(exchange_name, market_filter) -> dict:
+def parse_markets(exchange_name: str, additional_client_config: dict, market_filter) -> dict:
     exchange_class = ccxt_client_util.ccxt_exchange_class_factory(exchange_name)
-    config = ccxt_client_util.get_custom_domain_config(exchange_class)
+    config = {
+        **additional_client_config,
+        **ccxt_client_util.get_custom_domain_config(exchange_class)
+    }
     client = exchange_class(config)
     ccxt_client_util.load_markets_from_cache(client, market_filter)
     return client.markets

{OctoBot-Trading-2.4.185 → OctoBot-Trading-2.4.187}/octobot_trading/exchanges/connectors/simulator/exchange_simulator_connector.py

@@ -66,17 +66,18 @@ class ExchangeSimulatorConnector(abstract_exchange.AbstractExchange):
 
         # init _forced_market_statuses when allowed
         if self.exchange_manager.use_cached_markets:
-            self._init_forced_market_statuses()
+            additional_client_config = await self._get_additional_client_config()
+            self._init_forced_market_statuses(additional_client_config)
 
     def get_adapter_class(self, adapter_class):
         return adapter_class or exchange_simulator_adapter.ExchangeSimulatorAdapter
 
-    def _init_forced_market_statuses(self):
+    def _init_forced_market_statuses(self, additional_client_config):
         def market_filter(market):
             return market[enums.ExchangeConstantsMarketStatusColumns.SYMBOL.value] in self.symbols
 
         self._forced_market_statuses = ccxt_client_simulation.parse_markets(
-            self._get_exchange_class_rest_name(), market_filter
+            self._get_exchange_class_rest_name(), additional_client_config, market_filter
         )
 
     def _get_exchange_class_rest_name(self):
@@ -84,6 +85,21 @@ class ExchangeSimulatorConnector(abstract_exchange.AbstractExchange):
             return self.exchange_manager.exchange.exchange_tentacle_class.get_rest_name(self.exchange_manager)
         return self.exchange_manager.exchange_class_string
 
+    async def _get_additional_client_config(self) -> dict:
+        if (
+            self.exchange_manager.exchange.exchange_tentacle_class
+            and self.exchange_manager.exchange.exchange_tentacle_class.HAS_FETCHED_DETAILS
+        ):
+            await self.exchange_manager.exchange.exchange_tentacle_class.fetch_exchange_config(
+                self.exchange_manager.exchange.exchange_config_by_exchange, self.exchange_manager
+            )
+            return self.exchange_manager.exchange.exchange_tentacle_class.get_custom_url_config(
+                self.exchange_manager.exchange.exchange_config_by_exchange.get(
+                    self.exchange_manager.exchange.exchange_tentacle_class.__name__, {}
+                ), self.exchange_manager.exchange_name
+            )
+        return {}
+
     def should_adapt_market_statuses(self) -> bool:
         return self.exchange_manager.use_cached_markets
 
@@ -242,6 +258,17 @@ class ExchangeSimulatorConnector(abstract_exchange.AbstractExchange):
     #     'is_from_exchange': False, // simulated fees
     # }
     def get_trade_fee(self, symbol: str, order_type: enums.TraderOrderType, quantity, price, taker_or_maker):
+        fees = self.calculate_fees(symbol, order_type, quantity, price, taker_or_maker)
+        fees[enums.FeePropertyColumns.IS_FROM_EXCHANGE.value] = False
+        fees[enums.FeePropertyColumns.COST.value] = decimal.Decimal(
+            str(fees.get(enums.FeePropertyColumns.COST.value) or 0)
+        )
+        return fees
+
+    def calculate_fees(
+        self, symbol: str, order_type: enums.TraderOrderType,
+        quantity: decimal.Decimal, price: decimal.Decimal, taker_or_maker: str
+    ):
         if not taker_or_maker:
             taker_or_maker = enums.ExchangeConstantsMarketPropertyColumns.TAKER.value
         base, quote = symbol_util.parse_symbol(symbol).base_and_quote()
@@ -258,7 +285,6 @@ class ExchangeSimulatorConnector(abstract_exchange.AbstractExchange):
             enums.FeePropertyColumns.CURRENCY.value: fee_currency,
             enums.FeePropertyColumns.RATE.value: rate,
             enums.FeePropertyColumns.COST.value: cost,
-            enums.FeePropertyColumns.IS_FROM_EXCHANGE.value: False,
         }
 
     def _get_fees_currency(self, base, quote, order_type: enums.TraderOrderType):
@@ -266,6 +292,11 @@ class ExchangeSimulatorConnector(abstract_exchange.AbstractExchange):
             return quote
         return base
 
+    @classmethod
+    def register_simulator_connector_fee_methods(cls, exchange_name: str, simulator_connector):
+        # override when using custom fees in backtesting is necessary
+        pass
+
     def get_time_frames(self, importer):
         return time_frame_manager.sort_time_frames(list(set(backtesting_api.get_available_time_frames(importer)) &
                                                         set(self.exchange_manager.exchange_config.available_time_frames)),

{OctoBot-Trading-2.4.185 → OctoBot-Trading-2.4.187}/octobot_trading/exchanges/exchange_factory.py

@@ -29,7 +29,7 @@ async def create_exchanges(exchange_manager, exchange_config_by_exchange: typing
 
     if exchange_manager.is_backtesting:
         # simulated : create exchange simulator instance
-        await create_simulated_exchange(exchange_manager)
+        await create_simulated_exchange(exchange_manager, exchange_config_by_exchange)
         exchange_manager.load_constants()
     else:
         # real : create a rest or websocket exchange instance
@@ -139,9 +139,10 @@ async def _create_rest_exchange(
         raise Exception(f"Can't create an exchange instance that match the exchange configuration ({exchange_manager})")
 
 
-async def create_simulated_exchange(exchange_manager):
+async def create_simulated_exchange(exchange_manager, exchange_config_by_exchange: typing.Optional[dict[str, dict]]):
     exchange_manager.exchange = exchanges.ExchangeSimulator(
-        exchange_manager.config, exchange_manager, exchange_manager.backtesting
+        exchange_manager.config, exchange_manager, exchange_manager.backtesting,
+        exchange_config_by_exchange=exchange_config_by_exchange
     )
 
     await exchange_manager.exchange.initialize()

{OctoBot-Trading-2.4.185 → OctoBot-Trading-2.4.187}/octobot_trading/exchanges/implementations/exchange_simulator.py

@@ -34,6 +34,7 @@ class ExchangeSimulator(rest_exchange.RestExchange):
         self.exchange_importers = []
         self.exchange_tentacle_class = None
         self.exchange_tentacle = None
+        self.exchange_config_by_exchange = exchange_config_by_exchange
         super().__init__(config, exchange_manager, exchange_config_by_exchange)
 
     def _create_connector(self, config, exchange_manager, connector_class):
@@ -46,12 +47,17 @@ class ExchangeSimulator(rest_exchange.RestExchange):
 
     async def initialize_impl(self):
         self.exchange_tentacle_class = exchange_util.get_rest_exchange_class(
-            self.exchange_manager.exchange_name, self.exchange_manager.tentacles_setup_config, None
+            self.exchange_manager.exchange_name, self.exchange_manager.tentacles_setup_config,
+            self.exchange_config_by_exchange
         )
         await super().initialize_impl()
         self.exchange_importers = self.connector.exchange_importers
         if self.connector.should_adapt_market_statuses():
             await self._init_exchange_tentacle()
+        if self.exchange_tentacle_class:
+            self.exchange_tentacle_class.DEFAULT_CONNECTOR_CLASS.register_simulator_connector_fee_methods(
+                self.exchange_manager.exchange_name, self.connector
+            )
 
     async def _init_exchange_tentacle(self):
         origin_ignore_config = self.exchange_manager.ignore_config
@@ -61,7 +67,7 @@ class ExchangeSimulator(rest_exchange.RestExchange):
             # initialize a locale exchange_tentacle to be able to access adapters for market statuses
             if self.exchange_tentacle_class:
                 self.exchange_tentacle = self.exchange_tentacle_class(
-                    self.exchange_manager.config, self.exchange_manager, None
+                    self.exchange_manager.config, self.exchange_manager, self.exchange_config_by_exchange
                 )
         finally:
             self.exchange_manager.ignore_config = origin_ignore_config

{OctoBot-Trading-2.4.185 → OctoBot-Trading-2.4.187}/octobot_trading/exchanges/types/rest_exchange.py

@@ -82,6 +82,7 @@ class RestExchange(abstract_exchange.AbstractExchange):
     # trigger an error
     # Name of the price param to give ccxt to edit a stop loss
     STOP_LOSS_EDIT_PRICE_PARAM = ccxt_enums.ExchangeOrderCCXTUnifiedParams.STOP_LOSS_PRICE.value
+    STOP_LOSS_CREATE_PRICE_PARAM = ccxt_enums.ExchangeOrderCCXTUnifiedParams.STOP_LOSS_PRICE.value
     """
     RestExchange is using its exchange connector to interact with the exchange.
     It should be used regardless of the exchange or the exchange library (ccxt or other)
@@ -559,6 +560,12 @@ class RestExchange(abstract_exchange.AbstractExchange):
             return exchanges_util.ExchangeMarketStatusFixer(market_status, price_example).market_status
         return market_status
 
+    def get_max_orders_count(self, symbol: str, order_type: enums.TraderOrderType) -> int:
+        return (
+            constants.DEFAULT_MAX_STOP_ORDERS_COUNT if orders.is_stop_order(order_type)
+            else constants.DEFAULT_MAX_DEFAULT_ORDERS_COUNT
+        )
+
     def _apply_contract_size(self, value, contract_size):
         if value is None:
             return value
@@ -1132,7 +1139,11 @@ class RestExchange(abstract_exchange.AbstractExchange):
     async def fetch_exchange_config(
         cls, exchange_config_by_exchange: typing.Optional[dict[str, dict]], exchange_manager
     ):
-        raise NotImplementedError("fetch_exchange_config")
+        raise NotImplementedError("fetch_exchange_config is not implemented")
+
+    @classmethod
+    def get_custom_url_config(cls, tentacle_config: dict, exchange_name: str) -> dict:
+        raise NotImplementedError("get_custom_url_config is not implemented")
 
     @classmethod
     def supported_autofill_exchanges(cls, tentacle_config):

{OctoBot-Trading-2.4.185 → OctoBot-Trading-2.4.187}/octobot_trading/personal_data/__init__.py

@@ -45,6 +45,7 @@ from octobot_trading.personal_data.orders import (
     is_stop_order,
     is_stop_trade_order_type,
     is_take_profit_order,
+    ensure_orders_limit,
     get_trade_order_type,
     create_as_chained_order,
     ensure_orders_relevancy,
@@ -292,6 +293,7 @@ __all__ = [
     "get_pnl_transaction_source_from_order",
     "is_stop_order",
     "is_stop_trade_order_type",
+    "ensure_orders_limit",
     "is_take_profit_order",
     "get_trade_order_type",
     "create_as_chained_order",

{OctoBot-Trading-2.4.185 → OctoBot-Trading-2.4.187}/octobot_trading/personal_data/orders/__init__.py

@@ -120,6 +120,7 @@ from octobot_trading.personal_data.orders.order_util import (
     is_stop_order,
     is_stop_trade_order_type,
     is_take_profit_order,
+    ensure_orders_limit,
     get_trade_order_type,
     create_order_price_trigger,
     create_as_active_order_using_strategy_if_any,
@@ -205,6 +206,8 @@ __all__ = [
     "get_pnl_transaction_source_from_order",
     "is_stop_order",
     "is_stop_trade_order_type",
+    "is_take_profit_order",
+    "ensure_orders_limit",
     "create_as_chained_order",
     "ensure_orders_relevancy",
     "get_order_quantity_currency",

{OctoBot-Trading-2.4.185 → OctoBot-Trading-2.4.187}/octobot_trading/personal_data/orders/order_util.py

@@ -517,6 +517,28 @@ def is_take_profit_order(order_type: enums.TraderOrderType):
     ]
 
 
+def ensure_orders_limit(exchange_manager, symbol, added_orders: list[enums.TraderOrderType]):
+    max_limit_orders = exchange_manager.exchange.get_max_orders_count(symbol, enums.TraderOrderType.SELL_LIMIT)
+    max_stop_orders = exchange_manager.exchange.get_max_orders_count(symbol, enums.TraderOrderType.STOP_LOSS)
+    open_orders = exchange_manager.exchange_personal_data.orders_manager.get_open_orders(
+        symbol=symbol, active=None  # consider both active and inactive orders of this symbol
+    )
+    stop_orders_count = len([o for o in open_orders if is_stop_order(o.order_type)]) + len(
+        [o_type for o_type in added_orders if is_stop_order(o_type)]
+    )
+    limit_orders_count = len(open_orders) + len(added_orders) - stop_orders_count
+    if limit_orders_count > max_limit_orders:
+        raise errors.MaxOpenOrderReachedForSymbolError(
+            f"{symbol} max open limit orders reached: "
+            f"limit = {max_limit_orders}, orders count = {limit_orders_count}"
+        )
+    if stop_orders_count > max_stop_orders:
+        raise errors.MaxOpenOrderReachedForSymbolError(
+            f"{symbol} max open stop orders reached: "
+            f"limit = {max_stop_orders}, orders count = {stop_orders_count}"
+        )
+
+
 def get_trade_order_type(order_type: enums.TraderOrderType) -> enums.TradeOrderType:
     if order_type in (enums.TraderOrderType.BUY_MARKET, enums.TraderOrderType.SELL_MARKET):
         return enums.TradeOrderType.MARKET

{OctoBot-Trading-2.4.185 → OctoBot-Trading-2.4.187}/tests/exchanges/__init__.py

@@ -75,6 +75,9 @@ class MockedCCXTConnector(CCXTConnector):
     def _should_authenticate(self):
         return False
 
+    def register_simulator_connector_fee_methods(self, *args, **kwargs):
+        pass
+
 
 class MockedRestExchange(DefaultRestExchange):
     DEFAULT_CONNECTOR_CLASS = MockedCCXTConnector

{OctoBot-Trading-2.4.185 → OctoBot-Trading-2.4.187}/tests/exchanges/test_exchange_simulator.py

@@ -118,6 +118,7 @@ async def test_init_exchange_tentacle(backtesting_trader):
     init_adapter = mock.Mock()
 
     class AdapterTentacle:
+        DEFAULT_CONNECTOR_CLASS = mock.Mock()
         def __init__(self, *_, **__):
             self.get_adapter_class = mock.Mock(
                 return_value=init_adapter
@@ -125,6 +126,7 @@ async def test_init_exchange_tentacle(backtesting_trader):
             self.stop = mock.AsyncMock()
 
     class NoAdapterTentacle:
+        DEFAULT_CONNECTOR_CLASS = mock.Mock()
         def __init__(self, *_, **__):
             self.get_adapter_class = mock.Mock(
                 return_value=None

{OctoBot-Trading-2.4.185 → OctoBot-Trading-2.4.187}/tests/personal_data/orders/test_order_util.py

@@ -22,6 +22,7 @@ import pytest
 import octobot_trading.api as api
 import octobot_trading.enums as enums
 import octobot_trading.constants as constants
+import octobot_trading.errors
 import octobot_trading.personal_data as personal_data
 import octobot_trading.personal_data.orders.order_util as order_util
 import octobot_trading.personal_data.orders.order_factory as order_factory
@@ -940,3 +941,56 @@ def test_get_split_orders_count_and_increment():
         symbol_market,
         False
     ) == (0, decimal.Decimal('0'))
+
+
+def test_ensure_orders_limit():
+    symbol = "BTC/USDT"
+    exchange_manager = mock.Mock(
+        exchange = mock.Mock(
+            get_max_orders_count = mock.Mock(return_value=5),
+        ),
+        exchange_personal_data = mock.Mock(
+            orders_manager = mock.Mock(
+                get_open_orders = mock.Mock(
+                    return_value=[
+                        mock.Mock(order_type=enums.TraderOrderType.BUY_LIMIT),
+                        mock.Mock(order_type=enums.TraderOrderType.SELL_LIMIT),
+                        mock.Mock(order_type=enums.TraderOrderType.STOP_LOSS),
+                        mock.Mock(order_type=enums.TraderOrderType.STOP_LOSS),
+                        mock.Mock(order_type=enums.TraderOrderType.STOP_LOSS),
+                    ],
+                )
+            )
+        )
+    )
+
+    # do not raise
+    order_util.ensure_orders_limit(exchange_manager, symbol, [])
+    assert exchange_manager.exchange.get_max_orders_count.call_count == 2
+    assert exchange_manager.exchange.get_max_orders_count.mock_calls[0].args == (
+        symbol, enums.TraderOrderType.SELL_LIMIT
+    )
+    assert exchange_manager.exchange.get_max_orders_count.mock_calls[1].args == (
+        symbol, enums.TraderOrderType.STOP_LOSS
+    )
+    exchange_manager.exchange_personal_data.orders_manager.get_open_orders.assert_called_once_with(
+        symbol=symbol, active=None
+    )
+
+    # ok added limit orders
+    order_util.ensure_orders_limit(exchange_manager, symbol, [enums.TraderOrderType.BUY_LIMIT]*2)
+    order_util.ensure_orders_limit(exchange_manager, symbol, [enums.TraderOrderType.BUY_LIMIT]*3)
+    # too many added limit orders
+    with pytest.raises(octobot_trading.errors.MaxOpenOrderReachedForSymbolError):
+        order_util.ensure_orders_limit(exchange_manager, symbol, [enums.TraderOrderType.BUY_LIMIT]*4)
+    with pytest.raises(octobot_trading.errors.MaxOpenOrderReachedForSymbolError):
+        order_util.ensure_orders_limit(exchange_manager, symbol, [enums.TraderOrderType.BUY_LIMIT]*10)
+
+    # ok added stop orders
+    order_util.ensure_orders_limit(exchange_manager, symbol, [enums.TraderOrderType.STOP_LOSS])
+    order_util.ensure_orders_limit(exchange_manager, symbol, [enums.TraderOrderType.STOP_LOSS_LIMIT]*2)
+    # too many added stop orders
+    with pytest.raises(octobot_trading.errors.MaxOpenOrderReachedForSymbolError):
+        order_util.ensure_orders_limit(exchange_manager, symbol, [enums.TraderOrderType.STOP_LOSS]*3)
+    with pytest.raises(octobot_trading.errors.MaxOpenOrderReachedForSymbolError):
+        order_util.ensure_orders_limit(exchange_manager, symbol, [enums.TraderOrderType.STOP_LOSS_LIMIT]*10)

{OctoBot-Trading-2.4.185 → OctoBot-Trading-2.4.187}/tests_additional/real_exchanges/real_exchange_tester.py

@@ -317,9 +317,9 @@ class RealExchangeTester:
         end = self.get_time_after_time_frames(start, self.HISTORICAL_CANDLES_TO_FETCH_COUNT)
         return start, end
 
-    async def get_kline_price(self, **kwargs):
+    async def get_kline_price(self, time_frame=None, **kwargs):
         async with self.get_exchange_manager() as exchange_manager:
-            return await exchange_manager.exchange.get_kline_price(self.SYMBOL, self.TIME_FRAME, **kwargs)
+            return await exchange_manager.exchange.get_kline_price(self.SYMBOL, time_frame or self.TIME_FRAME, **kwargs)
 
     async def get_order_book(self, **kwargs):
         async with self.get_exchange_manager() as exchange_manager:

{OctoBot-Trading-2.4.185 → OctoBot-Trading-2.4.187}/tests_additional/real_exchanges/test_hollaex.py

@@ -107,7 +107,7 @@ class TestHollaexRealExchangeTester(RealExchangeTester):
         await super().test_get_historical_ohlcv()
 
     async def test_get_kline_price(self):
-        kline_price = await self.get_kline_price()
+        kline_price = await self.get_kline_price(time_frame=TimeFrames.ONE_HOUR)
         assert len(kline_price) == 1
         assert len(kline_price[0]) == 6
         kline_start_time = kline_price[0][PriceIndexes.IND_PRICE_TIME.value]