Merge pull request #2038 from Drakkar-Software/dev

master merge

Author: GuillaumeDSM

CHANGELOG.md

@@ -6,6 +6,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 *It is strongly advised to perform an update of your tentacles after updating OctoBot. (start.py tentacles --install --all)*
 
+## [0.4.10] - 2022-09-13
+### Updated
+- Beta tentacles
+### Fixed
+- Kucoin rate limit issues
+- Futures trading issues
+- Tentacles versioning in profile import
+
 ## [0.4.9] - 2022-09-07
 ### Updated
 - Beta tentacles

README.md

@@ -1,4 +1,4 @@
-# OctoBot [0.4.9](https://octobot.click/gh-changelog)
+# OctoBot [0.4.10](https://octobot.click/gh-changelog)
 [![PyPI](https://img.shields.io/pypi/v/OctoBot.svg)](https://octobot.click/gh-pypi)
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/e07fb190156d4efb8e7d07aaa5eff2e1)](https://app.codacy.com/gh/Drakkar-Software/OctoBot?utm_source=github.com&utm_medium=referral&utm_content=Drakkar-Software/OctoBot&utm_campaign=Badge_Grade_Dashboard)[![Downloads](https://pepy.tech/badge/octobot/month)](https://pepy.tech/project/octobot)
 [![Dockerhub](https://img.shields.io/docker/pulls/drakkarsoftware/octobot.svg)](https://octobot.click/gh-dockerhub)
@@ -46,11 +46,11 @@ Octobot's main feature is **evolution** : you can [install](https://www.octobot.
 
 ## Hardware requirements
 - CPU : 1 Core / 1GHz
-- RAM : 250 Mo
-- Disk : 1 Go
+- RAM : 250 MB
+- Disk : 1 GB
 
 ## Installation
-OctoBot's installation is **very simple**... because **very documented** ! See the [installation guides](https://www.octobot.online/guides/#installation) for more info.
+OctoBot's installation is **very simple**... because it is **very documented** ! See the [installation guides](https://www.octobot.online/guides/#installation) for more info.
 
 #### [With executable](https://www.octobot.info/installation/with-binary)
 Follow the [2 steps installation guide](https://www.octobot.online/executable_installation/) 
@@ -114,17 +114,16 @@ In short :
 [![Bitmax](../assets/ascendex-logo.png)](https://octobot.click/gh-ascendex)
 
 Octobot supports many [exchanges](https://octobot.click/gh-exchanges) thanks to the [ccxt library](https://github.com/ccxt/ccxt). 
-To activate trading on an exchange, just configure OctoBot with your api keys as described [on the exchange documentation](https://www.octobot.online/guides/#exchanges).
+To activate trading on an exchange, just configure OctoBot with your API keys as described [on the exchange documentation](https://www.octobot.online/guides/#exchanges).
 
 ## Disclaimer
 Do not risk money which you are afraid to lose. USE THE SOFTWARE AT YOUR OWN RISK. THE AUTHORS 
 AND ALL AFFILIATES ASSUME NO RESPONSIBILITY FOR YOUR TRADING RESULTS. 
 
 Always start by running a trading bot in simulation mode and do not engage money
-before you understand how it works and what profit/loss you should
-expect.
+before you understand how it works and what profit/loss you should expect.
 
-Do not hesitate to read the source code and understand the mechanism of this bot.
+Please feel free to read the source code and understand the mechanism of this bot.
 
 ## License
 GNU General Public License v3.0 or later.

octobot/api/strategy_optimizer.py

@@ -37,9 +37,9 @@ async def update_strategy_optimizer_total_runs(optimizer, runs):
 
 
 async def generate_and_save_strategy_optimizer_runs(trading_mode, tentacles_setup_config,
-                                                    optimizer_config, optimizer_id) -> list:
+                                                    optimizer_config, optimizer_id, queue_size) -> list:
     optimizer = StrategyDesignOptimizer(trading_mode, None, tentacles_setup_config,
-                                        optimizer_config, optimizer_id)
+                                        optimizer_config, optimizer_id, queue_size)
     return await optimizer.generate_and_save_run()
 
 

octobot/backtesting/independent_backtesting.pxd

@@ -58,7 +58,7 @@ cdef class IndependentBacktesting:
     cdef void _log_symbol_report(self, str symbol, object exchange_manager, object min_time_frame)
     cdef void _log_global_report(self, object exchange_manager)
     cdef void _adapt_config(self)
-    cdef str _find_reference_market(self)
+    cdef str _find_reference_market_and_update_contract_type(self)
     cdef void _add_config_default_backtesting_values(self)
     cdef void _add_crypto_currencies_config(self)
     cdef void _init_exchange_type(self)

octobot/backtesting/independent_backtesting.py

@@ -321,7 +321,7 @@ def _adapt_config(self):
             exchange_details.pop(common_constants.CONFIG_EXCHANGE_SANDBOXED, None)
         self.backtesting_config[common_constants.CONFIG_TRADING][common_constants.CONFIG_TRADER_RISK] = self.risk
         self.backtesting_config[common_constants.CONFIG_TRADING][
-            common_constants.CONFIG_TRADER_REFERENCE_MARKET] = self._find_reference_market()
+            common_constants.CONFIG_TRADER_REFERENCE_MARKET] = self._find_reference_market_and_update_contract_type()
         self.backtesting_config[common_constants.CONFIG_SIMULATOR][
             common_constants.CONFIG_STARTING_PORTFOLIO] = self.starting_portfolio
         self.backtesting_config[common_constants.CONFIG_SIMULATOR][
@@ -333,12 +333,17 @@ def _adapt_config(self):
         self._add_config_default_backtesting_values()
 
     def _init_exchange_type(self):
+        forced_exchange_type = self.octobot_origin_config.get(common_constants.CONFIG_EXCHANGE_TYPE,
+                                                              common_constants.USE_CURRENT_PROFILE)
         try:
             for exchange_name in self.symbols_to_create_exchange_classes:
-                # use current profile config to create a spot/future/margin backtesting exchange
-                self.octobot_backtesting.exchange_type_by_exchange[exchange_name] = \
-                    self.octobot_origin_config[common_constants.CONFIG_EXCHANGES].get(exchange_name, {}).\
-                    get(common_constants.CONFIG_EXCHANGE_TYPE, common_constants.DEFAULT_EXCHANGE_TYPE)
+                if forced_exchange_type == common_constants.USE_CURRENT_PROFILE:
+                    # use current profile config to create a spot/future/margin backtesting exchange
+                    self.octobot_backtesting.exchange_type_by_exchange[exchange_name] = \
+                        self.octobot_origin_config[common_constants.CONFIG_EXCHANGES].get(exchange_name, {}).\
+                        get(common_constants.CONFIG_EXCHANGE_TYPE, common_constants.DEFAULT_EXCHANGE_TYPE)
+                else:
+                    self.octobot_backtesting.exchange_type_by_exchange[exchange_name] = forced_exchange_type
         except StopIteration:
             # use default exchange type
             pass
@@ -354,25 +359,36 @@ async def _generate_backtesting_id_if_missing(self):
             await run_dbs_identifier.initialize()
             self.backtesting_config[common_constants.CONFIG_BACKTESTING_ID] = run_dbs_identifier.backtesting_id
 
-    def _find_reference_market(self):
+    def _find_reference_market_and_update_contract_type(self):
         ref_market_candidate = None
         ref_market_candidates = {}
+        forced_contract_type = self.octobot_origin_config.get(common_constants.CONFIG_CONTRACT_TYPE,
+                                                              common_constants.USE_CURRENT_PROFILE)
         for symbols in self.symbols_to_create_exchange_classes.values():
             symbol = symbols[0]
             if next(iter(self.octobot_backtesting.exchange_type_by_exchange.values())) \
                     == common_constants.CONFIG_EXCHANGE_FUTURE:
-                if symbol.is_inverse():
-                    if not all([symbol.is_inverse() for symbol in symbols]):
-                        self.logger.error(f"Mixed inverse and linear contracts backtesting are not supported yet")
-                    self.octobot_backtesting.futures_contract_type = trading_enums.FutureContractType.INVERSE_PERPETUAL
+                if forced_contract_type == common_constants.USE_CURRENT_PROFILE:
+                    if symbol.is_inverse():
+                        if not all([symbol.is_inverse() for symbol in symbols]):
+                            self.logger.error(f"Mixed inverse and linear contracts backtesting are not supported yet")
+                            self.octobot_backtesting.futures_contract_type = \
+                                trading_enums.FutureContractType.INVERSE_PERPETUAL
+                    else:
+                        if not all([symbol.is_linear() for symbol in symbols]):
+                            self.logger.error(f"Mixed inverse and linear contracts backtesting are not supported yet")
+                        self.octobot_backtesting.futures_contract_type = \
+                            trading_enums.FutureContractType.LINEAR_PERPETUAL
+                    # in inverse contracts, use BTC for BTC/USD trading as reference market
+                    if symbol.settlement_asset:
+                        # only use settlement asset if available
+                        return symbol.settlement_asset
                 else:
-                    if not all([symbol.is_linear() for symbol in symbols]):
-                        self.logger.error(f"Mixed inverse and linear contracts backtesting are not supported yet")
-                    self.octobot_backtesting.futures_contract_type = trading_enums.FutureContractType.LINEAR_PERPETUAL
-                # in inverse contracts, use BTC for BTC/USD trading as reference market
-                if symbol.settlement_asset:
-                    # only use settlement asset if available
-                    return symbol.settlement_asset
+                    self.octobot_backtesting.futures_contract_type = forced_contract_type
+                    return symbol.base \
+                        if forced_contract_type is trading_enums.FutureContractType.INVERSE_PERPETUAL \
+                        else symbol.quote
+
             for symbol in symbols:
                 quote = symbol.quote
                 if ref_market_candidate is None:

octobot/cli.py

@@ -162,7 +162,8 @@ def _load_or_create_tentacles(config, logger):
     if os.path.isfile(tentacles_manager_constants.USER_REFERENCE_TENTACLE_CONFIG_FILE_PATH):
         config.load_profiles_if_possible_and_necessary()
         tentacles_setup_config = tentacles_manager_api.get_tentacles_setup_config(
-            config.get_tentacles_config_path())
+            config.get_tentacles_config_path()
+        )
         commands.run_update_or_repair_tentacles_if_necessary(config, tentacles_setup_config)
     else:
         # when no tentacles folder has been found

octobot/commands.py

@@ -92,16 +92,36 @@ def _check_tentacles_install_exit():
         sys.exit(0)
 
 
-async def update_or_repair_tentacles_if_necessary(tentacles_setup_config, config):
-    if not tentacles_manager_api.are_tentacles_up_to_date(tentacles_setup_config, constants.VERSION):
-        logging.get_logger(COMMANDS_LOGGER_NAME).info("OctoBot tentacles are not up to date. Updating tentacles...")
+def _get_first_non_imported_profile_tentacles_setup_config(config):
+    return tentacles_manager_api.get_tentacles_setup_config(
+        config.get_non_imported_profiles()[0].get_tentacles_config_path()
+    )
+
+
+async def update_or_repair_tentacles_if_necessary(selected_profile_tentacles_setup_config, config):
+    local_profile_tentacles_setup_config = selected_profile_tentacles_setup_config
+    logger = logging.get_logger(COMMANDS_LOGGER_NAME)
+    if config.profile.imported:
+        if not tentacles_manager_api.are_tentacles_up_to_date(selected_profile_tentacles_setup_config,
+                                                              constants.VERSION):
+            selected_profile_tentacles_version = tentacles_manager_api.get_tentacles_installation_version(
+                selected_profile_tentacles_setup_config
+            )
+            logger.warning(f"Current imported profile \"{config.profile.name}\" references tentacles in a different "
+                           f"version from the current OctoBot. Referenced version: "
+                           f"{selected_profile_tentacles_version}, current OctoBot version: {constants.VERSION}. "
+                           f"This profile might not work properly.")
+            # only update tentacles based on local (non imported) profiles tentacles installation version
+            local_profile_tentacles_setup_config = _get_first_non_imported_profile_tentacles_setup_config(config)
+    if not tentacles_manager_api.are_tentacles_up_to_date(local_profile_tentacles_setup_config, constants.VERSION):
+        logger.info("OctoBot tentacles are not up to date. Updating tentacles...")
         _check_tentacles_install_exit()
         if await install_or_update_tentacles(config):
-            logging.get_logger(COMMANDS_LOGGER_NAME).info("OctoBot tentacles are now up to date.")
+            logger.info("OctoBot tentacles are now up to date.")
     elif tentacles_manager_api.load_tentacles(verbose=True):
-        logging.get_logger(COMMANDS_LOGGER_NAME).debug("OctoBot tentacles are up to date.")
+        logger.debug("OctoBot tentacles are up to date.")
     else:
-        logging.get_logger(COMMANDS_LOGGER_NAME).info("OctoBot tentacles are damaged. Installing default tentacles ...")
+        logger.info("OctoBot tentacles are damaged. Installing default tentacles ...")
         _check_tentacles_install_exit()
         await install_or_update_tentacles(config)
 

octobot/community/authentication.py

@@ -39,6 +39,7 @@ class CommunityAuthentication(authentication.Authenticator):
     """
     ALLOWED_TIME_DELAY = 1 * commons_constants.MINUTE_TO_SECONDS
     LOGIN_TIMEOUT = 20
+    DEVICE_NOT_FOUND_RETRY_DELAY = 1
     AUTHORIZATION_HEADER = "authorization"
     SESSION_HEADER = "X-Session"
     GQL_AUTHORIZATION_HEADER = "Authorization"
@@ -111,8 +112,11 @@ async def _ensure_init_community_feed(self):
             await self._community_feed.start()
 
     async def register_feed_callback(self, channel_type, callback, identifier=None):
-        await self._ensure_init_community_feed()
-        await self._community_feed.register_feed_callback(channel_type, callback, identifier=identifier)
+        try:
+            await self._ensure_init_community_feed()
+            await self._community_feed.register_feed_callback(channel_type, callback, identifier=identifier)
+        except errors.DeviceError as e:
+            self.logger.error(f"Impossible to connect to community signals: {e}")
 
     async def send(self, message, channel_type, identifier=None):
         """
@@ -229,25 +233,36 @@ async def update_selected_device(self):
         self.user_account.flush_device_details()
         await self._load_device_if_selected()
         if not self.user_account.has_selected_device_data():
-            self.logger.info("No selected device. Please select a device to enable your community features.")
+            self.logger.info(self.user_account.NO_SELECTED_DEVICE_DESC)
 
     async def _load_device_if_selected(self):
         # 1. use user selected device id if any
         if saved_uuid := self._get_saved_gql_device_id():
-            await self.select_device(saved_uuid)
-        else:
-            # 2. fetch all user devices and create one if none, otherwise ask use for which one to use
-            await self.load_user_devices()
-            if len(self.user_account.get_all_user_devices_raw_data()) == 0:
-                await self.select_device(
-                    self.user_account.get_device_id(
-                        await self.create_new_device()
-                    )
+            try:
+                await self.select_device(saved_uuid)
+                return
+            except errors.DeviceNotFoundError:
+                # proceed to 2.
+                pass
+        # 2. fetch all user devices and create one if none, otherwise ask use for which one to use
+        await self.load_user_devices()
+        if len(self.user_account.get_all_user_devices_raw_data()) == 0:
+            await self.select_device(
+                self.user_account.get_device_id(
+                    await self.create_new_device()
                 )
-            # more than one possible device, can't auto-select one
+            )
+        # more than one possible device, can't auto-select one
 
     async def select_device(self, device_id):
-        self.user_account.set_selected_device_raw_data(await self.fetch_device(device_id))
+        fetched_device = await self.fetch_device(device_id)
+        if fetched_device is None:
+            # retry after some time, if still None, there is an issue
+            await asyncio.sleep(self.DEVICE_NOT_FOUND_RETRY_DELAY)
+            fetched_device = await self.fetch_device(device_id)
+        if fetched_device is None:
+            raise errors.DeviceNotFoundError(f"Can't find device with id: {device_id}")
+        self.user_account.set_selected_device_raw_data(fetched_device)
         self.user_account.gql_device_id = device_id
         self._save_gql_device_id(self.user_account.gql_device_id)
         await self.on_new_device_select()

octobot/community/community_user_account.py

@@ -14,10 +14,13 @@
 #  You should have received a copy of the GNU General Public
 #  License along with OctoBot. If not, see <https://www.gnu.org/licenses/>.
 import octobot.community.community_supports as community_supports
+import octobot.community.errors as errors
 
 
 class CommunityUserAccount:
     USER_DATA_CONTENT = "content"
+    NO_SELECTED_DEVICE_DESC = "No selected device. Please select a device to enable your community features."
+
 
     def __init__(self):
         self.gql_user_id = None
@@ -51,7 +54,10 @@ def get_selected_device_raw_data(self):
         return self._selected_device_raw_data
 
     def get_selected_device_uuid(self):
-        return self.get_selected_device_raw_data().get("uuid", None)
+        try:
+            return self.get_selected_device_raw_data().get("uuid", None)
+        except AttributeError:
+            raise errors.DeviceError(self.NO_SELECTED_DEVICE_DESC)
 
     @staticmethod
     def get_device_id(device):

octobot/community/errors.py

@@ -26,3 +26,7 @@ class StatusCodeRequestError(RequestError):
 
 class DeviceError(commons_authentication.UnavailableError):
     pass
+
+
+class DeviceNotFoundError(DeviceError):
+    pass