[GPT] enable historical signals fetch

Evaluator/TA/ai_evaluator/ai.py

@@ -31,28 +31,31 @@
 
 
 class GPTEvaluator(evaluators.TAEvaluator):
+    GLOBAL_VERSION = 1
     PREPROMPT = "Predict: {up or down} {confidence%} (no other information)"
     PASSED_DATA_LEN = 10
+    MAX_CONFIDENCE_PERCENT = 100
     HIGH_CONFIDENCE_PERCENT = 80
     MEDIUM_CONFIDENCE_PERCENT = 50
     LOW_CONFIDENCE_PERCENT = 30
     INDICATORS = {
-        "No indicator: the raw value of the selected source": lambda data, period: data,
+        "No indicator: raw candles price data": lambda data, period: data,
         "EMA: Exponential Moving Average": tulipy.ema,
         "SMA: Simple Moving Average": tulipy.sma,
         "Kaufman Adaptive Moving Average": tulipy.kama,
         "Hull Moving Average": tulipy.kama,
         "RSI: Relative Strength Index": tulipy.rsi,
         "Detrended Price Oscillator": tulipy.dpo,
     }
-    SOURCES = ["Open", "High", "Low", "Close", "Volume"]
+    SOURCES = ["Open", "High", "Low", "Close", "Volume", "Full candle (For no indicator only)"]
     GPT_MODELS = []
 
     def __init__(self, tentacles_setup_config):
         super().__init__(tentacles_setup_config)
         self.indicator = None
         self.source = None
         self.period = None
+        self.min_confidence_threshold = 0
         self.gpt_model = gpt_service.GPTService.DEFAULT_MODEL
         self.is_backtesting = False
         self.min_allowed_timeframe = os.getenv("MIN_GPT_TIMEFRAME", None)
@@ -65,13 +68,21 @@ def __init__(self, tentacles_setup_config):
         except ValueError:
             self.logger.error(f"Invalid timeframe configuration: unknown timeframe: '{self.min_allowed_timeframe}'")
         self.allow_reevaluations = os_util.parse_boolean_environment_var("ALLOW_GPT_REEVALUATIONS", "True")
+        self.services_config = None
 
     def enable_reevaluation(self) -> bool:
         """
         Override when artificial re-evaluations from the evaluator channel can be disabled
         """
         return self.allow_reevaluations
 
