Merge pull request #1420 from Drakkar-Software/dev

Dev merge

Author: GuillaumeDSM

Evaluator/TA/ai_evaluator/ai.py

@@ -227,12 +227,13 @@ async def ask_gpt(self, preprompt, inputs, symbol, time_frame, candle_time) -> s
                 {} if self.is_backtesting else self.services_config
             )
             service.apply_daily_token_limit_if_possible(self.gpt_tokens_limit)
+            model = self.gpt_model if self.enable_model_selector else None
             resp = await service.get_chat_completion(
                 [
-                    service.create_message("system", preprompt),
-                    service.create_message("user", inputs),
+                    service.create_message("system", preprompt, model=model),
+                    service.create_message("user", inputs, model=model),
                 ],
-                model=self.gpt_model if self.enable_model_selector else None,
+                model=model,
                 exchange=self.exchange_name,
                 symbol=symbol,
                 time_frame=time_frame,

Services/Interfaces/web_interface/advanced_templates/advanced_index.html

@@ -4,6 +4,15 @@
 <br>
 <div class="card text-center w-50 mx-auto">
     <h2 class="card-header">Welcome to OctoBot's advanced interface</h2>
+    {% with messages = get_flashed_messages(with_categories=true) %}
+      {% if messages %}
+            {% for category, message in messages %}
+            <div class="alert alert-{{ 'danger' if category == 'error' else 'success' }}">
+                {{ message }}
+            </div>
+            {% endfor %}
+      {% endif %}
+    {% endwith %}
     <div class="card-body py-4">
         This interface is providing insights on some OctoBot advanced concepts and should be used once OctoBot basic
         features are understood.

Services/Interfaces/web_interface/controllers/community.py

@@ -31,6 +31,7 @@ def community():
         try:
             models.wait_for_login_if_processing()
             logged_in_email = authenticator.get_logged_in_email()
+            all_user_bots = models.get_all_user_bots()
         except (authentication.AuthenticationRequired, authentication.UnavailableError):
             pass
         except Exception as e:
@@ -45,7 +46,7 @@ def community():
             is_donor=bool(authenticator.user_account.supports.is_donor()),
             strategies=strategies,
             current_bots_stats=models.get_current_octobots_stats(),
-            all_user_bots=models.get_all_user_bots(),
+            all_user_bots=all_user_bots,
             selected_user_bot=models.get_selected_user_bot(),
             can_logout=models.can_logout(),
             can_select_bot=models.can_select_bot(),

Services/Interfaces/web_interface/login/web_login_manager.py

@@ -105,10 +105,10 @@ def active_login_required(func):
     def decorated_view(*args, **kwargs):
         if is_login_required():
             return _login_required_func(func, *args, **kwargs)
-        flask.flash("For security reasons, please enable password authentication in "
-                    "accounts configuration to use this page.",
+        flask.flash(f"For security reasons, please enable password authentication in "
+                    f"accounts configuration to use the {flask.request.path} page.",
                     category=flask_login.LOGIN_MESSAGE_CATEGORY)
-        return flask.redirect(flask.current_app.login_manager.login_view)
+        return flask.redirect('home')
     return decorated_view
 
 

Services/Interfaces/web_interface/websockets/abstract_websocket_namespace_notifier.py

@@ -38,10 +38,10 @@ def on_connect(self):
         self.clients_count += 1
         self.logger.debug(f"Client connected. {self.clients_count} total clients.")
 
-    def on_disconnect(self):
+    def on_disconnect(self, reason):
         # will be called after some time (requires timeout)
         self.clients_count -= 1
-        self.logger.debug(f"Client disconnected. {self.clients_count} remaining clients.")
+        self.logger.debug(f"Client disconnected ({reason}). {self.clients_count} remaining clients.")
 
     def _has_clients(self):
         return self.clients_count > 0

Services/Services_bases/gpt_service/gpt.py

@@ -15,6 +15,8 @@
 #  License along with this library.
 import asyncio
 import os
+import uuid
+
 import openai
 import logging
 import datetime
@@ -26,6 +28,7 @@
 
 import octobot_commons.constants as commons_constants
 import octobot_commons.enums as commons_enums
+import octobot_commons.logging as commons_logging
 import octobot_commons.time_frame_manager as time_frame_manager
 import octobot_commons.authentication as authentication
 import octobot_commons.tree as tree
@@ -38,6 +41,16 @@
 octobot_services.util.patch_openai_proxies()
 
 
+NO_SYSTEM_PROMPT_MODELS = [
+    "o1-mini",
+]
+MINIMAL_PARAMS_MODELS = [
+    "o1-mini",
+]
+SYSTEM = "system"
+USER = "user"
+
+
 class GPTService(services.AbstractService):
     BACKTESTING_ENABLED = True
     DEFAULT_MODEL = "gpt-3.5-turbo"
@@ -47,7 +60,10 @@ def get_fields_description(self):
         if self._env_secret_key is None:
             return {
                 services_constants.CONIG_OPENAI_SECRET_KEY: "Your openai API secret key",
-                services_constants.CONIG_LLM_CUSTOM_BASE_URL: "Custom LLM base url to use. Leave empty to use openai.com",
+                services_constants.CONIG_LLM_CUSTOM_BASE_URL: (
+                    "Custom LLM base url to use. Leave empty to use openai.com. For Ollama models, "
+                    "add /v1 to the url (such as: http://localhost:11434/v1)"
+                ),
             }
         return {}
 
@@ -75,7 +91,12 @@ def __init__(self):
         self.last_consumed_token_date = None
 
     @staticmethod
-    def create_message(role, content):
+    def create_message(role, content, model: str = None):
+        if role == SYSTEM and model in NO_SYSTEM_PROMPT_MODELS:
+            commons_logging.get_logger(GPTService.__name__).debug(
+                f"Overriding prompt to use {USER} instead of {SYSTEM} for {model}"
+            )
+            return {"role": USER, "content": content}
         return {"role": role, "content": content}
 
     async def get_chat_completion(
@@ -124,12 +145,18 @@ async def _get_signal_from_gpt(
         self._ensure_rate_limit()
         try:
             model = model or self.model
+            supports_params = model not in MINIMAL_PARAMS_MODELS
+            if not supports_params:
+                self.logger.info(
+                    f"The {model} model does not support every required parameter, results might not be as accurate "
+                    f"as with other models."
+                )
             completions = await self._get_client().chat.completions.create(
                 model=model,
-                max_tokens=max_tokens,
+                max_tokens=max_tokens if supports_params else openai.NOT_GIVEN,
                 n=n,
                 stop=stop,
-                temperature=temperature,
+                temperature=temperature if supports_params else openai.NOT_GIVEN,
                 messages=messages
             )
             self._update_token_usage(completions.usage.total_tokens)
@@ -138,9 +165,15 @@ async def _get_signal_from_gpt(
             openai.BadRequestError, # error in request
             openai.UnprocessableEntityError # error in model (ex: model not found)
         )as err:
-            raise errors.InvalidRequestError(
-                f"Error when running request with model {model} (invalid request): {err}"
-            ) from err
+            if "does not support 'system' with this model" in str(err):
+                desc = err.body.get("message", str(err))
+                err_message = (
+                    f"The \"{model}\" model can't be used with {SYSTEM} prompts. "
+                    f"It should be added to NO_SYSTEM_PROMPT_MODELS: {desc}"
+            )
+            else:
+                err_message = f"Error when running request with model {model} (invalid request): {err}"
+            raise errors.InvalidRequestError(err_message) from err
         except openai.AuthenticationError as err:
             self.logger.error(f"Invalid OpenAI api key: {err}")
             self.creation_error_message = err
@@ -284,7 +317,7 @@ def _update_token_usage(self, consumed_tokens):
         self.logger.debug(f"Consumed {consumed_tokens} tokens. {self.consumed_daily_tokens} consumed tokens today.")
 
     def check_required_config(self, config):
-        if self._env_secret_key is not None or self.use_stored_signals_only():
+        if self._env_secret_key is not None or self.use_stored_signals_only() or self._get_base_url():
             return True
         try:
             config_key = config[services_constants.CONIG_OPENAI_SECRET_KEY]
@@ -319,10 +352,18 @@ def get_logo(self):
         return "https://upload.wikimedia.org/wikipedia/commons/0/04/ChatGPT_logo.svg"
 
     def _get_api_key(self):
-        return self._env_secret_key or \
-            self.config[services_constants.CONFIG_CATEGORY_SERVICES][services_constants.CONFIG_GPT][
-                services_constants.CONIG_OPENAI_SECRET_KEY
-            ]
+        key = (
+            self._env_secret_key or
+            self.config[services_constants.CONFIG_CATEGORY_SERVICES][services_constants.CONFIG_GPT].get(
+                services_constants.CONIG_OPENAI_SECRET_KEY, None
+            )
+        )
+        if key and not fields_utils.has_invalid_default_config_value(key):
+            return key
+        if self._get_base_url():
+            # no key and custom base url: use random key
+            return uuid.uuid4().hex
+        return key
 
     def _get_base_url(self):
         value = self.config[services_constants.CONFIG_CATEGORY_SERVICES][services_constants.CONFIG_GPT].get(
@@ -337,20 +378,28 @@ async def prepare(self) -> None:
             if self.use_stored_signals_only():
                 self.logger.info(f"Skipping GPT - OpenAI models fetch as self.use_stored_signals_only() is True")
                 return
+            if self._get_base_url():
+                self.logger.info(f"Using custom LLM url: {self._get_base_url()}")
             fetched_models = await self._get_client().models.list()
             self.models = [d.id for d in fetched_models.data]
             if self.model not in self.models:
-                self.logger.warning(
-                    f"Warning: the default '{self.model}' model is not in available LLM models from the "
-                    f"selected LLM provider. "
-                    f"Available models are: {self.models}. Please select an available model when configuring your "
-                    f"evaluators."
-                )
+                if self._get_base_url():
+                    self.logger.info(
+                        f"Custom LLM available models are: {self.models}. "
+                        f"Please select one of those in your evaluator configuration."
+                    )
+                else:
+                    self.logger.warning(
+                        f"Warning: the default '{self.model}' model is not in available LLM models from the "
+                        f"selected LLM provider. "
+                        f"Available models are: {self.models}. Please select an available model when configuring your "
+                        f"evaluators."
+                    )
         except openai.AuthenticationError as err:
             self.logger.error(f"Invalid OpenAI api key: {err}")
             self.creation_error_message = err
         except Exception as err:
-            self.logger.error(f"Unexpected error when checking api key: {err}")
+            self.logger.exception(err, True, f"Unexpected error when initializing GPT service: {err}")
 
     def _is_healthy(self):
         return self.use_stored_signals_only() or (self._get_api_key() and self.models)

Trading/Exchange/binance/binance_exchange.py

@@ -90,6 +90,10 @@ class Binance(exchanges.RestExchange):
         # binance {"code":-2021,"msg":"Order would immediately trigger."}
         ("order would immediately trigger", )
     ]
+    # text content of errors due to an order that can't be cancelled on exchange (because filled or already cancelled)
+    EXCHANGE_ORDER_UNCANCELLABLE_ERRORS: typing.List[typing.Iterable[str]] = [
+        ('Unknown order sent', )
+    ]
 
     BUY_STR = "BUY"
     SELL_STR = "SELL"
@@ -274,8 +278,14 @@ async def set_symbol_margin_type(self, symbol: str, isolated: bool, **kwargs: di
 
 
 class BinanceCCXTAdapter(exchanges.CCXTAdapter):
-    STOP_MARKET = 'stop_market'
-    STOP_ORDERS = [STOP_MARKET]
+    STOP_ORDERS = [
+        "stop_market", "stop", # futures
+        "stop_loss", "stop_loss_limit"  # spot
+    ]
+    TAKE_PROFITS_ORDERS = [
+        "take_profit_market", "take_profit_limit",    # futures
+        "take_profit"  # spot
+    ]
     BINANCE_DEFAULT_FUNDING_TIME = 8 * commons_constants.HOURS_TO_SECONDS
 
     def fix_order(self, raw, symbol=None, **kwargs):
@@ -287,15 +297,34 @@ def fix_order(self, raw, symbol=None, **kwargs):
         return fixed
 
     def _adapt_order_type(self, fixed):
-        if fixed.get(ccxt_enums.ExchangeOrderCCXTColumns.TYPE.value, None) in self.STOP_ORDERS:
-            stop_price = fixed.get(ccxt_enums.ExchangeOrderCCXTColumns.STOP_PRICE.value, None)
-            updated_type = trading_enums.TradeOrderType.UNKNOWN.value
-            if stop_price is not None:
-                updated_type = trading_enums.TradeOrderType.STOP_LOSS.value
-            else:
-                self.logger.error(f"Unknown order type, order: {fixed}")
-            # stop loss and take profits are not tagged as such by ccxt, force it
-            fixed[trading_enums.ExchangeConstantsOrderColumns.TYPE.value] = updated_type
+        if order_type := fixed.get(ccxt_enums.ExchangeOrderCCXTColumns.TYPE.value, None):
+            is_stop = order_type.lower() in self.STOP_ORDERS
+            is_tp = order_type.lower() in self.TAKE_PROFITS_ORDERS
+            if is_stop or is_tp:
+                stop_price = fixed.get(ccxt_enums.ExchangeOrderCCXTColumns.STOP_PRICE.value, None)
+                selling = (
+                    fixed.get(ccxt_enums.ExchangeOrderCCXTColumns.SIDE.value, None)
+                    == trading_enums.TradeOrderSide.SELL.value
+                )
+                updated_type = trading_enums.TradeOrderType.UNKNOWN.value
+                trigger_above = False
+                if is_stop:
+                    updated_type = trading_enums.TradeOrderType.STOP_LOSS.value
+                    trigger_above = not selling # sell stop loss triggers when price is lower than target
+                elif is_tp:
+                    # updated_type = trading_enums.TradeOrderType.TAKE_PROFIT.value
+                    # take profits are not yet handled as such: consider them as limit orders
+                    updated_type = trading_enums.TradeOrderType.LIMIT.value # waiting for TP handling
+                    if not fixed[trading_enums.ExchangeConstantsOrderColumns.PRICE.value]:
+                        fixed[trading_enums.ExchangeConstantsOrderColumns.PRICE.value] = stop_price # waiting for TP handling
+                    trigger_above = selling # sell take profit triggers when price is higher than target
+                else:
+                    self.logger.error(
+                        f"Unknown [{self.connector.exchange_manager.exchange_name}] order type, order: {fixed}"
+                    )
+                # stop loss and take profits are not tagged as such by ccxt, force it
+                fixed[trading_enums.ExchangeConstantsOrderColumns.TYPE.value] = updated_type
+                fixed[trading_enums.ExchangeConstantsOrderColumns.TRIGGER_ABOVE.value] = trigger_above
         return fixed
 
     def fix_trades(self, raw, **kwargs):

Trading/Exchange/bingx/bingx_exchange.py

@@ -30,12 +30,19 @@ class Bingx(exchanges.RestExchange):
         # bingx {"code":100404,"msg":"the order you want to cancel is FILLED or CANCELLED already, or is not a valid
         # order id ,please verify","debugMsg":""}
         ("the order you want to cancel is filled or cancelled already", ),
+        #  bingx {"code":100404,"msg":"the order is FILLED or CANCELLED already before, or is not a valid
+        #  order id ,please verify","debugMsg":""}
+        ("the order is filled or cancelled already before", ),
     ]
     # text content of errors due to unhandled authentication issues
     EXCHANGE_AUTHENTICATION_ERRORS: typing.List[typing.Iterable[str]] = [
         # 'bingx {'code': '100413', 'msg': 'Incorrect apiKey', 'timestamp': '1725195218082'}'
         ("incorrect apikey",),
     ]
+    # text content of errors due to an order that can't be cancelled on exchange (because filled or already cancelled)
+    EXCHANGE_ORDER_UNCANCELLABLE_ERRORS: typing.List[typing.Iterable[str]] = [
+        ('the order is filled or cancelled', )
+    ]
 
     # Set True when get_open_order() can return outdated orders (cancelled or not yet created)
     CAN_HAVE_DELAYED_CANCELLED_ORDERS = True
@@ -117,17 +124,36 @@ def _update_stop_order_or_trade_type_and_price(self, order_or_trade: dict):
                     trading_enums.ExchangeConstantsOrderColumns.PRICE.value
                 )
             )
+            is_selling = (
+                order_or_trade[trading_enums.ExchangeConstantsOrderColumns.SIDE.value]
+                == trading_enums.TradeOrderSide.SELL.value
+            )
             stop_price = float(stop_price)
             # use stop price as order price to parse it properly
             order_or_trade[trading_enums.ExchangeConstantsOrderColumns.PRICE.value] = stop_price
             # type is TAKE_STOP_LIMIT (not unified)
-            if order_or_trade.get(trading_enums.ExchangeConstantsOrderColumns.TYPE.value) not in (
-                trading_enums.TradeOrderType.STOP_LOSS.value, trading_enums.TradeOrderType.TAKE_PROFIT.value
-            ):
+            if order_or_trade.get(trading_enums.ExchangeConstantsOrderColumns.TYPE.value) == "take_stop_limit":
+                # unsupported: no way to figure out if this order is a stop loss or a take profit
+                # (trigger above or bellow)
+                order_or_trade[trading_enums.ExchangeConstantsOrderColumns.TYPE.value] = (
+                    trading_enums.TradeOrderType.UNSUPPORTED.value)
+                self.logger.info(f"Unsupported order fetched: {order_or_trade}")
+            else:
                 if stop_price <= order_creation_price:
-                     order_type = trading_enums.TradeOrderType.STOP_LOSS.value
+                    trigger_above = False
+                    if is_selling:
+                        order_type = trading_enums.TradeOrderType.STOP_LOSS.value
+                        order_or_trade[trading_enums.ExchangeConstantsOrderColumns.STOP_PRICE.value] = stop_price
+                    else:
+                        order_type = trading_enums.TradeOrderType.LIMIT.value
                 else:
-                    order_type = trading_enums.TradeOrderType.TAKE_PROFIT.value
+                    trigger_above = True
+                    if is_selling:
+                        order_type = trading_enums.TradeOrderType.LIMIT.value
+                    else:
+                        order_type = trading_enums.TradeOrderType.STOP_LOSS.value
+                        order_or_trade[trading_enums.ExchangeConstantsOrderColumns.STOP_PRICE.value] = stop_price
+                order_or_trade[trading_enums.ExchangeConstantsOrderColumns.TRIGGER_ABOVE.value] = trigger_above
                 order_or_trade[trading_enums.ExchangeConstantsOrderColumns.TYPE.value] = order_type
 
     def fix_order(self, raw, **kwargs):

Trading/Exchange/bybit/bybit_exchange.py

@@ -402,7 +402,7 @@ def _adapt_order_type(self, fixed):
                 fixed[trading_enums.ExchangeConstantsOrderColumns.TYPE.value] = \
                     trading_enums.TradeOrderType.STOP_LOSS.value
             else:
-                self.logger.error(f"Unknown trigger order: {fixed}")
+                self.logger.error(f"Unknown [{self.connector.exchange_manager.exchange_name}] trigger order: {fixed}")
         return fixed
 
     def fix_ticker(self, raw, **kwargs):