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

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/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.77] - 2024-04-13
+### Added
+- [Exchanges] Handle inactive markets
+
+## [2.4.76] - 2024-04-12
+### Added
+- [Exchanges] Handle order type open status for symbol
+### Updated
+- [Exchanges] Handle portfolio optimization using limit orders
+
 ## [2.4.75] - 2024-04-11
 ### Fixed
 - [Exchanges] Properly handle order not found errors

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

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

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

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

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

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/octobot_trading/constants.py

@@ -42,6 +42,8 @@ ALLOW_SIMULATED_ORDERS_INSTANT_FILL = os_util.parse_boolean_environment_var(
 ORDER_DATA_FETCHING_TIMEOUT = 5 * commons_constants.MINUTE_TO_SECONDS
 CHAINED_ORDER_PRICE_FETCHING_TIMEOUT = 1    # should be instant or ignored
 CHAINED_ORDERS_OUTDATED_PRICE_ALLOWANCE = decimal.Decimal("0.005")  # allows 0.5% outdated price error
+# 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
 
 # Tentacles
@@ -131,7 +133,7 @@ EXCHANGE_PERMISSION_ERRORS: typing.List[typing.Iterable[str]] = [
 
     # coinbase ex: coinbase {"error":"PERMISSION_DENIED",
     # "error_details":"Missing required scopes","message":"Missing required scopes"}
-    ("permission_denied", )
+    ("permission_denied", "required scopes"),
 ]
 
 # text content of errors due to exchange compliancy rules

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/octobot_trading/errors.py

@@ -93,6 +93,12 @@ class FailedRequest(Exception):
     """
 
 
+class UnavailableOrderTypeForMarketError(Exception):
+    """
+    Raised when an exchange refuses to create a given type of order that should normally be supported
+    """
+
+
 class AuthenticationError(Exception):
     """
     Raised when an exchange failed to authenticate

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/octobot_trading/exchanges/abstract_exchange.py

@@ -383,7 +383,7 @@ class AbstractExchange(tentacles_management.AbstractTentacle):
         """
         raise NotImplementedError("get_bundled_order_parameters is not implemented")
 
-    def is_supported_order_type(self, order_type):
+    def is_supported_order_type(self, order_type: enums.TraderOrderType) -> bool:
         """
         Check if the order type is supported by the current exchange instance
         Should be used to know if we should simulate this order or create it on the exchange
@@ -392,6 +392,12 @@ class AbstractExchange(tentacles_management.AbstractTentacle):
         """
         return order_type not in self.get_supported_elements(enums.ExchangeSupportedElements.UNSUPPORTED_ORDERS)
 
+    def is_market_open_for_order_type(self, symbol: str, order_type: enums.TraderOrderType) -> bool:
+        """
+        Override if necessary
+        """
+        return True
+
     def get_trade_fee(self, symbol: str, order_type: enums.TraderOrderType, quantity, price, taker_or_maker):
         """
         Calculates fees resulting to a trade

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

@@ -134,8 +134,16 @@ def get_ccxt_client_login_options(exchange_manager):
     return {'defaultType': 'spot'}
 
 
-def get_symbols(client):
+def get_symbols(client, active_only):
     try:
+        if active_only:
+            return set(
+                symbol
+                for symbol in client.symbols
+                if client.markets.get(symbol, {}).get(
+                    enums.ExchangeConstantsMarketStatusColumns.ACTIVE.value, True
+                )
+            )
         return set(client.symbols)
     except (AttributeError, TypeError):
         # ccxt exchange load_markets failed

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

@@ -97,7 +97,7 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
                 )
 
             # initialize symbols and timeframes
-            self.symbols = self.get_client_symbols()
+            self.symbols = self.get_client_symbols(active_only=True)
             self.time_frames = self.get_client_time_frames()
 
         except (ccxt.ExchangeNotAvailable, ccxt.RequestTimeout) as e:
@@ -157,8 +157,8 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
                 else:
                     raise
 
