Merge pull request #8421 from freqtrade/new_release

New release 2023.3
Bump version to 2023.3
2023-03-31 07:09:11 +02:00 · 2023-03-30 06:56:49 +02:00 · 2023-03-30 06:56:35 +02:00 · 2023-02-26 14:53:52 +01:00 · 2023-02-25 16:02:36 +01:00 · 2023-02-25 16:02:26 +01:00
46 changed files with 259 additions and 459 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -425,7 +425,7 @@ jobs:
        python setup.py sdist bdist_wheel

    - name: Publish to PyPI (Test)
-      uses: pypa/gh-action-pypi-publish@v1.8.4
+      uses: pypa/gh-action-pypi-publish@v1.8.3
      if: (github.event_name == 'release')
      with:
        user: __token__
@@ -433,7 +433,7 @@ jobs:
        repository_url: https://test.pypi.org/legacy/

    - name: Publish to PyPI
-      uses: pypa/gh-action-pypi-publish@v1.8.4
+      uses: pypa/gh-action-pypi-publish@v1.8.3
      if: (github.event_name == 'release')
      with:
        user: __token__
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -13,12 +13,12 @@ repos:
      - id: mypy
        exclude: build_helpers
        additional_dependencies:
-          - types-cachetools==5.3.0.5
+          - types-cachetools==5.3.0.4
          - types-filelock==3.2.7
-          - types-requests==2.28.11.17
-          - types-tabulate==0.9.0.2
-          - types-python-dateutil==2.8.19.11
-          - SQLAlchemy==2.0.8
+          - types-requests==2.28.11.16
+          - types-tabulate==0.9.0.1
+          - types-python-dateutil==2.8.19.10
+          - SQLAlchemy==2.0.7
        # stages: [push]

  - repo: https://github.com/pycqa/isort
--- a/2
+++ b/2
@@ -1,4 +1,4 @@
-FROM python:3.10.11-slim-bullseye as base
+FROM python:3.10.10-slim-bullseye as base

 # Setup env
 ENV LANG C.UTF-8
--- a/build_helpers/publish_docker_arm64.sh
+++ b/build_helpers/publish_docker_arm64.sh
@@ -42,9 +42,9 @@ if [ $? -ne 0 ]; then
    return 1
 fi

-docker build --build-arg sourceimage=freqtrade --build-arg sourcetag=${TAG_ARM} -t freqtrade:${TAG_PLOT_ARM} -f docker/Dockerfile.plot .
-docker build --build-arg sourceimage=freqtrade --build-arg sourcetag=${TAG_ARM} -t freqtrade:${TAG_FREQAI_ARM} -f docker/Dockerfile.freqai .
-docker build --build-arg sourceimage=freqtrade --build-arg sourcetag=${TAG_FREQAI_ARM} -t freqtrade:${TAG_FREQAI_RL_ARM} -f docker/Dockerfile.freqai_rl .
+docker build --cache-from freqtrade:${TAG_ARM} --build-arg sourceimage=${CACHE_IMAGE} --build-arg sourcetag=${TAG_ARM} -t freqtrade:${TAG_PLOT_ARM} -f docker/Dockerfile.plot .
+docker build --cache-from freqtrade:${TAG_ARM} --build-arg sourceimage=${CACHE_IMAGE} --build-arg sourcetag=${TAG_ARM} -t freqtrade:${TAG_FREQAI_ARM} -f docker/Dockerfile.freqai .
+docker build --cache-from freqtrade:${TAG_ARM} --build-arg sourceimage=${CACHE_IMAGE} --build-arg sourcetag=${TAG_ARM} -t freqtrade:${TAG_FREQAI_RL_ARM} -f docker/Dockerfile.freqai_rl .

 # Tag image for upload and next build step
 docker tag freqtrade:$TAG_ARM ${CACHE_IMAGE}:$TAG_ARM
--- a/build_helpers/publish_docker_multi.sh
+++ b/build_helpers/publish_docker_multi.sh
@@ -58,9 +58,9 @@ fi
 # Tag image for upload and next build step
 docker tag freqtrade:$TAG ${CACHE_IMAGE}:$TAG

-docker build --build-arg sourceimage=freqtrade --build-arg sourcetag=${TAG} -t freqtrade:${TAG_PLOT} -f docker/Dockerfile.plot .
-docker build --build-arg sourceimage=freqtrade --build-arg sourcetag=${TAG} -t freqtrade:${TAG_FREQAI} -f docker/Dockerfile.freqai .
-docker build --build-arg sourceimage=freqtrade --build-arg sourcetag=${TAG_FREQAI} -t freqtrade:${TAG_FREQAI_RL} -f docker/Dockerfile.freqai_rl .
+docker build --cache-from freqtrade:${TAG} --build-arg sourceimage=${CACHE_IMAGE} --build-arg sourcetag=${TAG} -t freqtrade:${TAG_PLOT} -f docker/Dockerfile.plot .
+docker build --cache-from freqtrade:${TAG} --build-arg sourceimage=${CACHE_IMAGE} --build-arg sourcetag=${TAG} -t freqtrade:${TAG_FREQAI} -f docker/Dockerfile.freqai .
+docker build --cache-from freqtrade:${TAG_FREQAI} --build-arg sourceimage=${CACHE_IMAGE} --build-arg sourcetag=${TAG_FREQAI} -t freqtrade:${TAG_FREQAI_RL} -f docker/Dockerfile.freqai_rl .

 docker tag freqtrade:$TAG_PLOT ${CACHE_IMAGE}:$TAG_PLOT
 docker tag freqtrade:$TAG_FREQAI ${CACHE_IMAGE}:$TAG_FREQAI
--- a/docs/backtesting.md
+++ b/docs/backtesting.md
@@ -274,20 +274,19 @@ A backtesting result will look like that:
 | XRP/BTC  |      35 |           0.66 |          22.96 |       0.00114897 |          11.48 | 3:49:00      |    12     0    23   34.3 |
 | ZEC/BTC  |      22 |          -0.46 |         -10.18 |      -0.00050971 |          -5.09 | 2:22:00      |     7     0    15   31.8 |
 | TOTAL    |     429 |           0.36 |         152.41 |       0.00762792 |          76.20 | 4:12:00      |   186     0   243   43.4 |
-====================================================== LEFT OPEN TRADES REPORT ======================================================
-| Pair     |  Entries |   Avg Profit % |   Cum Profit % |   Tot Profit BTC |   Tot Profit % | Avg Duration   |  Win Draw Loss Win% |
-|:---------|---------:|---------------:|---------------:|-----------------:|---------------:|:---------------|--------------------:|
-| ADA/BTC  |        1 |           0.89 |           0.89 |       0.00004434 |           0.44 | 6:00:00        |    1    0    0  100 |
-| LTC/BTC  |        1 |           0.68 |           0.68 |       0.00003421 |           0.34 | 2:00:00        |    1    0    0  100 |
-| TOTAL    |        2 |           0.78 |           1.57 |       0.00007855 |           0.78 | 4:00:00        |    2    0    0  100 |
-==================== EXIT REASON STATS ====================
+========================================================= EXIT REASON STATS ==========================================================
 | Exit Reason        |   Exits |  Wins |  Draws |  Losses |
 |:-------------------|--------:|------:|-------:|--------:|
 | trailing_stop_loss |     205 |   150 |      0 |      55 |
 | stop_loss          |     166 |     0 |      0 |     166 |
 | exit_signal        |      56 |    36 |      0 |      20 |
 | force_exit         |       2 |     0 |      0 |       2 |
-
+====================================================== LEFT OPEN TRADES REPORT ======================================================
+| Pair     |  Entries |   Avg Profit % |   Cum Profit % |   Tot Profit BTC |   Tot Profit % | Avg Duration   |  Win Draw Loss Win% |
+|:---------|---------:|---------------:|---------------:|-----------------:|---------------:|:---------------|--------------------:|
+| ADA/BTC  |        1 |           0.89 |           0.89 |       0.00004434 |           0.44 | 6:00:00        |    1    0    0  100 |
+| LTC/BTC  |        1 |           0.68 |           0.68 |       0.00003421 |           0.34 | 2:00:00        |    1    0    0  100 |
+| TOTAL    |        2 |           0.78 |           1.57 |       0.00007855 |           0.78 | 4:00:00        |    2    0    0  100 |
 ================== SUMMARY METRICS ==================
 | Metric                      | Value               |
 |-----------------------------+---------------------|
--- a/docs/freqai-feature-engineering.md
+++ b/docs/freqai-feature-engineering.md
@@ -6,8 +6,8 @@ Low level feature engineering is performed in the user strategy within a set of

 |  Function | Description |
 |---------------|-------------|
-| `feature_engineering_expand_all()` | This optional function will automatically expand the defined features on the config defined `indicator_periods_candles`, `include_timeframes`, `include_shifted_candles`, and `include_corr_pairs`.
-| `feature_engineering_expand_basic()` | This optional function will automatically expand the defined features on the config defined `include_timeframes`, `include_shifted_candles`, and `include_corr_pairs`. Note: this function does *not* expand across `include_periods_candles`.
+| `feature_engineering__expand_all()` | This optional function will automatically expand the defined features on the config defined `indicator_periods_candles`, `include_timeframes`, `include_shifted_candles`, and `include_corr_pairs`.
+| `feature_engineering__expand_basic()` | This optional function will automatically expand the defined features on the config defined `include_timeframes`, `include_shifted_candles`, and `include_corr_pairs`. Note: this function does *not* expand across `include_periods_candles`.
 | `feature_engineering_standard()` | This optional function will be called once with the dataframe of the base timeframe. This is the final function to be called, which means that the dataframe entering this function will contain all the features and columns from the base asset created by the other `feature_engineering_expand` functions. This function is a good place to do custom exotic feature extractions (e.g. tsfresh). This function is also a good place for any feature that should not be auto-expanded upon (e.g., day of the week).
 | `set_freqai_targets()` | Required function to set the targets for the model. All targets must be prepended with `&` to be recognized by the FreqAI internals.

@@ -182,11 +182,11 @@ In total, the number of features the user of the presented example strat has cre
 $= 3 * 3 * 3 * 2 * 2 = 108$.


-### Gain finer control over `feature_engineering_*` functions with `metadata`
+ ### Gain finer control over `feature_engineering_*` functions with `metadata`

 All `feature_engineering_*` and `set_freqai_targets()` functions are passed a `metadata` dictionary which contains information about the `pair`, `tf` (timeframe), and `period` that FreqAI is automating for feature building. As such, a user can use `metadata` inside `feature_engineering_*` functions as criteria for blocking/reserving features for certain timeframes, periods, pairs etc.

- ```python
+ ```py
 def feature_engineering_expand_all(self, dataframe, period, metadata, **kwargs):
 if metadata["tf"] == "1h":
    dataframe["%-roc-period"] = ta.ROC(dataframe, timeperiod=period)
--- a/docs/freqai-reinforcement-learning.md
+++ b/docs/freqai-reinforcement-learning.md
@@ -180,7 +180,7 @@ As you begin to modify the strategy and the prediction model, you will quickly r

                # you can use feature values from dataframe
                # Assumes the shifted RSI indicator has been generated in the strategy.