+    @classmethod
+    def get_signals_history_type(cls):
+        """
+        Override when this evaluator uses a specific type of signal history
+        """
+        return commons_enums.SignalHistoryTypes.GPT
+
     async def load_and_save_user_inputs(self, bot_id: str) -> dict:
         """
         instance method API for user inputs
@@ -98,7 +109,12 @@ def init_user_inputs(self, inputs: dict) -> None:
         self.period = self.UI.user_input(
             "period", enums.UserInputTypes.INT,
             self.period, inputs, min_val=1,
-            title="Period: length of the indicator period."
+            title="Period: length of the indicator period or the number of candles to give to ChatGPT."
+        )
+        self.min_confidence_threshold = self.UI.user_input(
+            "min_confidence_threshold", enums.UserInputTypes.INT,
+            self.min_confidence_threshold, inputs, min_val=0, max_val=100,
+            title="Minimum confidence threshold: % confidence value starting from which to return 1 or -1."
         )
         if len(self.GPT_MODELS) > 1 and self.enable_model_selector:
             self.gpt_model = self.UI.user_input(
@@ -112,7 +128,9 @@ async def _init_GPT_models(self):
             self.GPT_MODELS = [gpt_service.GPTService.DEFAULT_MODEL]
             if self.enable_model_selector and not self.is_backtesting:
                 try:
-                    service = await services_api.get_service(gpt_service.GPTService, self.is_backtesting)
+                    service = await services_api.get_service(
+                        gpt_service.GPTService, self.is_backtesting, self.services_config
+                    )
                     self.GPT_MODELS = service.models
                 except Exception as err:
                     self.logger.exception(err, True, f"Impossible to fetch GPT models: {err}")
@@ -128,67 +146,110 @@ async def _init_registered_topics(self, all_symbols_by_crypto_currencies, curren
 
     async def ohlcv_callback(self, exchange: str, exchange_id: str,
                              cryptocurrency: str, symbol: str, time_frame, candle, inc_in_construction_data):
-        candle_data = self.get_candles_data_api()(
-            self.get_exchange_symbol_data(exchange, exchange_id, symbol), time_frame,
-            include_in_construction=inc_in_construction_data
-        )
+        candle_data = self.get_candles_data(exchange, exchange_id, symbol, time_frame, inc_in_construction_data)
         await self.evaluate(cryptocurrency, symbol, time_frame, candle_data, candle)
 
     async def evaluate(self, cryptocurrency, symbol, time_frame, candle_data, candle):
-        self.eval_note = commons_constants.START_PENDING_EVAL_NOTE
-        if self._check_timeframe(time_frame):
-            try:
-                computed_data = self.call_indicator(candle_data)
-                reduced_data = computed_data[-self.PASSED_DATA_LEN:]
-                formatted_data = ", ".join(str(datum).replace('[', '').replace(']', '') for datum in reduced_data)
-                prediction = await self.ask_gpt(self.PREPROMPT, formatted_data, symbol, time_frame)
-                cleaned_prediction = prediction.strip().replace("\n", "").replace(".", "").lower()
-                prediction_side = self._parse_prediction_side(cleaned_prediction)
-                if prediction_side == 0:
-                    self.logger.error(f"Error when reading GPT answer: {cleaned_prediction}")
-                    return
-                confidence = self._parse_confidence(cleaned_prediction) / 100
-                self.eval_note = prediction_side * confidence
-            except services_errors.InvalidRequestError as e:
-                self.logger.error(f"Invalid GPT request: {e}")
-            except services_errors.RateLimitError as e:
-                self.logger.error(f"Too many requests: {e}")
-            except services_errors.UnavailableInBacktestingError:
-                # error already logged error for backtesting in use_backtesting_init_timeout
-                pass
-            except evaluators_errors.UnavailableEvaluatorError as e:
-                self.logger.exception(e, True, f"Evaluation error: {e}")
-            except tulipy.lib.InvalidOptionError as e:
-                self.logger.warning(
-                    f"Error when computing {self.indicator} on {self.period} period with {len(candle_data)} "
-                    f"candles: {e}"
-                )
-                self.logger.exception(e, False)
-        else:
-            self.logger.debug(f"Ignored {time_frame} time frame as the shorted allowed time frame is "
-                              f"{self.min_allowed_timeframe}")
-        await self.evaluation_completed(cryptocurrency, symbol, time_frame,
-                                        eval_time=evaluators_util.get_eval_time(full_candle=candle,
-                                                                                time_frame=time_frame))
+        async with self.async_evaluation():
+            self.eval_note = commons_constants.START_PENDING_EVAL_NOTE
+            if self._check_timeframe(time_frame):
+                try:
+                    candle_time = candle[commons_enums.PriceIndexes.IND_PRICE_TIME.value]
+                    computed_data = self.call_indicator(candle_data)
+                    formatted_data = self.get_formatted_data(computed_data)
+                    prediction = await self.ask_gpt(self.PREPROMPT, formatted_data, symbol, time_frame, candle_time)
+                    cleaned_prediction = prediction.strip().replace("\n", "").replace(".", "").lower()
+                    prediction_side = self._parse_prediction_side(cleaned_prediction)
+                    if prediction_side == 0 and not self.is_backtesting:
+                        self.logger.error(f"Error when reading GPT answer: {cleaned_prediction}")
+                        return
+                    confidence = self._parse_confidence(cleaned_prediction) / 100
+                    self.eval_note = prediction_side * confidence
+                except services_errors.InvalidRequestError as e:
+                    self.logger.error(f"Invalid GPT request: {e}")
+                except services_errors.RateLimitError as e:
+                    self.logger.error(f"Too many requests: {e}")
+                except services_errors.UnavailableInBacktestingError:
+                    # error already logged error for backtesting in use_backtesting_init_timeout
+                    pass
+                except evaluators_errors.UnavailableEvaluatorError as e:
+                    self.logger.exception(e, True, f"Evaluation error: {e}")
+                except tulipy.lib.InvalidOptionError as e:
+                    self.logger.warning(
+                        f"Error when computing {self.indicator} on {self.period} period with {len(candle_data)} "
+                        f"candles: {e}"
+                    )
+                    self.logger.exception(e, False)
+            else:
+                self.logger.debug(f"Ignored {time_frame} time frame as the shorted allowed time frame is "
+                                  f"{self.min_allowed_timeframe}")
+            await self.evaluation_completed(cryptocurrency, symbol, time_frame,
+                                            eval_time=evaluators_util.get_eval_time(full_candle=candle,
+                                                                                    time_frame=time_frame))
+
+    def get_formatted_data(self, computed_data) -> str:
+        if self.source in self.get_unformated_sources():
+            return str(computed_data)
+        reduced_data = computed_data[-self.PASSED_DATA_LEN:]
+        return ", ".join(str(datum).replace('[', '').replace(']', '') for datum in reduced_data)
 
-    async def ask_gpt(self, preprompt, inputs, symbol, time_frame) -> str:
+    async def ask_gpt(self, preprompt, inputs, symbol, time_frame, candle_time) -> str:
         try:
-            service = await services_api.get_service(gpt_service.GPTService, self.is_backtesting)
+            service = await services_api.get_service(
+                gpt_service.GPTService,
+                self.is_backtesting,
+                {} if self.is_backtesting else self.services_config
+            )
             resp = await service.get_chat_completion(
                 [
                     service.create_message("system", preprompt),
                     service.create_message("user", inputs),
                 ],
-                model=self.gpt_model if self.enable_model_selector else None
+                model=self.gpt_model if self.enable_model_selector else None,
+                exchange=self.exchange_name,
+                symbol=symbol,
+                time_frame=time_frame,
+                version=self.get_version(),
+                candle_open_time=candle_time,
+                use_stored_signals=self.is_backtesting
             )
             self.logger.info(f"GPT's answer is '{resp}' for {symbol} on {time_frame} with input: {inputs}")
             return resp
         except services_errors.CreationError as err:
             raise evaluators_errors.UnavailableEvaluatorError(f"Impossible to get ChatGPT prediction: {err}") from err
 
+    def get_version(self):
+        # later on, identify by its specs
+        # return f"{self.gpt_model}-{self.source}-{self.indicator}-{self.period}-{self.GLOBAL_VERSION}"
+        return "0.0.0"
+
     def call_indicator(self, candle_data):
+        if self.source in self.get_unformated_sources():
+            return candle_data
         return data_util.drop_nan(self.INDICATORS[self.indicator](candle_data, self.period))
 
+    def get_candles_data(self, exchange, exchange_id, symbol, time_frame, inc_in_construction_data):
+        if self.source in self.get_unformated_sources():
+            limit = self.period if inc_in_construction_data else self.period + 1
+            full_candles = trading_api.get_candles_as_list(
+                trading_api.get_symbol_historical_candles(
+                    self.get_exchange_symbol_data(exchange, exchange_id, symbol), time_frame, limit=limit
+                )
+            )
+            # remove time value
+            for candle in full_candles:
+                candle.pop(commons_enums.PriceIndexes.IND_PRICE_TIME.value)
+            if inc_in_construction_data:
+                return full_candles
+            return full_candles[:-1]
+        return self.get_candles_data_api()(
+            self.get_exchange_symbol_data(exchange, exchange_id, symbol), time_frame,
+            include_in_construction=inc_in_construction_data
+        )
+
+    def get_unformated_sources(self):
+        return (self.SOURCES[5], )
+
     def get_candles_data_api(self):
         return {
             self.SOURCES[0]: trading_api.get_symbol_open_candles,
@@ -216,14 +277,20 @@ def _parse_confidence(self, cleaned_prediction):
         up with 70% confidence
         up with high confidence
         """