-    def get_client_symbols(self):
-        return ccxt_client_util.get_symbols(self.client)
+    def get_client_symbols(self, active_only=True):
+        return ccxt_client_util.get_symbols(self.client, active_only)
 
     def get_client_time_frames(self):
         return ccxt_client_util.get_time_frames(self.client)

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/octobot_trading/exchanges/connectors/ccxt/ccxt_websocket_connector.py

@@ -766,7 +766,7 @@ class CCXTWebsocketConnector(abstract_websocket_exchange.AbstractWebsocketExchan
         return self.EXCHANGE_FEEDS.get(Feeds.CANDLE, Feeds.UNSUPPORTED.value) != Feeds.UNSUPPORTED.value
 
     def _is_supported_pair(self, pair):
-        return pair in ccxt_client_util.get_symbols(self.client)
+        return pair in ccxt_client_util.get_symbols(self.client, True)
 
     def _is_pair_independent_feed(self, feed):
         return feed in self.PAIR_INDEPENDENT_CHANNELS

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/octobot_trading/exchanges/types/rest_exchange.py

@@ -196,30 +196,35 @@ class RestExchange(abstract_exchange.AbstractExchange):
             self.log_order_creation_error(e, order_type, symbol, quantity, price, stop_price)
             if self.__class__.PRINT_DEBUG_LOGS:
                 self.logger.warning(str(e))
-            raise errors.MissingFunds(e)
-        except ccxt.NotSupported:
-            raise errors.NotSupported
+            raise errors.MissingFunds(e) from e
+        except ccxt.NotSupported as err:
+            raise errors.NotSupported from err
         except ccxt.AuthenticationError as err:
             # invalid api key or missing trading rights
             raise errors.AuthenticationError(
                 f"Error when handling order {err}. Please make sure that trading permissions are on for this API key."
-            )
+            ) from err
         except ccxt.DDoSProtection as e:
             # raised upon rate limit issues, last response data might have details on what is happening
             if self.should_log_on_ddos_exception(e):
                 self.connector.log_ddos_error(e)
             raise errors.FailedRequest(f"Failed to order operation: {e.__class__.__name__} {e}") from e
         except Exception as e:
+            if not self.is_market_open_for_order_type(symbol, order_type):
+                raise errors.UnavailableOrderTypeForMarketError(
+                    f"Error when handling order {e}. "
+                    f"Exchange currently refuses to create orders of type {order_type} on {symbol}."
+                ) from e
             if exchanges_util.is_api_permission_error(e):
                 # invalid api key or missing trading rights
                 raise errors.AuthenticationError(
                     f"Error when handling order {e}. Please make sure that trading permissions are on for this API key."
-                )
+                ) from e
             if exchanges_util.is_exchange_rules_compliancy_error(e):
                 raise errors.ExchangeCompliancyError(
                     f"Error when handling order {e}. Exchange is refusing this order request on this account because "
                     f"of its compliancy requirements."
-                )
+                ) from e
             self.log_order_creation_error(e, order_type, symbol, quantity, price, stop_price)
             print(traceback.format_exc(), file=sys.stderr)
             self.logger.exception(e, False, f"Unexpected error during order operation: {e}")

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/octobot_trading/modes/modes_util.py

@@ -120,6 +120,18 @@ async def convert_asset_to_target_asset(
             )
             return created_orders
 
+        if trading_personal_data.get_trade_order_type(order_type) is not trading_enums.TradeOrderType.MARKET:
+            # can't use market orders: use limit orders with price a bit under the current price to instant fill it.
+            price_delta = price * constants.INSTANT_FILLED_LIMIT_ORDER_PRICE_DELTA
+            if order_type is trading_enums.TraderOrderType.SELL_LIMIT:
+                price -= price_delta
+            elif order_type is trading_enums.TraderOrderType.BUY_LIMIT:
+                price += price_delta
+            else:
+                trading_mode.logger.error(
+                    f"Unhandled order type in convertor limit order price adapter: {order_type}"
+                )
+
         # get order quantity
         quantity = _get_available_or_target_quantity(trading_mode, symbol, order_type, price, asset_amount)
         symbol_market = trading_mode.exchange_manager.exchange.get_market_status(symbol, with_fixer=False)