-                rsi_now = self.raw_features[f"%-rsi-period_10_shift-1_{pair}_"
+                rsi_now = self.raw_features[f"%-rsi-period-10_shift-1_{pair}_"
                                f"{self.config['timeframe']}"].iloc[self._current_tick]

                # reward agent for entering trades
--- a/docs/requirements-docs.txt
+++ b/docs/requirements-docs.txt
@@ -1,6 +1,6 @@
 markdown==3.3.7
 mkdocs==1.4.2
-mkdocs-material==9.1.5
+mkdocs-material==9.1.4
 mdx_truly_sane_lists==1.3
 pymdown-extensions==9.10
 jinja2==3.1.2
--- a/docs/rest-api.md
+++ b/docs/rest-api.md
@@ -9,6 +9,9 @@ This same command can also be used to update freqUI, should there be a new relea

 Once the bot is started in trade / dry-run mode (with `freqtrade trade`) - the UI will be available under the configured port below (usually `http://127.0.0.1:8080`).

+!!! info "Alpha release"
+    FreqUI is still considered an alpha release - if you encounter bugs or inconsistencies please open a [FreqUI issue](https://github.com/freqtrade/frequi/issues/new/choose).
+
 !!! Note "developers"
    Developers should not use this method, but instead use the method described in the [freqUI repository](https://github.com/freqtrade/frequi) to get the source-code of freqUI.

--- a/freqtrade/init.py
+++ b/freqtrade/init.py
@@ -1,5 +1,5 @@
 """ Freqtrade bot """
-__version__ = '2023.4.dev'
+__version__ = '2023.3'

 if 'dev' in __version__:
    from pathlib import Path
--- a/freqtrade/constants.py
+++ b/freqtrade/constants.py
@@ -598,7 +598,7 @@ CONF_SCHEMA = {
                        "model_type": {"type": "string", "default": "PPO"},
                        "policy_type": {"type": "string", "default": "MlpPolicy"},
                        "net_arch": {"type": "array", "default": [128, 128]},
-                        "randomize_starting_position": {"type": "boolean", "default": False},
+                        "randomize_startinng_position": {"type": "boolean", "default": False},
                        "model_reward_parameters": {
                            "type": "object",
                            "properties": {
--- a/freqtrade/exchange/init.py
+++ b/freqtrade/exchange/init.py
@@ -8,15 +8,15 @@ from freqtrade.exchange.bitpanda import Bitpanda
 from freqtrade.exchange.bittrex import Bittrex
 from freqtrade.exchange.bybit import Bybit
 from freqtrade.exchange.coinbasepro import Coinbasepro
-from freqtrade.exchange.exchange_utils import (ROUND_DOWN, ROUND_UP, amount_to_contract_precision,
-                                               amount_to_contracts, amount_to_precision,
-                                               available_exchanges, ccxt_exchanges,
-                                               contracts_to_amount, date_minus_candles,
-                                               is_exchange_known_ccxt, market_is_active,
-                                               price_to_precision, timeframe_to_minutes,
-                                               timeframe_to_msecs, timeframe_to_next_date,
-                                               timeframe_to_prev_date, timeframe_to_seconds,
-                                               validate_exchange, validate_exchanges)
+from freqtrade.exchange.exchange_utils import (amount_to_contract_precision, amount_to_contracts,
+                                               amount_to_precision, available_exchanges,
+                                               ccxt_exchanges, contracts_to_amount,
+                                               date_minus_candles, is_exchange_known_ccxt,
+                                               market_is_active, price_to_precision,
+                                               timeframe_to_minutes, timeframe_to_msecs,
+                                               timeframe_to_next_date, timeframe_to_prev_date,
+                                               timeframe_to_seconds, validate_exchange,
+                                               validate_exchanges)
 from freqtrade.exchange.gate import Gate
 from freqtrade.exchange.hitbtc import Hitbtc
 from freqtrade.exchange.huobi import Huobi
--- a/freqtrade/exchange/exchange.py
+++ b/freqtrade/exchange/exchange.py
@@ -30,14 +30,13 @@ from freqtrade.exceptions import (DDosProtection, ExchangeError, InsufficientFun
                                  RetryableOrderError, TemporaryError)
 from freqtrade.exchange.common import (API_FETCH_ORDER_RETRY_COUNT, remove_credentials, retrier,
                                       retrier_async)
-from freqtrade.exchange.exchange_utils import (ROUND, ROUND_DOWN, ROUND_UP, CcxtModuleType,
-                                               amount_to_contract_precision, amount_to_contracts,
-                                               amount_to_precision, contracts_to_amount,
-                                               date_minus_candles, is_exchange_known_ccxt,
-                                               market_is_active, price_to_precision,
-                                               timeframe_to_minutes, timeframe_to_msecs,
-                                               timeframe_to_next_date, timeframe_to_prev_date,
-                                               timeframe_to_seconds)
+from freqtrade.exchange.exchange_utils import (CcxtModuleType, amount_to_contract_precision,
+                                               amount_to_contracts, amount_to_precision,
+                                               contracts_to_amount, date_minus_candles,
+                                               is_exchange_known_ccxt, market_is_active,
+                                               price_to_precision, timeframe_to_minutes,
+                                               timeframe_to_msecs, timeframe_to_next_date,
+                                               timeframe_to_prev_date, timeframe_to_seconds)
 from freqtrade.exchange.types import OHLCVResponse, OrderBook, Ticker, Tickers
 from freqtrade.misc import (chunks, deep_merge_dicts, file_dump_json, file_load_json,
                            safe_value_fallback2)
@@ -60,7 +59,6 @@ class Exchange:
    # or by specifying them in the configuration.
    _ft_has_default: Dict = {
        "stoploss_on_exchange": False,
-        "stop_price_param": "stopPrice",
        "order_time_in_force": ["GTC"],
        "ohlcv_params": {},
        "ohlcv_candle_limit": 500,
@@ -736,14 +734,12 @@ class Exchange:
        """
        return amount_to_precision(amount, self.get_precision_amount(pair), self.precisionMode)

-    def price_to_precision(self, pair: str, price: float, *, rounding_mode: int = ROUND) -> float:
+    def price_to_precision(self, pair: str, price: float) -> float:
        """
-        Returns the price rounded to the precision the Exchange accepts.
-        The default price_rounding_mode in conf is ROUND.
-        For stoploss calculations, must use ROUND_UP for longs, and ROUND_DOWN for shorts.
+        Returns the price rounded up to the precision the Exchange accepts.
+        Rounds up
        """
-        return price_to_precision(price, self.get_precision_price(pair),
-                                  self.precisionMode, rounding_mode=rounding_mode)
+        return price_to_precision(price, self.get_precision_price(pair), self.precisionMode)

    def price_get_one_pip(self, pair: str, price: float) -> float:
        """
@@ -766,12 +762,12 @@ class Exchange:
        return self._get_stake_amount_limit(pair, price, stoploss, 'min', leverage)

    def get_max_pair_stake_amount(self, pair: str, price: float, leverage: float = 1.0) -> float:
-        max_stake_amount = self._get_stake_amount_limit(pair, price, 0.0, 'max', leverage)
+        max_stake_amount = self._get_stake_amount_limit(pair, price, 0.0, 'max')
        if max_stake_amount is None:
            # * Should never be executed
            raise OperationalException(f'{self.name}.get_max_pair_stake_amount should'
                                       'never set max_stake_amount to None')
-        return max_stake_amount
+        return max_stake_amount / leverage

    def _get_stake_amount_limit(
        self,
@@ -789,41 +785,43 @@ class Exchange:
        except KeyError:
            raise ValueError(f"Can't get market information for symbol {pair}")

-        if isMin:
-            # reserve some percent defined in config (5% default) + stoploss
-            margin_reserve: float = 1.0 + self._config.get('amount_reserve_percent',
-                                                           DEFAULT_AMOUNT_RESERVE_PERCENT)
-            stoploss_reserve = (
-                margin_reserve / (1 - abs(stoploss)) if abs(stoploss) != 1 else 1.5
-            )
-            # it should not be more than 50%
-            stoploss_reserve = max(min(stoploss_reserve, 1.5), 1)
-        else:
-            margin_reserve = 1.0
-            stoploss_reserve = 1.0
-
        stake_limits = []
        limits = market['limits']
        if (limits['cost'][limit] is not None):
            stake_limits.append(
-                self._contracts_to_amount(pair, limits['cost'][limit]) * stoploss_reserve
+                self._contracts_to_amount(
+                    pair,
+                    limits['cost'][limit]
+                )
            )

        if (limits['amount'][limit] is not None):
            stake_limits.append(
-                self._contracts_to_amount(pair, limits['amount'][limit]) * price * margin_reserve
+                self._contracts_to_amount(
+                    pair,
+                    limits['amount'][limit] * price
+                )
            )

        if not stake_limits:
            return None if isMin else float('inf')

+        # reserve some percent defined in config (5% default) + stoploss
+        amount_reserve_percent = 1.0 + self._config.get('amount_reserve_percent',
+                                                        DEFAULT_AMOUNT_RESERVE_PERCENT)
+        amount_reserve_percent = (
+            amount_reserve_percent / (1 - abs(stoploss)) if abs(stoploss) != 1 else 1.5
+        )
+        # it should not be more than 50%
+        amount_reserve_percent = max(min(amount_reserve_percent, 1.5), 1)
+
        # The value returned should satisfy both limits: for amount (base currency) and
        # for cost (quote, stake currency), so max() is used here.
        # See also #2575 at github.
        return self._get_stake_amount_considering_leverage(
-            max(stake_limits) if isMin else min(stake_limits),
+            max(stake_limits) * amount_reserve_percent,
            leverage or 1.0
-        )
+        ) if isMin else min(stake_limits)

    def _get_stake_amount_considering_leverage(self, stake_amount: float, leverage: float) -> float:
        """
@@ -1116,11 +1114,11 @@ class Exchange:
        """
        if not self._ft_has.get('stoploss_on_exchange'):
            raise OperationalException(f"stoploss is not implemented for {self.name}.")
-        price_param = self._ft_has['stop_price_param']
+
        return (
-            order.get(price_param, None) is None
-            or ((side == "sell" and stop_loss > float(order[price_param])) or
-                (side == "buy" and stop_loss < float(order[price_param])))
+            order.get('stopPrice', None) is None
+            or ((side == "sell" and stop_loss > float(order['stopPrice'])) or
+                (side == "buy" and stop_loss < float(order['stopPrice'])))
        )

    def _get_stop_order_type(self, user_order_type) -> Tuple[str, str]:
@@ -1160,8 +1158,8 @@ class Exchange:

    def _get_stop_params(self, side: BuySell, ordertype: str, stop_price: float) -> Dict:
        params = self._params.copy()
-        # Verify if stopPrice works for your exchange, else configure stop_price_param
-        params.update({self._ft_has['stop_price_param']: stop_price})
+        # Verify if stopPrice works for your exchange!
+        params.update({'stopPrice': stop_price})
        return params

    @retrier(retries=0)
@@ -1187,12 +1185,12 @@ class Exchange:

        user_order_type = order_types.get('stoploss', 'market')
        ordertype, user_order_type = self._get_stop_order_type(user_order_type)
-        round_mode = ROUND_DOWN if side == 'buy' else ROUND_UP
-        stop_price_norm = self.price_to_precision(pair, stop_price, rounding_mode=round_mode)
+
+        stop_price_norm = self.price_to_precision(pair, stop_price)
        limit_rate = None
        if user_order_type == 'limit':
            limit_rate = self._get_stop_limit_rate(stop_price, order_types, side)
-            limit_rate = self.price_to_precision(pair, limit_rate, rounding_mode=round_mode)
+            limit_rate = self.price_to_precision(pair, limit_rate)

        if self._config['dry_run']:
            dry_order = self.create_dry_run_order(
--- a/freqtrade/exchange/exchange_utils.py
+++ b/freqtrade/exchange/exchange_utils.py
@@ -2,12 +2,11 @@
 Exchange support utils
 """
 from datetime import datetime, timedelta, timezone
-from math import ceil, floor
+from math import ceil
 from typing import Any, Dict, List, Optional, Tuple

 import ccxt
-from ccxt import (DECIMAL_PLACES, ROUND, ROUND_DOWN, ROUND_UP, SIGNIFICANT_DIGITS, TICK_SIZE,
-                  TRUNCATE, decimal_to_precision)
+from ccxt import ROUND_DOWN, ROUND_UP, TICK_SIZE, TRUNCATE, decimal_to_precision

 from freqtrade.exchange.common import BAD_EXCHANGES, EXCHANGE_HAS_OPTIONAL, EXCHANGE_HAS_REQUIRED
 from freqtrade.util import FtPrecise
@@ -220,51 +219,35 @@ def amount_to_contract_precision(
    return amount


-def price_to_precision(
-    price: float,
-    price_precision: Optional[float],
-    precisionMode: Optional[int],
-    *,
-    rounding_mode: int = ROUND,
-) -> float:
+def price_to_precision(price: float, price_precision: Optional[float],
+                       precisionMode: Optional[int]) -> float:
    """
-    Returns the price rounded to the precision the Exchange accepts.
+    Returns the price rounded up to the precision the Exchange accepts.
    Partial Re-implementation of ccxt internal method decimal_to_precision(),
-    which does not support rounding up.
-    For stoploss calculations, must use ROUND_UP for longs, and ROUND_DOWN for shorts.
-
+    which does not support rounding up
    TODO: If ccxt supports ROUND_UP for decimal_to_precision(), we could remove this and
    align with amount_to_precision().
+    !!! Rounds up
    :param price: price to convert
    :param price_precision: price precision to use. Used from markets[pair]['precision']['price']
    :param precisionMode: precision mode to use. Should be used from precisionMode
                          one of ccxt's DECIMAL_PLACES, SIGNIFICANT_DIGITS, or TICK_SIZE
-    :param rounding_mode: rounding mode to use. Defaults to ROUND
    :return: price rounded up to the precision the Exchange accepts
+
    """
    if price_precision is not None and precisionMode is not None:
+        # price = float(decimal_to_precision(price, rounding_mode=ROUND,
+        #                                    precision=price_precision,
+        #                                    counting_mode=self.precisionMode,
+        #                                    ))
        if precisionMode == TICK_SIZE:
-            if rounding_mode == ROUND:
-                ticks = price / price_precision
-                rounded_ticks = round(ticks)
-                return rounded_ticks * price_precision
            precision = FtPrecise(price_precision)
            price_str = FtPrecise(price)
            missing = price_str % precision
            if not missing == FtPrecise("0"):
-                return round(float(str(price_str - missing + precision)), 14)
-            return price
-        elif precisionMode in (SIGNIFICANT_DIGITS, DECIMAL_PLACES):
-            ndigits = round(price_precision)
-            if rounding_mode == ROUND:
-                return round(price, ndigits)
-            ticks = price * (10**ndigits)
-            if rounding_mode == ROUND_UP:
-                return ceil(ticks) / (10**ndigits)
-            if rounding_mode == TRUNCATE:
-                return int(ticks) / (10**ndigits)
-            if rounding_mode == ROUND_DOWN:
-                return floor(ticks) / (10**ndigits)
-            raise ValueError(f"Unknown rounding_mode {rounding_mode}")
-        raise ValueError(f"Unknown precisionMode {precisionMode}")
+                price = round(float(str(price_str - missing + precision)), 14)
+        else:
+            symbol_prec = price_precision
+            big_price = price * pow(10, symbol_prec)
+            price = ceil(big_price) / pow(10, symbol_prec)
    return price
--- a/freqtrade/exchange/kraken.py
+++ b/freqtrade/exchange/kraken.py
@@ -12,7 +12,6 @@ from freqtrade.exceptions import (DDosProtection, InsufficientFundsError, Invali
                                  OperationalException, TemporaryError)
 from freqtrade.exchange import Exchange
 from freqtrade.exchange.common import retrier
-from freqtrade.exchange.exchange_utils import ROUND_DOWN, ROUND_UP
 from freqtrade.exchange.types import Tickers


@@ -110,7 +109,6 @@ class Kraken(Exchange):
        if self.trading_mode == TradingMode.FUTURES:
            params.update({'reduceOnly': True})

-        round_mode = ROUND_DOWN if side == 'buy' else ROUND_UP
        if order_types.get('stoploss', 'market') == 'limit':
            ordertype = "stop-loss-limit"
            limit_price_pct = order_types.get('stoploss_on_exchange_limit_ratio', 0.99)
@@ -118,11 +116,11 @@ class Kraken(Exchange):
                limit_rate = stop_price * limit_price_pct
            else:
                limit_rate = stop_price * (2 - limit_price_pct)
-            params['price2'] = self.price_to_precision(pair, limit_rate, rounding_mode=round_mode)
+            params['price2'] = self.price_to_precision(pair, limit_rate)
        else:
            ordertype = "stop-loss"

-        stop_price = self.price_to_precision(pair, stop_price, rounding_mode=round_mode)
+        stop_price = self.price_to_precision(pair, stop_price)

        if self._config['dry_run']:
            dry_order = self.create_dry_run_order(
--- a/freqtrade/exchange/okx.py
+++ b/freqtrade/exchange/okx.py
@@ -28,7 +28,6 @@ class Okx(Exchange):
        "funding_fee_timeframe": "8h",
        "stoploss_order_types": {"limit": "limit"},
        "stoploss_on_exchange": True,
-        "stop_price_param": "stopLossPrice",
    }
    _ft_has_futures: Dict = {
        "tickers_have_quoteVolume": False,
@@ -163,12 +162,29 @@ class Okx(Exchange):
        return pair_tiers[-1]['maxNotional'] / leverage

    def _get_stop_params(self, side: BuySell, ordertype: str, stop_price: float) -> Dict:
-        params = super()._get_stop_params(side, ordertype, stop_price)
+
+        params = self._params.copy()
+        # Verify if stopPrice works for your exchange!
+        params.update({'stopLossPrice': stop_price})
+
        if self.trading_mode == TradingMode.FUTURES and self.margin_mode:
            params['tdMode'] = self.margin_mode.value
            params['posSide'] = self._get_posSide(side, True)
        return params

+    def stoploss_adjust(self, stop_loss: float, order: Dict, side: str) -> bool:
+        """
+        OKX uses non-default stoploss price naming.
+        """
+        if not self._ft_has.get('stoploss_on_exchange'):
+            raise OperationalException(f"stoploss is not implemented for {self.name}.")
+
+        return (
+            order.get('stopLossPrice', None) is None
+            or ((side == "sell" and stop_loss > float(order['stopLossPrice'])) or
+                (side == "buy" and stop_loss < float(order['stopLossPrice'])))
+        )
+
    def fetch_stoploss_order(self, order_id: str, pair: str, params: Dict = {}) -> Dict:
        if self._config['dry_run']:
            return self.fetch_dry_run_order(order_id)
--- a/freqtrade/freqai/RL/Base3ActionRLEnv.py
+++ b/freqtrade/freqai/RL/Base3ActionRLEnv.py
@@ -66,7 +66,7 @@ class Base3ActionRLEnv(BaseEnvironment):
            elif action == Actions.Sell.value and not self.can_short:
                self._update_total_profit()
                self._position = Positions.Neutral
-                trade_type = "exit"
+                trade_type = "neutral"
                self._last_trade_tick = None
            else:
                print("case not defined")
@@ -74,7 +74,7 @@ class Base3ActionRLEnv(BaseEnvironment):
            if trade_type is not None:
                self.trade_history.append(
                    {'price': self.current_price(), 'index': self._current_tick,
-                     'type': trade_type, 'profit': self.get_unrealized_profit()})
+                     'type': trade_type})

        if (self._total_profit < self.max_drawdown or
                self._total_unrealized_profit < self.max_drawdown):
--- a/freqtrade/freqai/RL/Base4ActionRLEnv.py
+++ b/freqtrade/freqai/RL/Base4ActionRLEnv.py
@@ -52,6 +52,16 @@ class Base4ActionRLEnv(BaseEnvironment):

        trade_type = None
        if self.is_tradesignal(action):
+            """
+            Action: Neutral, position: Long ->  Close Long
+            Action: Neutral, position: Short -> Close Short
+
+            Action: Long, position: Neutral -> Open Long
+            Action: Long, position: Short -> Close Short and Open Long
+
+            Action: Short, position: Neutral -> Open Short
+            Action: Short, position: Long -> Close Long and Open Short
+            """

            if action == Actions.Neutral.value:
                self._position = Positions.Neutral
@@ -59,16 +69,16 @@ class Base4ActionRLEnv(BaseEnvironment):
                self._last_trade_tick = None
            elif action == Actions.Long_enter.value:
                self._position = Positions.Long
-                trade_type = "enter_long"
+                trade_type = "long"
                self._last_trade_tick = self._current_tick
            elif action == Actions.Short_enter.value:
                self._position = Positions.Short
-                trade_type = "enter_short"
+                trade_type = "short"
                self._last_trade_tick = self._current_tick
            elif action == Actions.Exit.value:
                self._update_total_profit()
                self._position = Positions.Neutral
-                trade_type = "exit"
+                trade_type = "neutral"
                self._last_trade_tick = None
            else:
                print("case not defined")
@@ -76,7 +86,7 @@ class Base4ActionRLEnv(BaseEnvironment):
            if trade_type is not None:
                self.trade_history.append(
                    {'price': self.current_price(), 'index': self._current_tick,
-                     'type': trade_type, 'profit': self.get_unrealized_profit()})
+                     'type': trade_type})

        if (self._total_profit < self.max_drawdown or
                self._total_unrealized_profit < self.max_drawdown):
--- a/freqtrade/freqai/RL/Base5ActionRLEnv.py
+++ b/freqtrade/freqai/RL/Base5ActionRLEnv.py
@@ -53,6 +53,16 @@ class Base5ActionRLEnv(BaseEnvironment):

        trade_type = None
        if self.is_tradesignal(action):
+            """
+            Action: Neutral, position: Long ->  Close Long
+            Action: Neutral, position: Short -> Close Short
+
+            Action: Long, position: Neutral -> Open Long
+            Action: Long, position: Short -> Close Short and Open Long
+
+            Action: Short, position: Neutral -> Open Short
+            Action: Short, position: Long -> Close Long and Open Short
+            """

            if action == Actions.Neutral.value:
                self._position = Positions.Neutral
@@ -60,21 +70,21 @@ class Base5ActionRLEnv(BaseEnvironment):
                self._last_trade_tick = None
            elif action == Actions.Long_enter.value:
                self._position = Positions.Long
-                trade_type = "enter_long"
+                trade_type = "long"
                self._last_trade_tick = self._current_tick
            elif action == Actions.Short_enter.value:
                self._position = Positions.Short
-                trade_type = "enter_short"
+                trade_type = "short"
                self._last_trade_tick = self._current_tick
            elif action == Actions.Long_exit.value:
                self._update_total_profit()
                self._position = Positions.Neutral
-                trade_type = "exit_long"
+                trade_type = "neutral"
                self._last_trade_tick = None
            elif action == Actions.Short_exit.value:
                self._update_total_profit()
                self._position = Positions.Neutral
-                trade_type = "exit_short"
+                trade_type = "neutral"
                self._last_trade_tick = None
            else:
                print("case not defined")
@@ -82,7 +92,7 @@ class Base5ActionRLEnv(BaseEnvironment):
            if trade_type is not None:
                self.trade_history.append(
                    {'price': self.current_price(), 'index': self._current_tick,
-                     'type': trade_type, 'profit': self.get_unrealized_profit()})
+                     'type': trade_type})

        if (self._total_profit < self.max_drawdown or
                self._total_unrealized_profit < self.max_drawdown):
--- a/freqtrade/freqai/data_kitchen.py
+++ b/freqtrade/freqai/data_kitchen.py
@@ -1291,7 +1291,7 @@ class FreqaiDataKitchen:

        return dataframe

-    def use_strategy_to_populate_indicators(  # noqa: C901
+    def use_strategy_to_populate_indicators(
        self,
        strategy: IStrategy,
        corr_dataframes: dict = {},
@@ -1362,12 +1362,12 @@ class FreqaiDataKitchen:
                dataframe = self.populate_features(dataframe.copy(), corr_pair, strategy,
                                                   corr_dataframes, base_dataframes, True)

-        if self.live:
-            dataframe = strategy.set_freqai_targets(dataframe.copy(), metadata=metadata)
-            dataframe = self.remove_special_chars_from_feature_names(dataframe)
+        dataframe = strategy.set_freqai_targets(dataframe.copy(), metadata=metadata)

        self.get_unique_classes_from_labels(dataframe)

+        dataframe = self.remove_special_chars_from_feature_names(dataframe)
+
        if self.config.get('reduce_df_footprint', False):
            dataframe = reduce_dataframe_footprint(dataframe)

--- a/freqtrade/freqai/freqai_interface.py
+++ b/freqtrade/freqai/freqai_interface.py
@@ -306,7 +306,7 @@ class IFreqaiModel(ABC):
                if check_features:
                    self.dd.load_metadata(dk)
                    dataframe_dummy_features = self.dk.use_strategy_to_populate_indicators(
-                        strategy, prediction_dataframe=dataframe.tail(1), pair=pair
+                        strategy, prediction_dataframe=dataframe.tail(1), pair=metadata["pair"]
                    )
                    dk.find_features(dataframe_dummy_features)
                    self.check_if_feature_list_matches_strategy(dk)
@@ -316,7 +316,7 @@ class IFreqaiModel(ABC):
            else:
                if populate_indicators:
                    dataframe = self.dk.use_strategy_to_populate_indicators(
-                        strategy, prediction_dataframe=dataframe, pair=pair
+                        strategy, prediction_dataframe=dataframe, pair=metadata["pair"]
                    )
                    populate_indicators = False

@@ -332,10 +332,6 @@ class IFreqaiModel(ABC):
                dataframe_train = dk.slice_dataframe(tr_train, dataframe_base_train)
                dataframe_backtest = dk.slice_dataframe(tr_backtest, dataframe_base_backtest)

-                dataframe_train = dk.remove_special_chars_from_feature_names(dataframe_train)
-                dataframe_backtest = dk.remove_special_chars_from_feature_names(dataframe_backtest)
-                dk.get_unique_classes_from_labels(dataframe_train)
-
                if not self.model_exists(dk):
                    dk.find_features(dataframe_train)
                    dk.find_labels(dataframe_train)
--- a/freqtrade/freqtradebot.py
+++ b/freqtrade/freqtradebot.py
@@ -21,8 +21,7 @@ from freqtrade.enums import (ExitCheckTuple, ExitType, RPCMessageType, RunMode,
                             State, TradingMode)
 from freqtrade.exceptions import (DependencyException, ExchangeError, InsufficientFundsError,
                                  InvalidOrderException, PricingError)
-from freqtrade.exchange import (ROUND_DOWN, ROUND_UP, timeframe_to_minutes, timeframe_to_next_date,
-                                timeframe_to_seconds)
+from freqtrade.exchange import timeframe_to_minutes, timeframe_to_next_date, timeframe_to_seconds
 from freqtrade.misc import safe_value_fallback, safe_value_fallback2
 from freqtrade.mixins import LoggingMixin
 from freqtrade.persistence import Order, PairLocks, Trade, init_db
@@ -854,8 +853,7 @@ class FreqtradeBot(LoggingMixin):
                logger.info(f"Canceling stoploss on exchange for {trade}")
                co = self.exchange.cancel_stoploss_order_with_result(
                    trade.stoploss_order_id, trade.pair, trade.amount)
-                self.update_trade_state(trade, trade.stoploss_order_id, co, stoploss_order=True)
-
+                trade.update_order(co)
                # Reset stoploss order id.
                trade.stoploss_order_id = None
            except InvalidOrderException:
@@ -947,7 +945,7 @@ class FreqtradeBot(LoggingMixin):

        return enter_limit_requested, stake_amount, leverage

-    def _notify_enter(self, trade: Trade, order: Order, order_type: str,
+    def _notify_enter(self, trade: Trade, order: Order, order_type: Optional[str] = None,
                      fill: bool = False, sub_trade: bool = False) -> None:
        """
        Sends rpc notification when a entry order occurred.
@@ -1173,8 +1171,7 @@ class FreqtradeBot(LoggingMixin):
            logger.warning('Unable to fetch stoploss order: %s', exception)

        if stoploss_order:
-            self.update_trade_state(trade, trade.stoploss_order_id, stoploss_order,
-                                    stoploss_order=True)
+            trade.update_order(stoploss_order)

        # We check if stoploss order is fulfilled
        if stoploss_order and stoploss_order['status'] in ('closed', 'triggered'):
@@ -1238,9 +1235,7 @@ class FreqtradeBot(LoggingMixin):
        :param order: Current on exchange stoploss order
        :return: None
        """
-        stoploss_norm = self.exchange.price_to_precision(
-            trade.pair, trade.stoploss_or_liquidation,
-            rounding_mode=ROUND_DOWN if trade.is_short else ROUND_UP)
+        stoploss_norm = self.exchange.price_to_precision(trade.pair, trade.stoploss_or_liquidation)

        if self.exchange.stoploss_adjust(stoploss_norm, order, side=trade.exit_side):
            # we check if the update is necessary
@@ -1483,8 +1478,8 @@ class FreqtradeBot(LoggingMixin):
                    return False

            try:
-                order = self.exchange.cancel_order_with_result(
-                    order['id'], trade.pair, trade.amount)
+                order = self.exchange.cancel_order_with_result(order['id'], trade.pair,
+                                                               trade.amount)
            except InvalidOrderException:
                logger.exception(
                    f"Could not cancel {trade.exit_side} order {trade.open_order_id}")
@@ -1496,18 +1491,17 @@ class FreqtradeBot(LoggingMixin):
            # Order might be filled above in odd timing issues.
            if order.get('status') in ('canceled', 'cancelled'):
                trade.exit_reason = None
-                trade.open_order_id = None
            else:
                trade.exit_reason = exit_reason_prev
            cancelled = True
        else:
            reason = constants.CANCEL_REASON['CANCELLED_ON_EXCHANGE']
            trade.exit_reason = None
-            trade.open_order_id = None

        self.update_trade_state(trade, trade.open_order_id, order)

        logger.info(f'{trade.exit_side.capitalize()} order {reason} for {trade}.')
+        trade.open_order_id = None
        trade.close_rate = None
        trade.close_rate_requested = None

@@ -1784,11 +1778,11 @@ class FreqtradeBot(LoggingMixin):
            return False

        # Update trade with order values
-        if not stoploss_order:
-            logger.info(f'Found open order for {trade}')
+        logger.info(f'Found open order for {trade}')
        try:
-            order = action_order or self.exchange.fetch_order_or_stoploss_order(
-                order_id, trade.pair, stoploss_order)
+            order = action_order or self.exchange.fetch_order_or_stoploss_order(order_id,
+                                                                                trade.pair,
+                                                                                stoploss_order)
        except InvalidOrderException as exception:
            logger.warning('Unable to fetch order %s: %s', order_id, exception)
            return False
@@ -1853,7 +1847,7 @@ class FreqtradeBot(LoggingMixin):
                self.handle_protections(trade.pair, trade.trade_direction)
        elif send_msg and not trade.open_order_id and not stoploss_order:
            # Enter fill
-            self._notify_enter(trade, order, order.order_type, fill=True, sub_trade=sub_trade)
+            self._notify_enter(trade, order, fill=True, sub_trade=sub_trade)

    def handle_protections(self, pair: str, side: LongShort) -> None:
        # Lock pair for one candle to prevent immediate rebuys
--- a/freqtrade/optimize/hyperopt_tools.py
+++ b/freqtrade/optimize/hyperopt_tools.py
@@ -23,8 +23,6 @@ logger = logging.getLogger(__name__)

 NON_OPT_PARAM_APPENDIX = "  # value loaded from strategy"

-HYPER_PARAMS_FILE_FORMAT = rapidjson.NM_NATIVE | rapidjson.NM_NAN
-

 def hyperopt_serializer(x):
    if isinstance(x, np.integer):
@@ -78,18 +76,9 @@ class HyperoptTools():
        with filename.open('w') as f:
            rapidjson.dump(final_params, f, indent=2,
                           default=hyperopt_serializer,
-                           number_mode=HYPER_PARAMS_FILE_FORMAT
+                           number_mode=rapidjson.NM_NATIVE | rapidjson.NM_NAN
                           )

-    @staticmethod
-    def load_params(filename: Path) -> Dict:
-        """
-        Load parameters from file
-        """
-        with filename.open('r') as f:
-            params = rapidjson.load(f, number_mode=HYPER_PARAMS_FILE_FORMAT)
-        return params
-
    @staticmethod
    def try_export_params(config: Config, strategy_name: str, params: Dict):
        if params.get(FTHYPT_FILEVERSION, 1) >= 2 and not config.get('disableparamexport', False):
@@ -200,7 +189,7 @@ class HyperoptTools():
            for s in ['buy', 'sell', 'protection',
                      'roi', 'stoploss', 'trailing', 'max_open_trades']:
                HyperoptTools._params_update_for_json(result_dict, params, non_optimized, s)
-            print(rapidjson.dumps(result_dict, default=str, number_mode=HYPER_PARAMS_FILE_FORMAT))
+            print(rapidjson.dumps(result_dict, default=str, number_mode=rapidjson.NM_NATIVE))

        else:
            HyperoptTools._params_pretty_print(params, 'buy', "Buy hyperspace params:",
--- a/freqtrade/optimize/optimize_reports.py
+++ b/freqtrade/optimize/optimize_reports.py
@@ -865,11 +865,6 @@ def show_backtest_result(strategy: str, results: Dict[str, Any], stake_currency:
        print(' BACKTESTING REPORT '.center(len(table.splitlines()[0]), '='))
    print(table)

-    table = text_table_bt_results(results['left_open_trades'], stake_currency=stake_currency)
-    if isinstance(table, str) and len(table) > 0:
-        print(' LEFT OPEN TRADES REPORT '.center(len(table.splitlines()[0]), '='))
-    print(table)
-
    if (results.get('results_per_enter_tag') is not None
            or results.get('results_per_buy_tag') is not None):
        # results_per_buy_tag is deprecated and should be removed 2 versions after short golive.
@@ -889,6 +884,11 @@ def show_backtest_result(strategy: str, results: Dict[str, Any], stake_currency:
        print(' EXIT REASON STATS '.center(len(table.splitlines()[0]), '='))
    print(table)

+    table = text_table_bt_results(results['left_open_trades'], stake_currency=stake_currency)
+    if isinstance(table, str) and len(table) > 0:
+        print(' LEFT OPEN TRADES REPORT '.center(len(table.splitlines()[0]), '='))
+    print(table)
+
    for period in backtest_breakdown:
        days_breakdown_stats = generate_periodic_breakdown_stats(
            trade_list=results['trades'], period=period)
@@ -917,11 +917,11 @@ def show_backtest_results(config: Config, backtest_stats: Dict):
            strategy, results, stake_currency,
            config.get('backtest_breakdown', []))

-    if len(backtest_stats['strategy']) > 0:
+    if len(backtest_stats['strategy']) > 1:
        # Print Strategy summary table

        table = text_table_strategy(backtest_stats['strategy_comparison'], stake_currency)
-        print(f"Backtested {results['backtest_start']} -> {results['backtest_end']} |"
+        print(f"{results['backtest_start']} -> {results['backtest_end']} |"
              f" Max open trades : {results['max_open_trades']}")
        print(' STRATEGY SUMMARY '.center(len(table.splitlines()[0]), '='))
        print(table)
--- a/freqtrade/persistence/trade_model.py
+++ b/freqtrade/persistence/trade_model.py
@@ -15,8 +15,7 @@ from freqtrade.constants import (DATETIME_PRINT_FORMAT, MATH_CLOSE_PREC, NON_OPE
                                 BuySell, LongShort)
 from freqtrade.enums import ExitType, TradingMode
 from freqtrade.exceptions import DependencyException, OperationalException
-from freqtrade.exchange import (ROUND_DOWN, ROUND_UP, amount_to_contract_precision,
-                                price_to_precision)
+from freqtrade.exchange import amount_to_contract_precision, price_to_precision
 from freqtrade.leverage import interest
 from freqtrade.persistence.base import ModelBase, SessionType
 from freqtrade.util import FtPrecise
@@ -598,8 +597,7 @@ class LocalTrade():
        """
        Method used internally to set self.stop_loss.
        """
-        stop_loss_norm = price_to_precision(stop_loss, self.price_precision, self.precision_mode,
-                                            rounding_mode=ROUND_DOWN if self.is_short else ROUND_UP)
+        stop_loss_norm = price_to_precision(stop_loss, self.price_precision, self.precision_mode)
        if not self.stop_loss:
            self.initial_stop_loss = stop_loss_norm
        self.stop_loss = stop_loss_norm
@@ -630,8 +628,7 @@ class LocalTrade():
        if self.initial_stop_loss_pct is None or refresh:
            self.__set_stop_loss(new_loss, stoploss)
            self.initial_stop_loss = price_to_precision(
-                new_loss, self.price_precision, self.precision_mode,
-                rounding_mode=ROUND_DOWN if self.is_short else ROUND_UP)
+                new_loss, self.price_precision, self.precision_mode)
            self.initial_stop_loss_pct = -1 * abs(stoploss)

        # evaluate if the stop loss needs to be updated
@@ -695,24 +692,21 @@ class LocalTrade():
            else:
                logger.warning(
                    f'Got different open_order_id {self.open_order_id} != {order.order_id}')
-
-        elif order.ft_order_side == 'stoploss' and order.status not in ('open', ):
-            self.stoploss_order_id = None
-            self.close_rate_requested = self.stop_loss
-            self.exit_reason = ExitType.STOPLOSS_ON_EXCHANGE.value
-            if self.is_open:
-                logger.info(f'{order.order_type.upper()} is hit for {self}.')
-        else:
-            raise ValueError(f'Unknown order type: {order.order_type}')
-
-        if order.ft_order_side != self.entry_side:
            amount_tr = amount_to_contract_precision(self.amount, self.amount_precision,
                                                     self.precision_mode, self.contract_size)
            if isclose(order.safe_amount_after_fee, amount_tr, abs_tol=MATH_CLOSE_PREC):
                self.close(order.safe_price)
            else:
                self.recalc_trade_from_orders()
-
+        elif order.ft_order_side == 'stoploss' and order.status not in ('canceled', 'open'):
+            self.stoploss_order_id = None
+            self.close_rate_requested = self.stop_loss
+            self.exit_reason = ExitType.STOPLOSS_ON_EXCHANGE.value
+            if self.is_open:
+                logger.info(f'{order.order_type.upper()} is hit for {self}.')
+            self.close(order.safe_price)
+        else:
+            raise ValueError(f'Unknown order type: {order.order_type}')
        Trade.commit()

    def close(self, rate: float, *, show_msg: bool = True) -> None:
--- a/freqtrade/plugins/pairlist/PrecisionFilter.py
+++ b/freqtrade/plugins/pairlist/PrecisionFilter.py
@@ -6,7 +6,6 @@ from typing import Any, Dict, Optional

 from freqtrade.constants import Config
 from freqtrade.exceptions import OperationalException
-from freqtrade.exchange import ROUND_UP
 from freqtrade.exchange.types import Ticker
 from freqtrade.plugins.pairlist.IPairList import IPairList

@@ -62,10 +61,9 @@ class PrecisionFilter(IPairList):
        stop_price = ticker['last'] * self._stoploss

        # Adjust stop-prices to precision
-        sp = self._exchange.price_to_precision(pair, stop_price, rounding_mode=ROUND_UP)
+        sp = self._exchange.price_to_precision(pair, stop_price)

-        stop_gap_price = self._exchange.price_to_precision(pair, stop_price * 0.99,
-                                                           rounding_mode=ROUND_UP)
+        stop_gap_price = self._exchange.price_to_precision(pair, stop_price * 0.99)
        logger.debug(f"{pair} - {sp} : {stop_gap_price}")

        if sp <= stop_gap_price:
--- a/freqtrade/rpc/api_server/uvicorn_threaded.py
+++ b/freqtrade/rpc/api_server/uvicorn_threaded.py
@@ -55,7 +55,7 @@ class UvicornServer(uvicorn.Server):

    @contextlib.contextmanager
    def run_in_thread(self):
-        self.thread = threading.Thread(target=self.run, name='FTUvicorn')
+        self.thread = threading.Thread(target=self.run)
        self.thread.start()
        while not self.started:
            time.sleep(1e-3)
--- a/freqtrade/rpc/rpc_types.py
+++ b/freqtrade/rpc/rpc_types.py
@@ -52,7 +52,7 @@ class __RPCBuyMsgBase(RPCSendMsgBase):
    direction: str
    limit: float
    open_rate: float
-    order_type: str
+    order_type: Optional[str]  # TODO: why optional??
    stake_amount: float
    stake_currency: str
    fiat_currency: Optional[str]
--- a/freqtrade/strategy/hyper.py
+++ b/freqtrade/strategy/hyper.py
@@ -8,7 +8,7 @@ from typing import Any, Dict, Iterator, List, Optional, Tuple, Type, Union

 from freqtrade.constants import Config
 from freqtrade.exceptions import OperationalException
-from freqtrade.misc import deep_merge_dicts
+from freqtrade.misc import deep_merge_dicts, json_load
 from freqtrade.optimize.hyperopt_tools import HyperoptTools
 from freqtrade.strategy.parameters import BaseParameter

@@ -124,7 +124,8 @@ class HyperStrategyMixin:
        if filename.is_file():
            logger.info(f"Loading parameters from file {filename}")
            try:
-                params = HyperoptTools.load_params(filename)
+                with filename.open('r') as f:
+                    params = json_load(f)
                if params.get('strategy_name') != self.__class__.__name__:
                    raise OperationalException('Invalid parameter file provided.')
                return params
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -7,7 +7,7 @@
 -r docs/requirements-docs.txt

 coveralls==3.3.1
-ruff==0.0.260
+ruff==0.0.259
 mypy==1.1.1
 pre-commit==3.2.1
 pytest==7.2.2
@@ -25,8 +25,8 @@ httpx==0.23.3
 nbconvert==7.2.10

 # mypy types
-types-cachetools==5.3.0.5
+types-cachetools==5.3.0.4
 types-filelock==3.2.7
-types-requests==2.28.11.17
-types-tabulate==0.9.0.2
-types-python-dateutil==2.8.19.11
+types-requests==2.28.11.16
+types-tabulate==0.9.0.1
+types-python-dateutil==2.8.19.10
--- a/requirements-freqai.txt
+++ b/requirements-freqai.txt
@@ -7,5 +7,5 @@ scikit-learn==1.1.3
 joblib==1.2.0
 catboost==1.1.1; platform_machine != 'aarch64' and 'arm' not in platform_machine and python_version < '3.11'
 lightgbm==3.3.5
-xgboost==1.7.5
-tensorboard==2.12.1
+xgboost==1.7.4
+tensorboard==2.12.0
--- a/requirements-plot.txt
+++ b/requirements-plot.txt
@@ -1,4 +1,4 @@
 # Include all requirements to run the bot.
 -r requirements.txt

-plotly==5.14.0
+plotly==5.13.1
--- a/requirements.txt
+++ b/requirements.txt
@@ -2,17 +2,17 @@ numpy==1.24.2
 pandas==1.5.3
 pandas-ta==0.3.14b

-ccxt==3.0.50
+ccxt==3.0.37
 cryptography==40.0.1
 aiohttp==3.8.4
-SQLAlchemy==2.0.8
+SQLAlchemy==2.0.7
 python-telegram-bot==13.15
 arrow==1.2.3
 cachetools==4.2.2
 requests==2.28.2
 urllib3==1.26.15
 jsonschema==4.17.3
-TA-Lib==0.4.26
+TA-Lib==0.4.25
 technical==1.4.0
 tabulate==0.9.0
 pycoingecko==3.1.0
@@ -28,7 +28,7 @@ py_find_1st==1.1.5
 # Load ticker files 30% faster
 python-rapidjson==1.10
 # Properly format api responses
-orjson==3.8.9
+orjson==3.8.8

 # Notify systemd
 sdnotify==0.3.2
@@ -53,7 +53,7 @@ python-dateutil==2.8.2
 schedule==1.1.0

 #WS Messages
-websockets==11.0
+websockets==10.4
 janus==1.0.0

 ast-comments==1.0.1
--- a/setup.py
+++ b/setup.py
@@ -59,7 +59,7 @@ setup(
    install_requires=[
        # from requirements.txt
        'ccxt>=2.6.26',
-        'SQLAlchemy>=2.0.6',
+        'SQLAlchemy',
        'python-telegram-bot>=13.4',
        'arrow>=0.17.0',
        'cachetools',
--- a/tests/exchange/test_binance.py
+++ b/tests/exchange/test_binance.py
@@ -48,7 +48,7 @@ def test_create_stoploss_order_binance(default_conf, mocker, limitratio, expecte
    default_conf['margin_mode'] = MarginMode.ISOLATED
    default_conf['trading_mode'] = trademode
    mocker.patch(f'{EXMS}.amount_to_precision', lambda s, x, y: y)
-    mocker.patch(f'{EXMS}.price_to_precision', lambda s, x, y, **kwargs: y)
+    mocker.patch(f'{EXMS}.price_to_precision', lambda s, x, y: y)

    exchange = get_patched_exchange(mocker, default_conf, api_mock, 'binance')

@@ -127,7 +127,7 @@ def test_create_stoploss_order_dry_run_binance(default_conf, mocker):
    order_type = 'stop_loss_limit'
    default_conf['dry_run'] = True
    mocker.patch(f'{EXMS}.amount_to_precision', lambda s, x, y: y)
-    mocker.patch(f'{EXMS}.price_to_precision', lambda s, x, y, **kwargs: y)
+    mocker.patch(f'{EXMS}.price_to_precision', lambda s, x, y: y)

    exchange = get_patched_exchange(mocker, default_conf, api_mock, 'binance')

--- a/tests/exchange/test_exchange.py
+++ b/tests/exchange/test_exchange.py
@@ -8,7 +8,6 @@ from unittest.mock import MagicMock, Mock, PropertyMock, patch
 import arrow
 import ccxt
 import pytest
-from ccxt import DECIMAL_PLACES, ROUND, ROUND_UP, TICK_SIZE, TRUNCATE
 from pandas import DataFrame

 from freqtrade.enums import CandleType, MarginMode, TradingMode
@@ -316,54 +315,35 @@ def test_amount_to_precision(amount, precision_mode, precision, expected,):
    assert amount_to_precision(amount, precision, precision_mode) == expected


-@pytest.mark.parametrize("price,precision_mode,precision,expected,rounding_mode", [
-    # Tests for DECIMAL_PLACES, ROUND_UP
-    (2.34559, 2, 4, 2.3456, ROUND_UP),
-    (2.34559, 2, 5, 2.34559, ROUND_UP),
-    (2.34559, 2, 3, 2.346, ROUND_UP),
-    (2.9999, 2, 3, 3.000, ROUND_UP),
-    (2.9909, 2, 3, 2.991, ROUND_UP),
-    # Tests for DECIMAL_PLACES, ROUND
-    (2.345600000000001, DECIMAL_PLACES, 4, 2.3456, ROUND),
-    (2.345551, DECIMAL_PLACES, 4, 2.3456, ROUND),
-    (2.49, DECIMAL_PLACES, 0, 2., ROUND),
-    (2.51, DECIMAL_PLACES, 0, 3., ROUND),
-    (5.1, DECIMAL_PLACES, -1, 10., ROUND),
-    (4.9, DECIMAL_PLACES, -1, 0., ROUND),
-    # Tests for TICK_SIZE, ROUND_UP
-    (2.34559, TICK_SIZE, 0.0001, 2.3456, ROUND_UP),
-    (2.34559, TICK_SIZE, 0.00001, 2.34559, ROUND_UP),
-    (2.34559, TICK_SIZE, 0.001, 2.346, ROUND_UP),
-    (2.9999, TICK_SIZE, 0.001, 3.000, ROUND_UP),
-    (2.9909, TICK_SIZE, 0.001, 2.991, ROUND_UP),
-    (2.9909, TICK_SIZE, 0.005, 2.995, ROUND_UP),
-    (2.9973, TICK_SIZE, 0.005, 3.0, ROUND_UP),
-    (2.9977, TICK_SIZE, 0.005, 3.0, ROUND_UP),
-    (234.43, TICK_SIZE, 0.5, 234.5, ROUND_UP),
-    (234.53, TICK_SIZE, 0.5, 235.0, ROUND_UP),
-    (0.891534, TICK_SIZE, 0.0001, 0.8916, ROUND_UP),
-    (64968.89, TICK_SIZE, 0.01, 64968.89, ROUND_UP),
-    (0.000000003483, TICK_SIZE, 1e-12, 0.000000003483, ROUND_UP),
-    # Tests for TICK_SIZE, ROUND
-    (2.49, TICK_SIZE, 1., 2., ROUND),
-    (2.51, TICK_SIZE, 1., 3., ROUND),
-    (2.000000051, TICK_SIZE, 0.0000001, 2.0000001, ROUND),
-    (2.000000049, TICK_SIZE, 0.0000001, 2., ROUND),
-    (2.9909, TICK_SIZE, 0.005, 2.990, ROUND),
-    (2.9973, TICK_SIZE, 0.005, 2.995, ROUND),
-    (2.9977, TICK_SIZE, 0.005, 3.0, ROUND),
-    (234.24, TICK_SIZE, 0.5, 234., ROUND),
-    (234.26, TICK_SIZE, 0.5, 234.5, ROUND),
-    # Tests for TRUNCATTE
-    (2.34559, 2, 4, 2.3455, TRUNCATE),
-    (2.34559, 2, 5, 2.34559, TRUNCATE),
-    (2.34559, 2, 3, 2.345, TRUNCATE),
-    (2.9999, 2, 3, 2.999, TRUNCATE),
-    (2.9909, 2, 3, 2.990, TRUNCATE),
+@pytest.mark.parametrize("price,precision_mode,precision,expected", [
+    (2.34559, 2, 4, 2.3456),
+    (2.34559, 2, 5, 2.34559),
+    (2.34559, 2, 3, 2.346),
+    (2.9999, 2, 3, 3.000),
+    (2.9909, 2, 3, 2.991),
+    # Tests for Tick_size
+    (2.34559, 4, 0.0001, 2.3456),
+    (2.34559, 4, 0.00001, 2.34559),
+    (2.34559, 4, 0.001, 2.346),
+    (2.9999, 4, 0.001, 3.000),
+    (2.9909, 4, 0.001, 2.991),
+    (2.9909, 4, 0.005, 2.995),
+    (2.9973, 4, 0.005, 3.0),
+    (2.9977, 4, 0.005, 3.0),
+    (234.43, 4, 0.5, 234.5),
+    (234.53, 4, 0.5, 235.0),
+    (0.891534, 4, 0.0001, 0.8916),
+    (64968.89, 4, 0.01, 64968.89),
+    (0.000000003483, 4, 1e-12, 0.000000003483),
+
 ])
-def test_price_to_precision(price, precision_mode, precision, expected, rounding_mode):
-    assert price_to_precision(
-        price, precision, precision_mode, rounding_mode=rounding_mode) == expected
+def test_price_to_precision(price, precision_mode, precision, expected):
+    # digits counting mode
+    # DECIMAL_PLACES = 2
+    # SIGNIFICANT_DIGITS = 3
+    # TICK_SIZE = 4
+
+    assert price_to_precision(price, precision, precision_mode) == expected


@pytest.mark.parametrize("price,precision_mode,precision,expected", [
@@ -437,7 +417,7 @@ def test__get_stake_amount_limit(mocker, default_conf) -> None:
    }
    mocker.patch(f'{EXMS}.markets', PropertyMock(return_value=markets))
    result = exchange.get_min_pair_stake_amount('ETH/BTC', 2, stoploss)
-    expected_result = 2 * 2 * (1 + 0.05)
+    expected_result = 2 * 2 * (1 + 0.05) / (1 - abs(stoploss))
    assert pytest.approx(result) == expected_result
    # With Leverage
    result = exchange.get_min_pair_stake_amount('ETH/BTC', 2, stoploss, 5.0)
@@ -446,14 +426,14 @@ def test__get_stake_amount_limit(mocker, default_conf) -> None:
    result = exchange.get_max_pair_stake_amount('ETH/BTC', 2)
    assert result == 20000

-    # min amount and cost are set (cost is minimal and therefore ignored)
+    # min amount and cost are set (cost is minimal)
    markets["ETH/BTC"]["limits"] = {
        'cost': {'min': 2, 'max': None},
        'amount': {'min': 2, 'max': None},
    }
    mocker.patch(f'{EXMS}.markets', PropertyMock(return_value=markets))
    result = exchange.get_min_pair_stake_amount('ETH/BTC', 2, stoploss)
-    expected_result = max(2, 2 * 2) * (1 + 0.05)
+    expected_result = max(2, 2 * 2) * (1 + 0.05) / (1 - abs(stoploss))
    assert pytest.approx(result) == expected_result
    # With Leverage
    result = exchange.get_min_pair_stake_amount('ETH/BTC', 2, stoploss, 10)
@@ -496,9 +476,6 @@ def test__get_stake_amount_limit(mocker, default_conf) -> None:
    result = exchange.get_max_pair_stake_amount('ETH/BTC', 2)
    assert result == 1000

-    result = exchange.get_max_pair_stake_amount('ETH/BTC', 2, 12.0)
-    assert result == 1000 / 12
-
    markets["ETH/BTC"]["contractSize"] = '0.01'
    default_conf['trading_mode'] = 'futures'
    default_conf['margin_mode'] = 'isolated'
@@ -5304,7 +5281,7 @@ def test_stoploss_contract_size(mocker, default_conf, contract_size, order_amoun
    })
    default_conf['dry_run'] = False
    mocker.patch(f'{EXMS}.amount_to_precision', lambda s, x, y: y)
-    mocker.patch(f'{EXMS}.price_to_precision', lambda s, x, y, **kwargs: y)
+    mocker.patch(f'{EXMS}.price_to_precision', lambda s, x, y: y)

    exchange = get_patched_exchange(mocker, default_conf, api_mock)
    exchange.get_contract_size = MagicMock(return_value=contract_size)
@@ -5324,10 +5301,3 @@ def test_stoploss_contract_size(mocker, default_conf, contract_size, order_amoun
    assert order['cost'] == 100
    assert order['filled'] == 100
    assert order['remaining'] == 100
-
-
-def test_price_to_precision_with_default_conf(default_conf, mocker):
-    conf = copy.deepcopy(default_conf)
-    patched_ex = get_patched_exchange(mocker, conf)
-    prec_price = patched_ex.price_to_precision("XRP/USDT", 1.0000000101)
-    assert prec_price == 1.00000001
--- a/tests/exchange/test_huobi.py
+++ b/tests/exchange/test_huobi.py
@@ -27,7 +27,7 @@ def test_create_stoploss_order_huobi(default_conf, mocker, limitratio, expected,
    })
    default_conf['dry_run'] = False
    mocker.patch(f'{EXMS}.amount_to_precision', lambda s, x, y: y)
-    mocker.patch(f'{EXMS}.price_to_precision', lambda s, x, y, **kwargs: y)
+    mocker.patch(f'{EXMS}.price_to_precision', lambda s, x, y: y)

    exchange = get_patched_exchange(mocker, default_conf, api_mock, 'huobi')

@@ -80,7 +80,7 @@ def test_create_stoploss_order_dry_run_huobi(default_conf, mocker):
    order_type = 'stop-limit'
    default_conf['dry_run'] = True
    mocker.patch(f'{EXMS}.amount_to_precision', lambda s, x, y: y)
-    mocker.patch(f'{EXMS}.price_to_precision', lambda s, x, y, **kwargs: y)
+    mocker.patch(f'{EXMS}.price_to_precision', lambda s, x, y: y)

    exchange = get_patched_exchange(mocker, default_conf, api_mock, 'huobi')

--- a/tests/exchange/test_kraken.py
+++ b/tests/exchange/test_kraken.py
@@ -29,7 +29,7 @@ def test_buy_kraken_trading_agreement(default_conf, mocker):
    default_conf['dry_run'] = False

    mocker.patch(f'{EXMS}.amount_to_precision', lambda s, x, y: y)
-    mocker.patch(f'{EXMS}.price_to_precision', lambda s, x, y, **kwargs: y)
+    mocker.patch(f'{EXMS}.price_to_precision', lambda s, x, y: y)
    exchange = get_patched_exchange(mocker, default_conf, api_mock, id="kraken")

    order = exchange.create_order(
@@ -192,7 +192,7 @@ def test_create_stoploss_order_kraken(default_conf, mocker, ordertype, side, adj

    default_conf['dry_run'] = False
    mocker.patch(f'{EXMS}.amount_to_precision', lambda s, x, y: y)
-    mocker.patch(f'{EXMS}.price_to_precision', lambda s, x, y, **kwargs: y)
+    mocker.patch(f'{EXMS}.price_to_precision', lambda s, x, y: y)

    exchange = get_patched_exchange(mocker, default_conf, api_mock, 'kraken')

@@ -263,7 +263,7 @@ def test_create_stoploss_order_dry_run_kraken(default_conf, mocker, side):
    api_mock = MagicMock()
    default_conf['dry_run'] = True
    mocker.patch(f'{EXMS}.amount_to_precision', lambda s, x, y: y)
-    mocker.patch(f'{EXMS}.price_to_precision', lambda s, x, y, **kwargs: y)
+    mocker.patch(f'{EXMS}.price_to_precision', lambda s, x, y: y)

    exchange = get_patched_exchange(mocker, default_conf, api_mock, 'kraken')

--- a/tests/exchange/test_kucoin.py
+++ b/tests/exchange/test_kucoin.py
@@ -27,7 +27,7 @@ def test_create_stoploss_order_kucoin(default_conf, mocker, limitratio, expected
    })
    default_conf['dry_run'] = False
    mocker.patch(f'{EXMS}.amount_to_precision', lambda s, x, y: y)
-    mocker.patch(f'{EXMS}.price_to_precision', lambda s, x, y, **kwargs: y)
+    mocker.patch(f'{EXMS}.price_to_precision', lambda s, x, y: y)

    exchange = get_patched_exchange(mocker, default_conf, api_mock, 'kucoin')
    if order_type == 'limit':
@@ -88,7 +88,7 @@ def test_stoploss_order_dry_run_kucoin(default_conf, mocker):
    order_type = 'market'
    default_conf['dry_run'] = True
    mocker.patch(f'{EXMS}.amount_to_precision', lambda s, x, y: y)
-    mocker.patch(f'{EXMS}.price_to_precision', lambda s, x, y, **kwargs: y)
+    mocker.patch(f'{EXMS}.price_to_precision', lambda s, x, y: y)

    exchange = get_patched_exchange(mocker, default_conf, api_mock, 'kucoin')

--- a/tests/freqai/conftest.py
+++ b/tests/freqai/conftest.py
@@ -119,7 +119,6 @@ def make_unfiltered_dataframe(mocker, freqai_conf):
    freqai = strategy.freqai
    freqai.live = True
    freqai.dk = FreqaiDataKitchen(freqai_conf)
-    freqai.dk.live = True
    freqai.dk.pair = "ADA/BTC"
    data_load_timerange = TimeRange.parse_timerange("20180110-20180130")
    freqai.dd.load_all_pair_histories(data_load_timerange, freqai.dk)
@@ -153,7 +152,6 @@ def make_data_dictionary(mocker, freqai_conf):
    freqai = strategy.freqai
    freqai.live = True
    freqai.dk = FreqaiDataKitchen(freqai_conf)
-    freqai.dk.live = True
    freqai.dk.pair = "ADA/BTC"
    data_load_timerange = TimeRange.parse_timerange("20180110-20180130")
    freqai.dd.load_all_pair_histories(data_load_timerange, freqai.dk)
--- a/tests/freqai/test_freqai_datadrawer.py
+++ b/tests/freqai/test_freqai_datadrawer.py
@@ -19,7 +19,6 @@ def test_update_historic_data(mocker, freqai_conf):
    freqai = strategy.freqai
    freqai.live = True
    freqai.dk = FreqaiDataKitchen(freqai_conf)
-    freqai.dk.live = True
    timerange = TimeRange.parse_timerange("20180110-20180114")

    freqai.dd.load_all_pair_histories(timerange, freqai.dk)
@@ -42,7 +41,6 @@ def test_load_all_pairs_histories(mocker, freqai_conf):
    freqai = strategy.freqai
    freqai.live = True
    freqai.dk = FreqaiDataKitchen(freqai_conf)
-    freqai.dk.live = True
    timerange = TimeRange.parse_timerange("20180110-20180114")
    freqai.dd.load_all_pair_histories(timerange, freqai.dk)

@@ -62,7 +60,6 @@ def test_get_base_and_corr_dataframes(mocker, freqai_conf):
    freqai = strategy.freqai
    freqai.live = True
    freqai.dk = FreqaiDataKitchen(freqai_conf)
-    freqai.dk.live = True
    timerange = TimeRange.parse_timerange("20180110-20180114")
    freqai.dd.load_all_pair_histories(timerange, freqai.dk)
    sub_timerange = TimeRange.parse_timerange("20180111-20180114")
@@ -90,7 +87,6 @@ def test_use_strategy_to_populate_indicators(mocker, freqai_conf):
    freqai = strategy.freqai
    freqai.live = True
    freqai.dk = FreqaiDataKitchen(freqai_conf)
-    freqai.dk.live = True
    timerange = TimeRange.parse_timerange("20180110-20180114")
    freqai.dd.load_all_pair_histories(timerange, freqai.dk)
    sub_timerange = TimeRange.parse_timerange("20180111-20180114")
@@ -107,9 +103,8 @@ def test_get_timerange_from_live_historic_predictions(mocker, freqai_conf):
    exchange = get_patched_exchange(mocker, freqai_conf)
    strategy.dp = DataProvider(freqai_conf, exchange)
    freqai = strategy.freqai
-    freqai.live = False
+    freqai.live = True
    freqai.dk = FreqaiDataKitchen(freqai_conf)
-    freqai.dk.live = False
    timerange = TimeRange.parse_timerange("20180126-20180130")
    freqai.dd.load_all_pair_histories(timerange, freqai.dk)
    sub_timerange = TimeRange.parse_timerange("20180128-20180130")
--- a/tests/freqai/test_freqai_datakitchen.py
+++ b/tests/freqai/test_freqai_datakitchen.py
@@ -180,7 +180,6 @@ def test_get_full_model_path(mocker, freqai_conf, model):
    freqai = strategy.freqai
    freqai.live = True
    freqai.dk = FreqaiDataKitchen(freqai_conf)
-    freqai.dk.live = True
    timerange = TimeRange.parse_timerange("20180110-20180130")
    freqai.dd.load_all_pair_histories(timerange, freqai.dk)

--- a/tests/freqai/test_freqai_interface.py
+++ b/tests/freqai/test_freqai_interface.py
@@ -87,7 +87,6 @@ def test_extract_data_and_train_model_Standard(mocker, freqai_conf, model, pca,
    freqai.live = True
    freqai.can_short = can_short
    freqai.dk = FreqaiDataKitchen(freqai_conf)
-    freqai.dk.live = True
    freqai.dk.set_paths('ADA/BTC', 10000)
    timerange = TimeRange.parse_timerange("20180110-20180130")
    freqai.dd.load_all_pair_histories(timerange, freqai.dk)
@@ -136,7 +135,6 @@ def test_extract_data_and_train_model_MultiTargets(mocker, freqai_conf, model, s
    freqai = strategy.freqai
    freqai.live = True
    freqai.dk = FreqaiDataKitchen(freqai_conf)
-    freqai.dk.live = True
    timerange = TimeRange.parse_timerange("20180110-20180130")
    freqai.dd.load_all_pair_histories(timerange, freqai.dk)

@@ -180,7 +178,6 @@ def test_extract_data_and_train_model_Classifiers(mocker, freqai_conf, model):
    freqai = strategy.freqai
    freqai.live = True
    freqai.dk = FreqaiDataKitchen(freqai_conf)
-    freqai.dk.live = True
    timerange = TimeRange.parse_timerange("20180110-20180130")
    freqai.dd.load_all_pair_histories(timerange, freqai.dk)

@@ -374,9 +371,6 @@ def test_backtesting_fit_live_predictions(mocker, freqai_conf, caplog):
    sub_timerange = TimeRange.parse_timerange("20180129-20180130")
    corr_df, base_df = freqai.dd.get_base_and_corr_dataframes(sub_timerange, "LTC/BTC", freqai.dk)
    df = freqai.dk.use_strategy_to_populate_indicators(strategy, corr_df, base_df, "LTC/BTC")
-    df = strategy.set_freqai_targets(df.copy(), metadata={"pair": "LTC/BTC"})
-    df = freqai.dk.remove_special_chars_from_feature_names(df)
-    freqai.dk.get_unique_classes_from_labels(df)
    freqai.dk.pair = "ADA/BTC"
    freqai.dk.full_df = df.fillna(0)
    freqai.dk.full_df
@@ -400,7 +394,6 @@ def test_principal_component_analysis(mocker, freqai_conf):
    freqai = strategy.freqai
    freqai.live = True
    freqai.dk = FreqaiDataKitchen(freqai_conf)
-    freqai.dk.live = True
    timerange = TimeRange.parse_timerange("20180110-20180130")
    freqai.dd.load_all_pair_histories(timerange, freqai.dk)

@@ -432,12 +425,10 @@ def test_plot_feature_importance(mocker, freqai_conf):
    freqai = strategy.freqai
    freqai.live = True
    freqai.dk = FreqaiDataKitchen(freqai_conf)
-    freqai.dk.live = True
    timerange = TimeRange.parse_timerange("20180110-20180130")
    freqai.dd.load_all_pair_histories(timerange, freqai.dk)

-    freqai.dd.pair_dict = {"ADA/BTC": {"model_filename": "fake_name",
-                                       "trained_timestamp": 1, "data_path": "", "extras": {}}}
+    freqai.dd.pair_dict = MagicMock()

    data_load_timerange = TimeRange.parse_timerange("20180110-20180130")
    new_timerange = TimeRange.parse_timerange("20180120-20180130")
--- a/tests/strategy/test_interface.py
+++ b/tests/strategy/test_interface.py
@@ -986,8 +986,7 @@ def test_auto_hyperopt_interface_loadparams(default_conf, mocker, caplog):
            }
        }
    }
-    mocker.patch('freqtrade.strategy.hyper.HyperoptTools.load_params',
-                 return_value=expected_result)
+    mocker.patch('freqtrade.strategy.hyper.json_load', return_value=expected_result)
    PairLocks.timeframe = default_conf['timeframe']
    strategy = StrategyResolver.load_strategy(default_conf)
    assert strategy.stoploss == -0.05
@@ -1006,13 +1005,11 @@ def test_auto_hyperopt_interface_loadparams(default_conf, mocker, caplog):
        }
    }

-    mocker.patch('freqtrade.strategy.hyper.HyperoptTools.load_params',
-                 return_value=expected_result)
+    mocker.patch('freqtrade.strategy.hyper.json_load', return_value=expected_result)
    with pytest.raises(OperationalException, match="Invalid parameter file provided."):
        StrategyResolver.load_strategy(default_conf)

-    mocker.patch('freqtrade.strategy.hyper.HyperoptTools.load_params',
-                 MagicMock(side_effect=ValueError()))
+    mocker.patch('freqtrade.strategy.hyper.json_load', MagicMock(side_effect=ValueError()))

    StrategyResolver.load_strategy(default_conf)
    assert log_has("Invalid parameter file format.", caplog)
--- a/tests/test_freqtradebot.py
+++ b/tests/test_freqtradebot.py
@@ -356,7 +356,7 @@ def test_create_trade_no_stake_amount(default_conf_usdt, ticker_usdt, fee, mocke
@pytest.mark.parametrize("is_short", [False, True])
@pytest.mark.parametrize('stake_amount,create,amount_enough,max_open_trades', [
    (5.0, True, True, 99),
-    (0.042, True, False, 99),  # Amount will be adjusted to min - which is 0.051
+    (0.049, True, False, 99),  # Amount will be adjusted to min - which is 0.051
    (0, False, True, 99),
    (UNLIMITED_STAKE_AMOUNT, False, True, 0),
 ])
@@ -1290,137 +1290,6 @@ def test_handle_stoploss_on_exchange(mocker, default_conf_usdt, fee, caplog, is_
    assert trade.exit_reason == str(ExitType.EMERGENCY_EXIT)


-@pytest.mark.parametrize("is_short", [False, True])
-def test_handle_stoploss_on_exchange_partial(
-        mocker, default_conf_usdt, fee, is_short, limit_order) -> None:
-    stop_order_dict = {'id': "101", "status": "open"}
-    stoploss = MagicMock(return_value=stop_order_dict)
-    enter_order = limit_order[entry_side(is_short)]
-    exit_order = limit_order[exit_side(is_short)]
-    patch_RPCManager(mocker)
-    patch_exchange(mocker)
-    mocker.patch.multiple(
-        EXMS,
-        fetch_ticker=MagicMock(return_value={
-            'bid': 1.9,
-            'ask': 2.2,
-            'last': 1.9
-        }),
-        create_order=MagicMock(side_effect=[
-            enter_order,
-            exit_order,
-        ]),
-        get_fee=fee,
-        create_stoploss=stoploss
-    )
-    freqtrade = FreqtradeBot(default_conf_usdt)
-    patch_get_signal(freqtrade, enter_short=is_short, enter_long=not is_short)
-
-    freqtrade.enter_positions()
-    trade = Trade.session.scalars(select(Trade)).first()
-    trade.is_short = is_short
-    trade.is_open = True
-    trade.open_order_id = None
-    trade.stoploss_order_id = None
-
-    assert freqtrade.handle_stoploss_on_exchange(trade) is False
-    assert stoploss.call_count == 1
-    assert trade.stoploss_order_id == "101"
-    assert trade.amount == 30
-    stop_order_dict.update({'id': "102"})
-    # Stoploss on exchange is cancelled on exchange, but filled partially.
-    # Must update trade amount to guarantee successful exit.
-    stoploss_order_hit = MagicMock(return_value={
-        'id': "101",
-        'status': 'canceled',
-        'type': 'stop_loss_limit',
-        'price': 3,
-        'average': 2,
-        'filled': trade.amount / 2,
-        'remaining': trade.amount / 2,
-        'amount': enter_order['amount'],
-    })
-    mocker.patch(f'{EXMS}.fetch_stoploss_order', stoploss_order_hit)
-    assert freqtrade.handle_stoploss_on_exchange(trade) is False
-    # Stoploss filled partially ...
-    assert trade.amount == 15
-
-    assert trade.stoploss_order_id == "102"
-
-
-@pytest.mark.parametrize("is_short", [False, True])
-def test_handle_stoploss_on_exchange_partial_cancel_here(
-        mocker, default_conf_usdt, fee, is_short, limit_order, caplog) -> None:
-    stop_order_dict = {'id': "101", "status": "open"}
-    default_conf_usdt['trailing_stop'] = True
-    stoploss = MagicMock(return_value=stop_order_dict)
-    enter_order = limit_order[entry_side(is_short)]
-    exit_order = limit_order[exit_side(is_short)]
-    patch_RPCManager(mocker)
-    patch_exchange(mocker)
-    mocker.patch.multiple(
-        EXMS,
-        fetch_ticker=MagicMock(return_value={
-            'bid': 1.9,
-            'ask': 2.2,
-            'last': 1.9
-        }),
-        create_order=MagicMock(side_effect=[
-            enter_order,
-            exit_order,
-        ]),
-        get_fee=fee,
-        create_stoploss=stoploss
-    )
-    freqtrade = FreqtradeBot(default_conf_usdt)
-    patch_get_signal(freqtrade, enter_short=is_short, enter_long=not is_short)
-
-    freqtrade.enter_positions()
-    trade = Trade.session.scalars(select(Trade)).first()
-    trade.is_short = is_short
-    trade.is_open = True
-    trade.open_order_id = None
-    trade.stoploss_order_id = None
-
-    assert freqtrade.handle_stoploss_on_exchange(trade) is False
-    assert stoploss.call_count == 1
-    assert trade.stoploss_order_id == "101"
-    assert trade.amount == 30
-    stop_order_dict.update({'id': "102"})
-    # Stoploss on exchange is open.
-    # Freqtrade cancels the stop - but cancel returns a partial filled order.
-    stoploss_order_hit = MagicMock(return_value={
-        'id': "101",
-        'status': 'open',
-        'type': 'stop_loss_limit',
-        'price': 3,
-        'average': 2,
-        'filled': 0,
-        'remaining': trade.amount,
-        'amount': enter_order['amount'],
-    })
-    stoploss_order_cancel = MagicMock(return_value={
-        'id': "101",
-        'status': 'canceled',
-        'type': 'stop_loss_limit',
-        'price': 3,
-        'average': 2,
-        'filled': trade.amount / 2,
-        'remaining': trade.amount / 2,
-        'amount': enter_order['amount'],
-    })
-    mocker.patch(f'{EXMS}.fetch_stoploss_order', stoploss_order_hit)
-    mocker.patch(f'{EXMS}.cancel_stoploss_order_with_result', stoploss_order_cancel)
-    trade.stoploss_last_update = arrow.utcnow().shift(minutes=-10).datetime
-
-    assert freqtrade.handle_stoploss_on_exchange(trade) is False
-    # Canceled Stoploss filled partially ...
-    assert log_has_re('Cancelling current stoploss on exchange.*', caplog)
-
-    assert trade.stoploss_order_id == "102"
-    assert trade.amount == 15
-
-
@pytest.mark.parametrize("is_short", [False, True])
 def test_handle_sle_cancel_cant_recreate(mocker, default_conf_usdt, fee, caplog, is_short,
                                         limit_order) -> None:
@@ -1802,7 +1671,7 @@ def test_stoploss_on_exchange_price_rounding(
        EXMS,
        get_fee=fee,
    )
-    price_mock = MagicMock(side_effect=lambda p, s, **kwargs: int(s))
+    price_mock = MagicMock(side_effect=lambda p, s: int(s))
    stoploss_mock = MagicMock(return_value={'id': '13434334'})
    adjust_mock = MagicMock(return_value=False)
    mocker.patch.multiple(
@@ -2955,9 +2824,6 @@ def test_manage_open_orders_exit_usercustom(
    assert rpc_mock.call_count == 2
    assert freqtrade.strategy.check_exit_timeout.call_count == 1
    assert freqtrade.strategy.check_entry_timeout.call_count == 0
-    trade = Trade.session.scalars(select(Trade)).first()
-    # cancelling didn't succeed - order-id remains open.
-    assert trade.open_order_id is not None

    # 2nd canceled trade - Fail execute exit
    caplog.clear()
@@ -3468,7 +3334,6 @@ def test_handle_cancel_exit_cancel_exception(mocker, default_conf_usdt) -> None:

    # TODO: should not be magicmock
    trade = MagicMock()
-    trade.open_order_id = '125'
    reason = CANCEL_REASON['TIMEOUT']
    order = {'remaining': 1,
             'id': '125',
@@ -3476,10 +3341,6 @@ def test_handle_cancel_exit_cancel_exception(mocker, default_conf_usdt) -> None:
             'status': "open"}
    assert not freqtrade.handle_cancel_exit(trade, order, reason)

-    # mocker.patch(f'{EXMS}.cancel_order_with_result', return_value=order)
-    # assert not freqtrade.handle_cancel_exit(trade, order, reason)
-    # assert trade.open_order_id == '125'
-

@pytest.mark.parametrize("is_short, open_rate, amt", [
    (False, 2.0, 30.0),
Author	SHA1	Message	Date
Matthias	038a111b45	Merge pull request #8421 from freqtrade/new_release New release 2023.3	2023-03-31 07:09:11 +02:00
Matthias	2ea77b22e0	Bump version to 2023.3	2023-03-30 06:56:49 +02:00
Matthias	a8b1352021	Merge branch 'stable' into new_release	2023-03-30 06:56:35 +02:00
Matthias	a31045874e	Merge pull request #8224 from freqtrade/new_release New release 2023.2	2023-02-26 14:53:52 +01:00
Matthias	25724ef729	Version bump 2023.2	2023-02-25 16:02:36 +01:00
Matthias	46458bf5eb	Merge branch 'stable' into new_release	2023-02-25 16:02:26 +01:00