+        value = self.LOW_CONFIDENCE_PERCENT
         if "%" in cleaned_prediction:
             percent_index = cleaned_prediction.index("%")
-            return float(cleaned_prediction[:percent_index].split(" ")[-1])
-        if "high" in cleaned_prediction:
-            return self.HIGH_CONFIDENCE_PERCENT
-        if "medium" in cleaned_prediction or "intermediate" in cleaned_prediction:
-            return self.MEDIUM_CONFIDENCE_PERCENT
-        if "low" in cleaned_prediction:
-            return self.LOW_CONFIDENCE_PERCENT
-        self.logger.warning(f"Impossible to parse confidence in {cleaned_prediction}. Using low confidence")
-        return self.LOW_CONFIDENCE_PERCENT
+            value = float(cleaned_prediction[:percent_index].split(" ")[-1])
+        elif "high" in cleaned_prediction:
+            value = self.HIGH_CONFIDENCE_PERCENT
+        elif "medium" in cleaned_prediction or "intermediate" in cleaned_prediction:
+            value = self.MEDIUM_CONFIDENCE_PERCENT
+        elif "low" in cleaned_prediction:
+            value = self.LOW_CONFIDENCE_PERCENT
+        elif not cleaned_prediction:
+            value = 0
+        else:
+            self.logger.warning(f"Impossible to parse confidence in {cleaned_prediction}. Using low confidence")
+        if value >= self.min_confidence_threshold:
+            return self.MAX_CONFIDENCE_PERCENT
+        return value

Evaluator/TA/ai_evaluator/resources/GPTEvaluator.md

@@ -1,5 +1,7 @@
 Uses [Chat GPT](https://chat.openai.com/) to predict the next moves of the market.
 
-Evaluates between -1 to 1 according to chat GPT's prediction of the selected data and its confidence.
+Evaluates between -1 to 1 according to ChatGPT's prediction of the selected data and its confidence.
 
-*This evaluator can't be used in backtesting.*
+Note: this evaluator can only be used in backtesting for markets where historical ChatGPT data are available.
+
+Find the full list of supported historical markets on https://www.octobot.cloud/features/chatgpt-trading

Meta/Keywords/scripting_library/tests/exchanges/__init__.py

@@ -36,7 +36,7 @@ async def fake_backtesting(backtesting_config):
         config=backtesting_config,
         exchange_ids=[],
         matrix_id="",
-        backtesting_files=[]
+        backtesting_files=[],
     )
 
 

Services/Interfaces/web_interface/controllers/configuration.py

@@ -110,9 +110,8 @@ def profiles_management(action):
             return util.get_rest_reply(flask.jsonify(data))
         if action == "duplicate":
             profile_id = flask.request.args.get("profile_id")
-            new_profile = models.duplicate_profile(profile_id)
-            models.select_profile(new_profile.profile_id)
-            flask.flash(f"New profile successfully created and selected.", "success")
+            models.duplicate_profile(profile_id)
+            flask.flash(f"New profile successfully created.", "success")
             return util.get_rest_reply(flask.jsonify("Profile created"))
         if action == "use_as_live":
             profile_id = flask.request.args.get("profile_id")