@@ -147,6 +159,15 @@ def _get_associated_symbol_and_order_type(trading_mode, asset: str, target_asset
     symbol, reversed_symbol = exchange_util.get_associated_symbol(trading_mode.exchange_manager, asset, target_asset)
     order_type = trading_enums.TraderOrderType.BUY_MARKET if reversed_symbol else \
         trading_enums.TraderOrderType.SELL_MARKET
+    if not trading_mode.exchange_manager.exchange.is_market_open_for_order_type(symbol, order_type):
+        # can't use market orders: use limit orders instead
+        order_type = trading_enums.TraderOrderType.BUY_LIMIT if order_type is trading_enums.TraderOrderType.BUY_MARKET \
+            else trading_enums.TraderOrderType.SELL_LIMIT
+        if not trading_mode.exchange_manager.exchange.is_market_open_for_order_type(symbol, order_type):
+            # can't convert asset: still try with limit orders but it will probably fail
+            trading_mode.logger.error(
+                f"Both market and {order_type} order are currently unsupported. Trying limit orders anyway."
+            )
     return symbol, order_type
 
 

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/tests/exchanges/test_exchange_config_data.py

@@ -80,7 +80,6 @@ class TestExchangeConfig:
         }
         _, exchange_manager = await self.init_default(config=config)
 
-        assert "UNI/BTC" in exchange_manager.exchange_config.traded_cryptocurrencies["Bitcoin"]
         assert "AVAX/BTC" in exchange_manager.exchange_config.traded_cryptocurrencies["Bitcoin"]
         assert "ADA/BTC" in exchange_manager.exchange_config.traded_cryptocurrencies["Bitcoin"]
         assert "MATIC/BTC" in exchange_manager.exchange_config.traded_cryptocurrencies["Bitcoin"]
@@ -90,6 +89,9 @@ class TestExchangeConfig:
         assert "AVAX/BNB" not in exchange_manager.exchange_config.traded_cryptocurrencies["Bitcoin"]
         assert "ETH/BTC" in exchange_manager.exchange_config.traded_symbol_pairs
 
+        # inactive markets
+        assert "UNI/BTC" not in exchange_manager.exchange_config.traded_cryptocurrencies["Bitcoin"]
+
         # disabled
         assert "Ethereum" not in exchange_manager.exchange_config.traded_cryptocurrencies
         assert "ADA/ETH" not in exchange_manager.exchange_config.traded_symbol_pairs
@@ -113,10 +115,12 @@ class TestExchangeConfig:
         }
         _, exchange_manager = await self.init_default(config=config)
 
-        assert "TRX/BTC" in exchange_manager.exchange_config.traded_symbol_pairs
         assert "ADA/BTC" in exchange_manager.exchange_config.traded_symbol_pairs
         assert "Bitcoin" in exchange_manager.exchange_config.traded_cryptocurrencies
 
+        # inactive markets
+        assert "TRX/BTC" not in exchange_manager.exchange_config.traded_cryptocurrencies["Bitcoin"]
+
         # invalid ETH wildcard config
         assert "Ethereum" not in exchange_manager.exchange_config.traded_cryptocurrencies
 
@@ -141,7 +145,6 @@ class TestExchangeConfig:
 
         _, exchange_manager = await self.init_default(config=config)
 
-        assert "UNI/BTC" in exchange_manager.exchange_config.traded_cryptocurrencies["Bitcoin"]
         assert "AVAX/BTC" in exchange_manager.exchange_config.traded_cryptocurrencies["Bitcoin"]
         assert "ADA/BTC" in exchange_manager.exchange_config.traded_cryptocurrencies["Bitcoin"]
         assert "MATIC/BTC" in exchange_manager.exchange_config.traded_cryptocurrencies["Bitcoin"]
@@ -152,6 +155,9 @@ class TestExchangeConfig:
         assert "AVAX/BNB" not in exchange_manager.exchange_config.traded_cryptocurrencies["Bitcoin"]
         assert "BTC/USDT" in exchange_manager.exchange_config.traded_symbol_pairs
 
+        # inactive markets
+        assert "UNI/BTC" not in exchange_manager.exchange_config.traded_cryptocurrencies["Bitcoin"]
+
         # disabled
         assert "Ethereum" not in exchange_manager.exchange_config.traded_cryptocurrencies
         assert "ADA/ETH" not in exchange_manager.exchange_config.traded_symbol_pairs
@@ -189,11 +195,13 @@ class TestExchangeConfig:
         _, exchange_manager = await self.init_default(config=config)
 
         assert exchange_manager.exchange_config.traded_cryptocurrencies["Binance Coin"] == ["BNB/USDT"]
-        assert exchange_manager.exchange_config.traded_cryptocurrencies["Binance USD"] == ["BNB/BUSD"]
         assert exchange_manager.exchange_config.traded_cryptocurrencies["Bitcoin"] == ["BNB/BTC"]
         assert exchange_manager.exchange_config.traded_cryptocurrencies["Tether"] == ["BNB/USDT"]
 
-        sorted_pairs_without_redundancy = sorted(["BNB/USDT", "BNB/BUSD", "BNB/BTC"])
+        # inactive markets
+        assert exchange_manager.exchange_config.traded_cryptocurrencies["Binance USD"] == []
+
+        sorted_pairs_without_redundancy = sorted(["BNB/USDT", "BNB/BTC"])
         assert sorted(exchange_manager.exchange_config.traded_symbol_pairs) == sorted_pairs_without_redundancy
 
         cancel_ccxt_throttle_task()

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/tests/modes/test_modes_util.py

@@ -243,6 +243,64 @@ async def test_convert_asset_to_target_asset(backtesting_trader):
         trading_mode.create_order.assert_called_once()
         trading_mode.create_order.reset_mock()
 
+    # using limit orders
+    def _is_market_open_for_order_type(symbol: str, order_type: trading_enums.TraderOrderType):
+        return (
+            True if order_type in (trading_enums.TraderOrderType.SELL_LIMIT, trading_enums.TraderOrderType.BUY_LIMIT)
+            else False
+        )
+
+    with mock.patch.object(
+        exchange_manager.exchange, "is_market_open_for_order_type",
+        mock.Mock(side_effect=_is_market_open_for_order_type)
+    ) as is_market_open_for_order_type_mock:
+        # cast 1: buying
+        orders = await modes_util.convert_asset_to_target_asset(
+            trading_mode, "USDT", "ETH", tickers, asset_amount=decimal.Decimal(450)
+        )
+        assert len(orders) == 1
+        order = orders[0]
+        assert order.order_type == trading_enums.TraderOrderType.BUY_LIMIT
+        assert order.symbol == "ETH/USDT"
+        # a bit lower than 0.3 because of the price change
+        assert order.origin_quantity == decimal.Decimal("0.29850746")
+        adapted_price = decimal.Decimal(1500) * (
+            constants.ONE + constants.INSTANT_FILLED_LIMIT_ORDER_PRICE_DELTA
+        )
+        assert order.origin_price == adapted_price
+        assert order.created_last_price == adapted_price
+        assert is_market_open_for_order_type_mock.call_count == 2
+        assert is_market_open_for_order_type_mock.mock_calls[0].args == \
+               ("ETH/USDT", trading_enums.TraderOrderType.BUY_MARKET)
+        assert is_market_open_for_order_type_mock.mock_calls[1].args == \
+               ("ETH/USDT", trading_enums.TraderOrderType.BUY_LIMIT)
+        is_market_open_for_order_type_mock.reset_mock()
+        trading_mode.create_order.assert_called_once()
+        trading_mode.create_order.reset_mock()
+
+        # cast 2: selling
+        orders = await modes_util.convert_asset_to_target_asset(
+            trading_mode, "ETH", "USDT", tickers, asset_amount=decimal.Decimal(2)
+        )
+        assert len(orders) == 1
+        order = orders[0]
+        assert order.order_type == trading_enums.TraderOrderType.SELL_LIMIT
+        assert order.symbol == "ETH/USDT"
+        assert order.origin_quantity == decimal.Decimal("2")
+        adapted_price = decimal.Decimal(1500) * (
+            constants.ONE - constants.INSTANT_FILLED_LIMIT_ORDER_PRICE_DELTA
+        )
+        assert order.origin_price == adapted_price
+        assert order.created_last_price == adapted_price
+        assert is_market_open_for_order_type_mock.call_count == 2
+        assert is_market_open_for_order_type_mock.mock_calls[0].args == \
+               ("ETH/USDT", trading_enums.TraderOrderType.SELL_MARKET)
+        assert is_market_open_for_order_type_mock.mock_calls[1].args == \
+               ("ETH/USDT", trading_enums.TraderOrderType.SELL_LIMIT)
+        is_market_open_for_order_type_mock.reset_mock()
+        trading_mode.create_order.assert_called_once()
+        trading_mode.create_order.reset_mock()
+
 
 def _get_trading_mode(exchange_manager):
     return mock.Mock(

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/tests_additional/real_exchanges/real_exchange_tester.py

@@ -35,6 +35,7 @@ class RealExchangeTester:
     SYMBOL = None
     SYMBOL_2 = None
     SYMBOL_3 = None
+    INACTIVE_MARKETS = []
     # default is 1h, change if necessary
     TIME_FRAME = commons_enums.TimeFrames.ONE_HOUR
     ALLOWED_TIMEFRAMES_WITHOUT_CANDLE = 0
@@ -102,6 +103,14 @@ class RealExchangeTester:
     # async def test_create_order(self):
     #     pass
 
+    def ensure_required_market_status_values(self, market_status):
+            assert market_status
+            assert market_status[Ecmsc.TYPE.value] == self.MARKET_STATUS_TYPE
+            assert market_status[Ecmsc.SYMBOL.value] in (self.SYMBOL, self.SYMBOL_2, self.SYMBOL_3)
+            assert market_status[Ecmsc.ACTIVE.value] \
+                   is False if market_status[Ecmsc.SYMBOL.value] in self.INACTIVE_MARKETS else True
+            assert market_status[Ecmsc.PRECISION.value]
+
     async def test_get_historical_ohlcv(self):
         # common implementation, should always work if candles history is supported
         historical_ohlcv = await self.get_historical_ohlcv()

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/tests_additional/real_exchanges/test_ascendex.py

@@ -52,10 +52,7 @@ class TestAscendExRealExchangeTester(RealExchangeTester):
 
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
-            assert market_status
-            assert market_status[Ecmsc.TYPE.value] == self.MARKET_STATUS_TYPE
-            assert market_status[Ecmsc.SYMBOL.value] in (self.SYMBOL, self.SYMBOL_2, self.SYMBOL_3)
-            assert market_status[Ecmsc.PRECISION.value]
+            self.ensure_required_market_status_values(market_status)
             # on AscendEx, precision is a decimal instead of a number of digits
             assert 0 < market_status[Ecmsc.PRECISION.value][
                 Ecmsc.PRECISION_AMOUNT.value] <= 1  # to be fixed in AscendEx tentacle

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/tests_additional/real_exchanges/test_binance.py

@@ -32,6 +32,7 @@ class TestBinanceRealExchangeTester(RealExchangeTester):
     SYMBOL = "BTC/USDT"
     SYMBOL_2 = "ETH/BTC"
     SYMBOL_3 = "XRP/BTC"
+    INACTIVE_MARKETS = [SYMBOL_3]
 
     async def test_time_frames(self):
         time_frames = await self.time_frames()
@@ -55,10 +56,7 @@ class TestBinanceRealExchangeTester(RealExchangeTester):
 
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
-            assert market_status
-            assert market_status[Ecmsc.TYPE.value] == self.MARKET_STATUS_TYPE
-            assert market_status[Ecmsc.SYMBOL.value] in (self.SYMBOL, self.SYMBOL_2, self.SYMBOL_3)
-            assert market_status[Ecmsc.PRECISION.value]
+            self.ensure_required_market_status_values(market_status)
             assert int(market_status[Ecmsc.PRECISION.value][Ecmsc.PRECISION_AMOUNT.value]) == \
                    market_status[Ecmsc.PRECISION.value][Ecmsc.PRECISION_AMOUNT.value]
             assert int(market_status[Ecmsc.PRECISION.value][Ecmsc.PRECISION_PRICE.value]) == \

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/tests_additional/real_exchanges/test_binance_futures.py

@@ -59,10 +59,7 @@ class TestBinanceFuturesRealExchangeTester(RealFuturesExchangeTester):
 
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
-            assert market_status
-            assert market_status[Ecmsc.TYPE.value] == self.MARKET_STATUS_TYPE
-            assert market_status[Ecmsc.SYMBOL.value] in (self.SYMBOL, self.SYMBOL_2, self.SYMBOL_3)
-            assert market_status[Ecmsc.PRECISION.value]
+            self.ensure_required_market_status_values(market_status)
             assert int(market_status[Ecmsc.PRECISION.value][Ecmsc.PRECISION_AMOUNT.value]) == \
                    market_status[Ecmsc.PRECISION.value][Ecmsc.PRECISION_AMOUNT.value]
             assert int(market_status[Ecmsc.PRECISION.value][Ecmsc.PRECISION_PRICE.value]) == \

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/tests_additional/real_exchanges/test_bingx.py

@@ -56,10 +56,7 @@ class TestBingxRealExchangeTester(RealExchangeTester):
 
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
-            assert market_status
-            assert market_status[Ecmsc.TYPE.value] == self.MARKET_STATUS_TYPE
-            assert market_status[Ecmsc.SYMBOL.value] in (self.SYMBOL, self.SYMBOL_2, self.SYMBOL_3)
-            assert market_status[Ecmsc.PRECISION.value]
+            self.ensure_required_market_status_values(market_status)
             assert int(market_status[Ecmsc.PRECISION.value][Ecmsc.PRECISION_AMOUNT.value]) == \
                    market_status[Ecmsc.PRECISION.value][Ecmsc.PRECISION_AMOUNT.value]
             assert int(market_status[Ecmsc.PRECISION.value][Ecmsc.PRECISION_PRICE.value]) == \

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/tests_additional/real_exchanges/test_bitfinex.py

@@ -55,10 +55,7 @@ class TestBitfinexRealExchangeTester(RealExchangeTester):
 
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
-            assert market_status
-            assert market_status[Ecmsc.TYPE.value] == self.MARKET_STATUS_TYPE
-            assert market_status[Ecmsc.SYMBOL.value] in (self.SYMBOL, self.SYMBOL_2, self.SYMBOL_3)
-            assert market_status[Ecmsc.PRECISION.value]
+            self.ensure_required_market_status_values(market_status)
             assert int(market_status[Ecmsc.PRECISION.value][Ecmsc.PRECISION_AMOUNT.value]) == \
                    market_status[Ecmsc.PRECISION.value][Ecmsc.PRECISION_AMOUNT.value]
             assert int(market_status[Ecmsc.PRECISION.value][Ecmsc.PRECISION_PRICE.value]) == \

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/tests_additional/real_exchanges/test_bitget.py

@@ -57,10 +57,7 @@ class TestBitgetRealExchangeTester(RealExchangeTester):
 
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
-            assert market_status
-            assert market_status[Ecmsc.TYPE.value] == self.MARKET_STATUS_TYPE
-            assert market_status[Ecmsc.SYMBOL.value] in (self.SYMBOL, self.SYMBOL_2, self.SYMBOL_3)
-            assert market_status[Ecmsc.PRECISION.value]
+            self.ensure_required_market_status_values(market_status)
             # on Bitget, precision is a decimal instead of a number of digits
             assert 0 < market_status[Ecmsc.PRECISION.value][
                 Ecmsc.PRECISION_AMOUNT.value] < 1  # to be fixed in Bitget tentacle

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/tests_additional/real_exchanges/test_bithumb.py

@@ -50,10 +50,7 @@ class TestBithumbRealExchangeTester(RealExchangeTester):
 
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
-            assert market_status
-            assert market_status[Ecmsc.TYPE.value] == self.MARKET_STATUS_TYPE
-            assert market_status[Ecmsc.SYMBOL.value] in (self.SYMBOL, self.SYMBOL_2, self.SYMBOL_3)
-            assert market_status[Ecmsc.PRECISION.value]
+            self.ensure_required_market_status_values(market_status)
             assert int(market_status[Ecmsc.PRECISION.value][Ecmsc.PRECISION_AMOUNT.value]) == \
                    market_status[Ecmsc.PRECISION.value][Ecmsc.PRECISION_AMOUNT.value]
             assert int(market_status[Ecmsc.PRECISION.value][Ecmsc.PRECISION_PRICE.value]) == \

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/tests_additional/real_exchanges/test_bitso.py

@@ -49,10 +49,7 @@ class TestBitsoRealExchangeTester(RealExchangeTester):
 
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
-            assert market_status
-            assert market_status[Ecmsc.TYPE.value] == self.MARKET_STATUS_TYPE
-            assert market_status[Ecmsc.SYMBOL.value] in (self.SYMBOL, self.SYMBOL_2, self.SYMBOL_3)
-            assert market_status[Ecmsc.PRECISION.value]
+            self.ensure_required_market_status_values(market_status)
             # on this exchange, precision is a decimal instead of a number of digits
             assert 0 < market_status[Ecmsc.PRECISION.value][
                 Ecmsc.PRECISION_AMOUNT.value] <= 1  # to be fixed in this exchange tentacle

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/tests_additional/real_exchanges/test_bitstamp.py

@@ -53,10 +53,7 @@ class TestBitstampRealExchangeTester(RealExchangeTester):
 
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
-            assert market_status
-            assert market_status[Ecmsc.TYPE.value] == self.MARKET_STATUS_TYPE
-            assert market_status[Ecmsc.SYMBOL.value] in (self.SYMBOL, self.SYMBOL_2, self.SYMBOL_3)
-            assert market_status[Ecmsc.PRECISION.value]
+            self.ensure_required_market_status_values(market_status)
             # on this exchange, precision is a decimal instead of a number of digits
             assert 0 < market_status[Ecmsc.PRECISION.value][
                 Ecmsc.PRECISION_AMOUNT.value] <= 1  # to be fixed in this exchange tentacle

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/tests_additional/real_exchanges/test_bybit.py

@@ -53,10 +53,7 @@ class TestBybitRealExchangeTester(RealExchangeTester):
 
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
-            assert market_status
-            assert market_status[Ecmsc.TYPE.value] == self.MARKET_STATUS_TYPE
-            assert market_status[Ecmsc.SYMBOL.value] in (self.SYMBOL, self.SYMBOL_2, self.SYMBOL_3)
-            assert market_status[Ecmsc.PRECISION.value]
+            self.ensure_required_market_status_values(market_status)
             # on Bybit, precision is a decimal instead of a number of digits
             assert 0 < market_status[Ecmsc.PRECISION.value][
                 Ecmsc.PRECISION_AMOUNT.value] <= 1  # to be fixed in Bybit tentacle

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/tests_additional/real_exchanges/test_bybit_futures.py

@@ -59,10 +59,7 @@ class TestBybitRealExchangeTester(RealFuturesExchangeTester):
 
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
-            assert market_status
-            assert market_status[Ecmsc.TYPE.value] == self.MARKET_STATUS_TYPE
-            assert market_status[Ecmsc.SYMBOL.value] in (self.SYMBOL, self.SYMBOL_2, self.SYMBOL_3)
-            assert market_status[Ecmsc.PRECISION.value]
+            self.ensure_required_market_status_values(market_status)
             # on Bybit, precision is a decimal instead of a number of digits
             assert 0 < market_status[Ecmsc.PRECISION.value][
                 Ecmsc.PRECISION_AMOUNT.value] <= 1  # to be fixed in Bybit tentacle

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/tests_additional/real_exchanges/test_coinbase.py

@@ -50,10 +50,7 @@ class TestCoinbaseRealExchangeTester(RealExchangeTester):
 
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
-            assert market_status
-            assert market_status[Ecmsc.TYPE.value] == self.MARKET_STATUS_TYPE
-            assert market_status[Ecmsc.SYMBOL.value] in (self.SYMBOL, self.SYMBOL_2, self.SYMBOL_3)
-            assert market_status[Ecmsc.PRECISION.value]
+            self.ensure_required_market_status_values(market_status)
             assert 0 < market_status[Ecmsc.PRECISION.value][
                 Ecmsc.PRECISION_AMOUNT.value] <= 1  # to be fixed in coinbase tentacle
             assert 0 < market_status[Ecmsc.PRECISION.value][

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/tests_additional/real_exchanges/test_coinex.py

@@ -53,10 +53,7 @@ class TestCoinexRealExchangeTester(RealExchangeTester):
 
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
-            assert market_status
-            assert market_status[Ecmsc.TYPE.value] == self.MARKET_STATUS_TYPE
-            assert market_status[Ecmsc.SYMBOL.value] in (self.SYMBOL, self.SYMBOL_2, self.SYMBOL_3)
-            assert market_status[Ecmsc.PRECISION.value]
+            self.ensure_required_market_status_values(market_status)
             # on this exchange, precision is a decimal instead of a number of digits
             assert 0 < market_status[Ecmsc.PRECISION.value][
                 Ecmsc.PRECISION_AMOUNT.value] <= 1  # to be fixed in this exchange tentacle

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/tests_additional/real_exchanges/test_cryptocom.py

@@ -51,10 +51,7 @@ class TestCryptoComRealExchangeTester(RealExchangeTester):
 
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
-            assert market_status
-            assert market_status[Ecmsc.TYPE.value] == self.MARKET_STATUS_TYPE
-            assert market_status[Ecmsc.SYMBOL.value] in (self.SYMBOL, self.SYMBOL_2, self.SYMBOL_3)
-            assert market_status[Ecmsc.PRECISION.value]
+            self.ensure_required_market_status_values(market_status)
             # on CryptoCom, precision is a decimal instead of a number of digits
             assert 0 < market_status[Ecmsc.PRECISION.value][
                 Ecmsc.PRECISION_AMOUNT.value] <= 1  # to be fixed in CryptoCom tentacle

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/tests_additional/real_exchanges/test_gateio.py

@@ -49,10 +49,7 @@ class TestGateIORealExchangeTester(RealExchangeTester):
 
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
-            assert market_status
-            assert market_status[Ecmsc.TYPE.value] == self.MARKET_STATUS_TYPE
-            assert market_status[Ecmsc.SYMBOL.value] in (self.SYMBOL, self.SYMBOL_2, self.SYMBOL_3)
-            assert market_status[Ecmsc.PRECISION.value]
+            self.ensure_required_market_status_values(market_status)
             assert 1e-08 <= market_status[Ecmsc.PRECISION.value][
                 Ecmsc.PRECISION_AMOUNT.value] < 1   # to be fixed in tentacle
             assert 1e-08 <= market_status[Ecmsc.PRECISION.value][

{OctoBot-Trading-2.4.75 → OctoBot-Trading-2.4.77}/tests_additional/real_exchanges/test_hitbtc.py

@@ -50,10 +50,7 @@ class TestHitBtcRealExchangeTester(RealExchangeTester):
 
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
-            assert market_status
-            assert market_status[Ecmsc.TYPE.value] == self.MARKET_STATUS_TYPE
-            assert market_status[Ecmsc.SYMBOL.value] in (self.SYMBOL, self.SYMBOL_2, self.SYMBOL_3)
-            assert market_status[Ecmsc.PRECISION.value]
+            self.ensure_required_market_status_values(market_status)
             assert 1e-08 <= market_status[Ecmsc.PRECISION.value][
                 Ecmsc.PRECISION_AMOUNT.value] < 1  # to be fixed in hitbtc tentacle
             assert 1e-09 <= market_status[Ecmsc.PRECISION.value][