fix footer

.devcontainer/devcontainer.json

@@ -11,14 +11,12 @@
     "mounts": [
         "source=freqtrade-bashhistory,target=/home/ftuser/commandhistory,type=volume"
     ],
-    "workspaceMount": "source=${localWorkspaceFolder},target=/workspaces/freqtrade,type=bind,consistency=cached",
     // Uncomment to connect as a non-root user if you've added one. See https://aka.ms/vscode-remote/containers/non-root.
     "remoteUser": "ftuser",
 
-    "onCreateCommand": "pip install --user -e .",
     "postCreateCommand": "freqtrade create-userdir --userdir user_data/",
 
-    "workspaceFolder": "/workspaces/freqtrade",
+    "workspaceFolder": "/freqtrade/",
 
     "settings": {
         "terminal.integrated.shell.linux": "/bin/bash",

.github/ISSUE_TEMPLATE/bug_report.md

@@ -20,7 +20,7 @@ Please do not use bug reports to request new features.
   * Operating system: ____
   * Python Version: _____ (`python -V`)
   * CCXT version: _____ (`pip freeze | grep ccxt`)
-  * Freqtrade Version: ____ (`freqtrade -V` or `docker compose run --rm freqtrade -V` for Freqtrade running in docker)
+  * Freqtrade Version: ____ (`freqtrade -V` or `docker-compose run --rm freqtrade -V` for Freqtrade running in docker)
   
 Note: All issues other than enhancement requests will be closed without further comment if the above template is deleted or not filled out.
 

.github/ISSUE_TEMPLATE/feature_request.md

@@ -18,7 +18,7 @@ Have you search for this feature before requesting it? It's highly likely that a
   * Operating system: ____
   * Python Version: _____ (`python -V`)
   * CCXT version: _____ (`pip freeze | grep ccxt`)
-  * Freqtrade Version: ____ (`freqtrade -V` or `docker compose run --rm freqtrade -V` for Freqtrade running in docker)
+  * Freqtrade Version: ____ (`freqtrade -V` or `docker-compose run --rm freqtrade -V` for Freqtrade running in docker)
 
 
 ## Describe the enhancement

.github/ISSUE_TEMPLATE/question.md

@@ -18,7 +18,7 @@ Please do not use the question template to report bugs or to request new feature
   * Operating system: ____
   * Python Version: _____ (`python -V`)
   * CCXT version: _____ (`pip freeze | grep ccxt`)
-  * Freqtrade Version: ____ (`freqtrade -V` or `docker compose run --rm freqtrade -V` for Freqtrade running in docker)
+  * Freqtrade Version: ____ (`freqtrade -V` or `docker-compose run --rm freqtrade -V` for Freqtrade running in docker)
   
 ## Your question
 

.github/workflows/ci.yml

@@ -16,16 +16,15 @@ on:
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
-permissions:
+
-  repository-projects: read
 jobs:
   build_linux:
 
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ ubuntu-20.04, ubuntu-22.04 ]
+        os: [ ubuntu-18.04, ubuntu-20.04, ubuntu-22.04 ]
-        python-version: ["3.8", "3.9", "3.10", "3.11"]
+        python-version: ["3.8", "3.9", "3.10.6"]
 
     steps:
     - uses: actions/checkout@v3
@@ -67,9 +66,15 @@ jobs:
     - name: Tests
       run: |
         pytest --random-order --cov=freqtrade --cov-config=.coveragerc
+      if: matrix.python-version != '3.9' || matrix.os != 'ubuntu-22.04'
+
+    - name: Tests incl. ccxt compatibility tests
+      run: |
+        pytest --random-order --cov=freqtrade --cov-config=.coveragerc --longrun
+      if: matrix.python-version == '3.9' && matrix.os == 'ubuntu-22.04'
 
     - name: Coveralls
-      if: (runner.os == 'Linux' && matrix.python-version == '3.10' && matrix.os == 'ubuntu-22.04')
+      if: (runner.os == 'Linux' && matrix.python-version == '3.9')
       env:
         # Coveralls token. Not used as secret due to github not providing secrets to forked repositories
         COVERALLS_REPO_TOKEN: 6D1m0xupS3FgutfuGao8keFf9Hc0FpIXu
@@ -89,16 +94,16 @@ jobs:
       run: |
         cp config_examples/config_bittrex.example.json config.json
         freqtrade create-userdir --userdir user_data
-        freqtrade hyperopt --datadir tests/testdata -e 6 --strategy SampleStrategy --hyperopt-loss SharpeHyperOptLossDaily --print-all
+        freqtrade hyperopt --datadir tests/testdata -e 5 --strategy SampleStrategy --hyperopt-loss SharpeHyperOptLossDaily --print-all
+
+    - name: Flake8
+      run: |
+        flake8
 
     - name: Sort imports (isort)
       run: |
         isort --check .
 
-    - name: Run Ruff
-      run: |
-        ruff check --format=github .
-
     - name: Mypy
       run: |
         mypy freqtrade scripts tests
@@ -116,7 +121,7 @@ jobs:
     strategy:
       matrix:
         os: [ macos-latest ]
-        python-version: ["3.8", "3.9", "3.10", "3.11"]
+        python-version: ["3.8", "3.9", "3.10.6"]
 
     steps:
     - uses: actions/checkout@v3
@@ -149,19 +154,6 @@ jobs:
       if: runner.os == 'macOS'
       run: |
         brew update
-        # homebrew fails to update python due to unlinking failures
-        # https://github.com/actions/runner-images/issues/6817
-        rm /usr/local/bin/2to3 || true
-        rm /usr/local/bin/2to3-3.11 || true
-        rm /usr/local/bin/idle3 || true
-        rm /usr/local/bin/idle3.11 || true
-        rm /usr/local/bin/pydoc3 || true
-        rm /usr/local/bin/pydoc3.11 || true
-        rm /usr/local/bin/python3 || true
-        rm /usr/local/bin/python3.11 || true
-        rm /usr/local/bin/python3-config || true
-        rm /usr/local/bin/python3.11-config || true
-
         brew install hdf5 c-blosc
         python -m pip install --upgrade pip wheel
         export LD_LIBRARY_PATH=${HOME}/dependencies/lib:$LD_LIBRARY_PATH
@@ -187,14 +179,14 @@ jobs:
         freqtrade create-userdir --userdir user_data
         freqtrade hyperopt --datadir tests/testdata -e 5 --strategy SampleStrategy --hyperopt-loss SharpeHyperOptLossDaily --print-all
 
+    - name: Flake8
+      run: |
+        flake8
+
     - name: Sort imports (isort)
       run: |
         isort --check .
 
-    - name: Run Ruff
-      run: |
-        ruff check --format=github .
-
     - name: Mypy
       run: |
         mypy freqtrade scripts
@@ -213,7 +205,7 @@ jobs:
     strategy:
       matrix:
         os: [ windows-latest ]
-        python-version: ["3.8", "3.9", "3.10", "3.11"]
+        python-version: ["3.8", "3.9", "3.10.6"]
 
     steps:
     - uses: actions/checkout@v3
@@ -249,9 +241,9 @@ jobs:
         freqtrade create-userdir --userdir user_data
         freqtrade hyperopt --datadir tests/testdata -e 5 --strategy SampleStrategy --hyperopt-loss SharpeHyperOptLossDaily --print-all
 
-    - name: Run Ruff
+    - name: Flake8
       run: |
-        ruff check --format=github .
+        flake8
 
     - name: Mypy
       run: |
@@ -266,7 +258,7 @@ jobs:
           webhookUrl: ${{ secrets.DISCORD_WEBHOOK }}
 
   mypy_version_check:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-20.04
     steps:
     - uses: actions/checkout@v3
 
@@ -291,7 +283,7 @@ jobs:
     - uses: pre-commit/action@v3.0.0
 
   docs_check:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-20.04
     steps:
     - uses: actions/checkout@v3
 
@@ -318,66 +310,10 @@ jobs:
           details: Freqtrade doc test failed!
           webhookUrl: ${{ secrets.DISCORD_WEBHOOK }}
 
-
-  build_linux_online:
-    # Run pytest with "live" checks
-    runs-on: ubuntu-22.04
-    steps:
-    - uses: actions/checkout@v3
-
-    - name: Set up Python
-      uses: actions/setup-python@v4
-      with:
-        python-version: "3.9"
-
-    - name: Cache_dependencies
-      uses: actions/cache@v3
-      id: cache
-      with:
-        path: ~/dependencies/
-        key: ${{ runner.os }}-dependencies
-
-    - name: pip cache (linux)
-      uses: actions/cache@v3
-      if: runner.os == 'Linux'
-      with:
-        path: ~/.cache/pip
-        key: test-${{ matrix.os }}-${{ matrix.python-version }}-pip
-
-    - name: TA binary *nix
-      if: steps.cache.outputs.cache-hit != 'true'
-      run: |
-        cd build_helpers && ./install_ta-lib.sh ${HOME}/dependencies/; cd ..
-
-    - name: Installation - *nix
-      if: runner.os == 'Linux'
-      run: |
-        python -m pip install --upgrade pip wheel
-        export LD_LIBRARY_PATH=${HOME}/dependencies/lib:$LD_LIBRARY_PATH
-        export TA_LIBRARY_PATH=${HOME}/dependencies/lib
-        export TA_INCLUDE_PATH=${HOME}/dependencies/include
-        pip install -r requirements-dev.txt
-        pip install -e .
-
-    - name: Tests incl. ccxt compatibility tests
-      env:
-        CI_WEB_PROXY: http://152.67.78.211:13128
-      run: |
-        pytest --random-order --cov=freqtrade --cov-config=.coveragerc --longrun
-
-
   # Notify only once - when CI completes (and after deploy) in case it's successfull
   notify-complete:
-    needs: [
+    needs: [ build_linux, build_macos, build_windows, docs_check, mypy_version_check, pre-commit ]
-      build_linux,
+    runs-on: ubuntu-20.04
-      build_macos,
-      build_windows,
-      docs_check,
-      mypy_version_check,
-      pre-commit,
-      build_linux_online
-    ]
-    runs-on: ubuntu-22.04
     # Discord notification can't handle schedule events
     if: (github.event_name != 'schedule')
     permissions:
@@ -402,7 +338,7 @@ jobs:
 
   deploy:
     needs: [ build_linux, build_macos, build_windows, docs_check, mypy_version_check, pre-commit ]
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-20.04
 
     if: (github.event_name == 'push' || github.event_name == 'schedule' || github.event_name == 'release') && github.repository == 'freqtrade/freqtrade'
 
@@ -425,7 +361,7 @@ jobs:
         python setup.py sdist bdist_wheel
 
     - name: Publish to PyPI (Test)
-      uses: pypa/gh-action-pypi-publish@v1.8.5
+      uses: pypa/gh-action-pypi-publish@v1.5.1
       if: (github.event_name == 'release')
       with:
         user: __token__
@@ -433,7 +369,7 @@ jobs:
         repository_url: https://test.pypi.org/legacy/
 
     - name: Publish to PyPI
-      uses: pypa/gh-action-pypi-publish@v1.8.5
+      uses: pypa/gh-action-pypi-publish@v1.5.1
       if: (github.event_name == 'release')
       with:
         user: __token__
@@ -466,13 +402,12 @@ jobs:
 
     - name: Build and test and push docker images
       env:
+        IMAGE_NAME: freqtradeorg/freqtrade
         BRANCH_NAME: ${{ steps.extract_branch.outputs.branch }}
       run: |
         build_helpers/publish_docker_multi.sh
 
   deploy_arm:
-    permissions:
-      packages: write
     needs: [ deploy ]
     # Only run on 64bit machines
     runs-on: [self-hosted, linux, ARM64]
@@ -495,9 +430,8 @@ jobs:
 
     - name: Build and test and push docker images
       env:
+        IMAGE_NAME: freqtradeorg/freqtrade
         BRANCH_NAME: ${{ steps.extract_branch.outputs.branch }}
-        GHCR_USERNAME: ${{ github.actor }}
-        GHCR_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       run: |
         build_helpers/publish_docker_arm64.sh
 

.github/workflows/draft-pdf.yml

@@ -0,0 +1,23 @@
+on: [push]
+
+jobs:
+  paper:
+    runs-on: ubuntu-latest
+    name: Paper Draft
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Build draft PDF
+        uses: openjournals/openjournals-draft-action@master
+        with:
+          journal: joss
+          # This should be the path to the paper within your repo.
+          paper-path: docs/JOSS_paper/paper.md
+      - name: Upload
+        uses: actions/upload-artifact@v1
+        with:
+          name: paper
+          # This is the output path where Pandoc will write the compiled
+          # PDF. Note, this should be the same directory as the input
+          # paper.md
+          path: docs/JOSS_paper/paper.pdf

.gitignore

@@ -109,6 +109,8 @@ target/
 !*.gitkeep
 !config_examples/config_binance.example.json
 !config_examples/config_bittrex.example.json
+!config_examples/config_ftx.example.json
 !config_examples/config_full.example.json
 !config_examples/config_kraken.example.json
 !config_examples/config_freqai.example.json
+!config_examples/config_freqai-rl.example.json

.pre-commit-config.yaml

@@ -2,40 +2,33 @@
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
   - repo: https://github.com/pycqa/flake8
-    rev: "6.0.0"
+    rev: "4.0.1"
     hooks:
       - id: flake8
         # stages: [push]
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: "v1.0.1"
+    rev: "v0.942"
     hooks:
       - id: mypy
         exclude: build_helpers
         additional_dependencies:
-          - types-cachetools==5.3.0.5
+          - types-cachetools==5.2.1
           - types-filelock==3.2.7
-          - types-requests==2.28.11.17
+          - types-requests==2.28.11
-          - types-tabulate==0.9.0.2
+          - types-tabulate==0.8.11
-          - types-python-dateutil==2.8.19.12
+          - types-python-dateutil==2.8.19
-          - SQLAlchemy==2.0.9
         # stages: [push]
 
   - repo: https://github.com/pycqa/isort
-    rev: "5.12.0"
+    rev: "5.10.1"
     hooks:
       - id: isort
         name: isort (python)
         # stages: [push]
 
-  - repo: https://github.com/charliermarsh/ruff-pre-commit
-    # Ruff version.
-    rev: 'v0.0.255'
-    hooks:
-      - id: ruff
-
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.4.0
+    rev: v2.4.0
     hooks:
       - id: end-of-file-fixer
         exclude: |

CONTRIBUTING.md

@@ -45,17 +45,16 @@ pytest tests/test_<file_name>.py::test_<method_name>
 
 ### 2. Test if your code is PEP8 compliant
 
-#### Run Ruff
+#### Run Flake8
 
 ```bash
-ruff .
+flake8 freqtrade tests scripts
 ```
 
-We receive a lot of code that fails the `ruff` checks.
+We receive a lot of code that fails the `flake8` checks.
 To help with that, we encourage you to install the git pre-commit 
 hook that will warn you when you try to commit code that fails these checks. 
-
+Guide for installing them is [here](http://flake8.pycqa.org/en/latest/user/using-hooks.html).
-you can manually run pre-commit with `pre-commit run -a`.
 
 ##### Additional styles applied
 

Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.10.11-slim-bullseye as base
+FROM python:3.10.7-slim-bullseye as base
 
 # Setup env
 ENV LANG C.UTF-8

README.md

@@ -1,7 +1,6 @@
 # ![freqtrade](https://raw.githubusercontent.com/freqtrade/freqtrade/develop/docs/assets/freqtrade_poweredby.svg)
 
 [![Freqtrade CI](https://github.com/freqtrade/freqtrade/workflows/Freqtrade%20CI/badge.svg)](https://github.com/freqtrade/freqtrade/actions/)
-[![DOI](https://joss.theoj.org/papers/10.21105/joss.04864/status.svg)](https://doi.org/10.21105/joss.04864)
 [![Coverage Status](https://coveralls.io/repos/github/freqtrade/freqtrade/badge.svg?branch=develop&service=github)](https://coveralls.io/github/freqtrade/freqtrade?branch=develop)
 [![Documentation](https://readthedocs.org/projects/freqtrade/badge/)](https://www.freqtrade.io)
 [![Maintainability](https://api.codeclimate.com/v1/badges/5737e6d668200b7518ff/maintainability)](https://codeclimate.com/github/freqtrade/freqtrade/maintainability)
@@ -29,6 +28,7 @@ Please read the [exchange specific notes](docs/exchanges.md) to learn about even
 
 - [X] [Binance](https://www.binance.com/)
 - [X] [Bittrex](https://bittrex.com/)
+- [X] [FTX](https://ftx.com/#a=2258149)
 - [X] [Gate.io](https://www.gate.io/ref/6266643)
 - [X] [Huobi](http://huobi.com/)
 - [X] [Kraken](https://kraken.com/)
@@ -39,8 +39,7 @@ Please read the [exchange specific notes](docs/exchanges.md) to learn about even
 
 - [X] [Binance](https://www.binance.com/)
 - [X] [Gate.io](https://www.gate.io/ref/6266643)
-- [X] [OKX](https://okx.com/)
+- [X] [OKX](https://okx.com/).
-- [X] [Bybit](https://bybit.com/)
 
 Please make sure to read the [exchange specific notes](docs/exchanges.md), as well as the [trading with leverage](docs/leverage.md) documentation before diving in.
 
@@ -165,10 +164,6 @@ first. If it hasn't been reported, please
 ensure you follow the template guide so that the team can assist you as
 quickly as possible.
 
-For every [issue](https://github.com/freqtrade/freqtrade/issues/new/choose) created, kindly follow up and mark satisfaction or reminder to close issue when equilibrium ground is reached.
-
---Maintain github's [community policy](https://docs.github.com/en/site-policy/github-terms/github-community-code-of-conduct)--
-
 ### [Feature Requests](https://github.com/freqtrade/freqtrade/labels/enhancement)
 
 Have you a great idea to improve the bot you want to share? Please,

build_helpers/install_ta-lib.sh

@@ -8,8 +8,8 @@ if [ -n "$2" ] || [ ! -f "${INSTALL_LOC}/lib/libta_lib.a" ]; then
   tar zxvf ta-lib-0.4.0-src.tar.gz
   cd ta-lib \
   && sed -i.bak "s|0.00000001|0.000000000000000001 |g" src/ta_func/ta_utility.h \
-  && curl 'https://raw.githubusercontent.com/gcc-mirror/gcc/master/config.guess' -o config.guess \
+  && curl 'http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD' -o config.guess \
-  && curl 'https://raw.githubusercontent.com/gcc-mirror/gcc/master/config.sub' -o config.sub \
+  && curl 'http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD' -o config.sub \
   && ./configure --prefix=${INSTALL_LOC}/ \
   && make
   if [ $? -ne 0 ]; then

build_helpers/install_windows.ps1

@@ -14,8 +14,5 @@ if ($pyv -eq '3.9') {
 if ($pyv -eq '3.10') {
     pip install build_helpers\TA_Lib-0.4.25-cp310-cp310-win_amd64.whl
 }
-if ($pyv -eq '3.11') {
-    pip install build_helpers\TA_Lib-0.4.25-cp311-cp311-win_amd64.whl
-}
 pip install -r requirements-dev.txt
 pip install -e .

build_helpers/pre_commit_update.py

@@ -8,17 +8,12 @@ import yaml
 
 pre_commit_file = Path('.pre-commit-config.yaml')
 require_dev = Path('requirements-dev.txt')
-require = Path('requirements.txt')
 
 with require_dev.open('r') as rfile:
     requirements = rfile.readlines()
 
-with require.open('r') as rfile:
-    requirements.extend(rfile.readlines())
-
 # Extract types only
-type_reqs = [r.strip('\n') for r in requirements if r.startswith(
+type_reqs = [r.strip('\n') for r in requirements if r.startswith('types-')]
-    'types-') or r.startswith('SQLAlchemy')]
 
 with pre_commit_file.open('r') as file:
     f = yaml.load(file, Loader=yaml.FullLoader)

build_helpers/publish_docker_arm64.sh

@@ -3,22 +3,16 @@
 # Use BuildKit, otherwise building on ARM fails
 export DOCKER_BUILDKIT=1
 
-IMAGE_NAME=freqtradeorg/freqtrade
-CACHE_IMAGE=freqtradeorg/freqtrade_cache
-GHCR_IMAGE_NAME=ghcr.io/freqtrade/freqtrade
-
 # Replace / with _ to create a valid tag
 TAG=$(echo "${BRANCH_NAME}" | sed -e "s/\//_/g")
 TAG_PLOT=${TAG}_plot
 TAG_FREQAI=${TAG}_freqai
-TAG_FREQAI_RL=${TAG_FREQAI}rl
-TAG_FREQAI_TORCH=${TAG_FREQAI}torch
 TAG_PI="${TAG}_pi"
 
 TAG_ARM=${TAG}_arm
 TAG_PLOT_ARM=${TAG_PLOT}_arm
 TAG_FREQAI_ARM=${TAG_FREQAI}_arm
-TAG_FREQAI_RL_ARM=${TAG_FREQAI_RL}_arm
+CACHE_IMAGE=freqtradeorg/freqtrade_cache
 
 echo "Running for ${TAG}"
 
@@ -42,16 +36,14 @@ if [ $? -ne 0 ]; then
     echo "failed building multiarch images"
     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 .
-
 # Tag image for upload and next build step
 docker tag freqtrade:$TAG_ARM ${CACHE_IMAGE}:$TAG_ARM
+
+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 tag freqtrade:$TAG_PLOT_ARM ${CACHE_IMAGE}:$TAG_PLOT_ARM
 docker tag freqtrade:$TAG_FREQAI_ARM ${CACHE_IMAGE}:$TAG_FREQAI_ARM
-docker tag freqtrade:$TAG_FREQAI_RL_ARM ${CACHE_IMAGE}:$TAG_FREQAI_RL_ARM
 
 # Run backtest
 docker run --rm -v $(pwd)/config_examples/config_bittrex.example.json:/freqtrade/config.json:ro -v $(pwd)/tests:/tests freqtrade:${TAG_ARM} backtesting --datadir /tests/testdata --strategy-path /tests/strategy/strats/ --strategy StrategyTestV3
@@ -63,9 +55,9 @@ fi
 
 docker images
 
+# docker push ${IMAGE_NAME}
 docker push ${CACHE_IMAGE}:$TAG_PLOT_ARM
 docker push ${CACHE_IMAGE}:$TAG_FREQAI_ARM
-docker push ${CACHE_IMAGE}:$TAG_FREQAI_RL_ARM
 docker push ${CACHE_IMAGE}:$TAG_ARM
 
 # Create multi-arch image
@@ -73,47 +65,22 @@ docker push ${CACHE_IMAGE}:$TAG_ARM
 # Otherwise installation might fail.
 echo "create manifests"
 
-docker manifest create ${IMAGE_NAME}:${TAG} ${CACHE_IMAGE}:${TAG} ${CACHE_IMAGE}:${TAG_ARM} ${IMAGE_NAME}:${TAG_PI}
+docker manifest create --amend ${IMAGE_NAME}:${TAG} ${CACHE_IMAGE}:${TAG_ARM} ${IMAGE_NAME}:${TAG_PI} ${CACHE_IMAGE}:${TAG}
 docker manifest push -p ${IMAGE_NAME}:${TAG}
 
-docker manifest create ${IMAGE_NAME}:${TAG_PLOT} ${CACHE_IMAGE}:${TAG_PLOT} ${CACHE_IMAGE}:${TAG_PLOT_ARM}
+docker manifest create ${IMAGE_NAME}:${TAG_PLOT} ${CACHE_IMAGE}:${TAG_PLOT_ARM} ${CACHE_IMAGE}:${TAG_PLOT}
 docker manifest push -p ${IMAGE_NAME}:${TAG_PLOT}
 
-docker manifest create ${IMAGE_NAME}:${TAG_FREQAI} ${CACHE_IMAGE}:${TAG_FREQAI} ${CACHE_IMAGE}:${TAG_FREQAI_ARM}
+docker manifest create ${IMAGE_NAME}:${TAG_FREQAI} ${CACHE_IMAGE}:${TAG_FREQAI_ARM} ${CACHE_IMAGE}:${TAG_FREQAI}
 docker manifest push -p ${IMAGE_NAME}:${TAG_FREQAI}
 
-docker manifest create ${IMAGE_NAME}:${TAG_FREQAI_RL} ${CACHE_IMAGE}:${TAG_FREQAI_RL} ${CACHE_IMAGE}:${TAG_FREQAI_RL_ARM}
-docker manifest push -p ${IMAGE_NAME}:${TAG_FREQAI_RL}
-
-# Create special Torch tag - which is identical to the RL tag.
-docker manifest create ${IMAGE_NAME}:${TAG_FREQAI_TORCH} ${CACHE_IMAGE}:${TAG_FREQAI_RL} ${CACHE_IMAGE}:${TAG_FREQAI_RL_ARM}
-docker manifest push -p ${IMAGE_NAME}:${TAG_FREQAI_TORCH}
-
-# copy images to ghcr.io
-
-alias crane="docker run --rm -i -v $(pwd)/.crane:/home/nonroot/.docker/ gcr.io/go-containerregistry/crane"
-mkdir .crane
-chmod a+rwx .crane
-
-echo "${GHCR_TOKEN}" | crane auth login ghcr.io -u "${GHCR_USERNAME}" --password-stdin
-
-crane copy ${IMAGE_NAME}:${TAG_FREQAI_RL} ${GHCR_IMAGE_NAME}:${TAG_FREQAI_RL}
-crane copy ${IMAGE_NAME}:${TAG_FREQAI_RL} ${GHCR_IMAGE_NAME}:${TAG_FREQAI_TORCH}
-crane copy ${IMAGE_NAME}:${TAG_FREQAI} ${GHCR_IMAGE_NAME}:${TAG_FREQAI}
-crane copy ${IMAGE_NAME}:${TAG_PLOT} ${GHCR_IMAGE_NAME}:${TAG_PLOT}
-crane copy ${IMAGE_NAME}:${TAG} ${GHCR_IMAGE_NAME}:${TAG}
-
 # Tag as latest for develop builds
 if [ "${TAG}" = "develop" ]; then
-    echo 'Tagging image as latest'
     docker manifest create ${IMAGE_NAME}:latest ${CACHE_IMAGE}:${TAG_ARM} ${IMAGE_NAME}:${TAG_PI} ${CACHE_IMAGE}:${TAG}
     docker manifest push -p ${IMAGE_NAME}:latest
-
-    crane copy ${IMAGE_NAME}:latest ${GHCR_IMAGE_NAME}:latest
 fi
 
 docker images
-rm -rf .crane
 
 # Cleanup old images from arm64 node.
 docker image prune -a --force --filter "until=24h"

build_helpers/publish_docker_multi.sh

@@ -2,17 +2,15 @@
 
 # The below assumes a correctly setup docker buildx environment
 
-IMAGE_NAME=freqtradeorg/freqtrade
-CACHE_IMAGE=freqtradeorg/freqtrade_cache
 # Replace / with _ to create a valid tag
 TAG=$(echo "${BRANCH_NAME}" | sed -e "s/\//_/g")
 TAG_PLOT=${TAG}_plot
 TAG_FREQAI=${TAG}_freqai
-TAG_FREQAI_RL=${TAG_FREQAI}rl
 TAG_PI="${TAG}_pi"
 
 PI_PLATFORM="linux/arm/v7"
 echo "Running for ${TAG}"
+CACHE_IMAGE=freqtradeorg/freqtrade_cache
 CACHE_TAG=${CACHE_IMAGE}:${TAG_PI}_cache
 
 # Add commit and commit_message to docker container
@@ -27,10 +25,7 @@ if [ "${GITHUB_EVENT_NAME}" = "schedule" ]; then
         --cache-to=type=registry,ref=${CACHE_TAG} \
         -f docker/Dockerfile.armhf \
         --platform ${PI_PLATFORM} \
-        -t ${IMAGE_NAME}:${TAG_PI} \
+        -t ${IMAGE_NAME}:${TAG_PI} --push .
-        --push \
-        --provenance=false \
-        .
 else
     echo "event ${GITHUB_EVENT_NAME}: building with cache"
     # Build regular image
@@ -39,16 +34,12 @@ else
 
     # Pull last build to avoid rebuilding the whole image
     # docker pull --platform ${PI_PLATFORM} ${IMAGE_NAME}:${TAG}
-    # disable provenance due to https://github.com/docker/buildx/issues/1509
     docker buildx build \
         --cache-from=type=registry,ref=${CACHE_TAG} \
         --cache-to=type=registry,ref=${CACHE_TAG} \
         -f docker/Dockerfile.armhf \
         --platform ${PI_PLATFORM} \
-        -t ${IMAGE_NAME}:${TAG_PI} \
+        -t ${IMAGE_NAME}:${TAG_PI} --push .
-        --push \
-        --provenance=false \
-        .
 fi
 
 if [ $? -ne 0 ]; then
@@ -58,13 +49,11 @@ 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 --cache-from freqtrade:${TAG} --build-arg sourceimage=${CACHE_IMAGE} --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 --cache-from freqtrade:${TAG} --build-arg sourceimage=${CACHE_IMAGE} --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 tag freqtrade:$TAG_PLOT ${CACHE_IMAGE}:$TAG_PLOT
 docker tag freqtrade:$TAG_FREQAI ${CACHE_IMAGE}:$TAG_FREQAI
-docker tag freqtrade:$TAG_FREQAI_RL ${CACHE_IMAGE}:$TAG_FREQAI_RL
 
 # Run backtest
 docker run --rm -v $(pwd)/config_examples/config_bittrex.example.json:/freqtrade/config.json:ro -v $(pwd)/tests:/tests freqtrade:${TAG} backtesting --datadir /tests/testdata --strategy-path /tests/strategy/strats/ --strategy StrategyTestV3
@@ -76,10 +65,11 @@ fi
 
 docker images
 
-docker push ${CACHE_IMAGE}:$TAG
+docker push ${CACHE_IMAGE}
 docker push ${CACHE_IMAGE}:$TAG_PLOT
 docker push ${CACHE_IMAGE}:$TAG_FREQAI
-docker push ${CACHE_IMAGE}:$TAG_FREQAI_RL
+docker push ${CACHE_IMAGE}:$TAG
+
 
 docker images
 

config_examples/config_binance.example.json

@@ -53,12 +53,26 @@
             "XTZ/BTC"
         ],
         "pair_blacklist": [
-            "BNB/.*"
+            "BNB/BTC"
         ]
     },
     "pairlists": [
         {"method": "StaticPairList"}
     ],
+    "edge": {
+        "enabled": false,
+        "process_throttle_secs": 3600,
+        "calculate_since_number_of_days": 7,
+        "allowed_risk": 0.01,
+        "stoploss_range_min": -0.01,
+        "stoploss_range_max": -0.1,
+        "stoploss_range_step": -0.01,
+        "minimum_winrate": 0.60,
+        "minimum_expectancy": 0.20,
+        "min_trade_number": 10,
+        "max_trade_duration_minute": 1440,
+        "remove_pumps": false
+    },
     "telegram": {
         "enabled": false,
         "token": "your_telegram_token",

config_examples/config_bittrex.example.json

@@ -56,6 +56,20 @@
     "pairlists": [
         {"method": "StaticPairList"}
     ],
+    "edge": {
+        "enabled": false,
+        "process_throttle_secs": 3600,
+        "calculate_since_number_of_days": 7,
+        "allowed_risk": 0.01,
+        "stoploss_range_min": -0.01,
+        "stoploss_range_max": -0.1,
+        "stoploss_range_step": -0.01,
+        "minimum_winrate": 0.60,
+        "minimum_expectancy": 0.20,
+        "min_trade_number": 10,
+        "max_trade_duration_minute": 1440,
+        "remove_pumps": false
+    },
     "telegram": {
         "enabled": false,
         "token": "your_telegram_token",

config_examples/config_freqai.example.json

@@ -18,11 +18,16 @@
         "name": "binance",
         "key": "",
         "secret": "",
-        "ccxt_config": {},
+        "ccxt_config": {
-        "ccxt_async_config": {},
+            "enableRateLimit": true
+        },
+        "ccxt_async_config": {
+            "enableRateLimit": true,
+            "rateLimit": 200
+        },
         "pair_whitelist": [
-            "1INCH/USDT:USDT",
+            "1INCH/USDT",
-            "ALGO/USDT:USDT"
+            "ALGO/USDT"
         ],
         "pair_blacklist": []
     },
@@ -48,7 +53,7 @@
     ],
     "freqai": {
         "enabled": true,
-        "purge_old_models": 2,
+        "purge_old_models": true,
         "train_period_days": 15,
         "backtest_period_days": 7,
         "live_retrain_hours": 0,
@@ -60,8 +65,8 @@
                 "1h"
             ],
             "include_corr_pairlist": [
-                "BTC/USDT:USDT",
+                "BTC/USDT",
-                "ETH/USDT:USDT"
+                "ETH/USDT"
             ],
             "label_period_candles": 20,
             "include_shifted_candles": 2,
@@ -79,7 +84,9 @@
             "test_size": 0.33,
             "random_state": 1
         },
-        "model_training_parameters": {}
+        "model_training_parameters": {
+            "n_estimators": 1000
+        }
     },
     "bot_name": "",
     "force_entry_enable": true,

config_examples/config_ftx.example.json

@@ -0,0 +1,96 @@
+{
+    "max_open_trades": 3,
+    "stake_currency": "USD",
+    "stake_amount": 50,
+    "tradable_balance_ratio": 0.99,
+    "fiat_display_currency": "USD",
+    "timeframe": "5m",
+    "dry_run": true,
+    "cancel_open_orders_on_exit": false,
+    "unfilledtimeout": {
+        "entry": 10,
+        "exit": 10,
+        "exit_timeout_count": 0,
+        "unit": "minutes"
+    },
+    "entry_pricing": {
+        "price_side": "same",
+        "use_order_book": true,
+        "order_book_top": 1,
+        "price_last_balance": 0.0,
+        "check_depth_of_market": {
+            "enabled": false,
+            "bids_to_ask_delta": 1
+        }
+    },
+    "exit_pricing": {
+        "price_side": "same",
+        "use_order_book": true,
+        "order_book_top": 1
+    },
+    "exchange": {
+        "name": "ftx",
+        "key": "your_exchange_key",
+        "secret": "your_exchange_secret",
+        "ccxt_config": {},
+        "ccxt_async_config": {},
+        "pair_whitelist": [
+            "BTC/USD",
+            "ETH/USD",
+            "BNB/USD",
+            "USDT/USD",
+            "LTC/USD",
+            "SRM/USD",
+            "SXP/USD",
+            "XRP/USD",
+            "DOGE/USD",
+            "1INCH/USD",
+            "CHZ/USD",
+            "MATIC/USD",
+            "LINK/USD",
+            "OXY/USD",
+            "SUSHI/USD"
+        ],
+        "pair_blacklist": [
+            "FTT/USD"
+        ]
+    },
+    "pairlists": [
+        {"method": "StaticPairList"}
+    ],
+    "edge": {
+        "enabled": false,
+        "process_throttle_secs": 3600,
+        "calculate_since_number_of_days": 7,
+        "allowed_risk": 0.01,
+        "stoploss_range_min": -0.01,
+        "stoploss_range_max": -0.1,
+        "stoploss_range_step": -0.01,
+        "minimum_winrate": 0.60,
+        "minimum_expectancy": 0.20,
+        "min_trade_number": 10,
+        "max_trade_duration_minute": 1440,
+        "remove_pumps": false
+    },
+    "telegram": {
+        "enabled": false,
+        "token": "your_telegram_token",
+        "chat_id": "your_telegram_chat_id"
+    },
+    "api_server": {
+        "enabled": false,
+        "listen_ip_address": "127.0.0.1",
+        "listen_port": 8080,
+        "verbosity": "error",
+        "jwt_secret_key": "somethingrandom",
+        "CORS_origins": [],
+        "username": "freqtrader",
+        "password": "SuperSecurePassword"
+    },
+    "bot_name": "freqtrade",
+    "initial_state": "running",
+    "force_entry_enable": false,
+    "internals": {
+        "process_throttle_secs": 5
+    }
+}

config_examples/config_full.example.json

@@ -60,7 +60,6 @@
         "force_entry": "market",
         "stoploss": "market",
         "stoploss_on_exchange": false,
-        "stoploss_price_type": "last",
         "stoploss_on_exchange_interval": 60,
         "stoploss_on_exchange_limit_ratio": 0.99
     },
@@ -205,7 +204,6 @@
     "strategy_path": "user_data/strategies/",
     "recursive_strategy_search": false,
     "add_config_files": [],
-    "reduce_df_footprint": false,
     "dataformat_ohlcv": "json",
     "dataformat_trades": "jsongz"
 }

config_examples/config_kraken.example.json

@@ -64,6 +64,20 @@
     "pairlists": [
         {"method": "StaticPairList"}
     ],
+    "edge": {
+        "enabled": false,
+        "process_throttle_secs": 3600,
+        "calculate_since_number_of_days": 7,
+        "allowed_risk": 0.01,
+        "stoploss_range_min": -0.01,
+        "stoploss_range_max": -0.1,
+        "stoploss_range_step": -0.01,
+        "minimum_winrate": 0.60,
+        "minimum_expectancy": 0.20,
+        "min_trade_number": 10,
+        "max_trade_duration_minute": 1440,
+        "remove_pumps": false
+    },
     "telegram": {
         "enabled": false,
         "token": "your_telegram_token",

docker/Dockerfile.armhf

@@ -1,4 +1,4 @@
-FROM python:3.9.16-slim-bullseye as base
+FROM python:3.9.12-slim-bullseye as base
 
 # Setup env
 ENV LANG C.UTF-8
@@ -11,7 +11,7 @@ ENV FT_APP_ENV="docker"
 # Prepare environment
 RUN mkdir /freqtrade \
   && apt-get update \
-  && apt-get -y install sudo libatlas3-base curl sqlite3 libhdf5-dev libutf8proc-dev libsnappy-dev \
+  && apt-get -y install sudo libatlas3-base curl sqlite3 libhdf5-dev \
   && apt-get clean \
   && useradd -u 1000 -G sudo -U -m ftuser \
   && chown ftuser:ftuser /freqtrade \
@@ -37,7 +37,6 @@ ENV LD_LIBRARY_PATH /usr/local/lib
 COPY --chown=ftuser:ftuser requirements.txt /freqtrade/
 USER ftuser
 RUN  pip install --user --no-cache-dir numpy \
-  && pip install --user /tmp/pyarrow-*.whl \
   && pip install --user --no-cache-dir -r requirements.txt
 
 # Copy dependencies to runtime-image

docker/Dockerfile.freqai_rl

@@ -1,8 +0,0 @@
-ARG sourceimage=freqtradeorg/freqtrade
-ARG sourcetag=develop_freqai
-FROM ${sourceimage}:${sourcetag}
-
-# Install dependencies
-COPY requirements-freqai.txt requirements-freqai-rl.txt /freqtrade/
-
-RUN pip install -r requirements-freqai-rl.txt --user --no-cache-dir

docs/JOSS_paper/note_to_editors.txt

@@ -0,0 +1,15 @@
+Dear Editors,
+We present a paper for ``FreqAI`` a machine learning sandbox for researchers and citizen scientists alike.
+There are a large number of authors, however all have contributed in a significant way to this paper.
+For clarity the contribution of each author is outlined:
+
+  - Robert Caulk            : Conception and software development
+  - Elin Tornquist          : Theoretical brainstorming, data analysis, tool dev
+  - Matthias Voppichler     : Software architecture and code review
+  - Andrew R. Lawless       : Extensive testing, feature brainstorming
+  - Ryan McMullan           : Extensive testing, feature brainstorming
+  - Wagner Costa Santos     : Major backtesting developments, extensive testing
+  - Pascal Schmidt          : Extensive testing, feature brainstorming
+  - Timothy C. Pogue        : Webhooks forecast sharing
+  - Stefan P. Gehring       : Extensive testing, feature brainstorming
+  - Johan van der Vlugt     : Extensive testing, feature brainstorming

docs/JOSS_paper/paper.bib

@@ -0,0 +1,207 @@
+@article{scikit-learn,
+ title={Scikit-learn: Machine Learning in {P}ython},
+ author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.
+         and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.
+         and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and
+         Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},
+ journal={Journal of Machine Learning Research},
+ volume={12},
+ pages={2825--2830},
+ year={2011}
+}
+
+@inproceedings{catboost,
+author = {Prokhorenkova, Liudmila and Gusev, Gleb and Vorobev, Aleksandr and Dorogush, Anna Veronika and Gulin, Andrey},
+title = {CatBoost: Unbiased Boosting with Categorical Features},
+year = {2018},
+publisher = {Curran Associates Inc.},
+address = {Red Hook, NY, USA},
+abstract = {This paper presents the key algorithmic techniques behind CatBoost, a new gradient boosting toolkit. Their combination leads to CatBoost outperforming other publicly available boosting implementations in terms of quality on a variety of datasets. Two critical algorithmic advances introduced in CatBoost are the implementation of ordered boosting, a permutation-driven alternative to the classic algorithm, and an innovative algorithm for processing categorical features. Both techniques were created to fight a prediction shift caused by a special kind of target leakage present in all currently existing implementations of gradient boosting algorithms. In this paper, we provide a detailed analysis of this problem and demonstrate that proposed algorithms solve it effectively, leading to excellent empirical results.},
+booktitle = {Proceedings of the 32nd International Conference on Neural Information Processing Systems},
+pages = {6639–6649},
+numpages = {11},
+location = {Montr\'{e}al, Canada},
+series = {NIPS'18}
+}
+
+
+@article{lightgbm,
+  title={Lightgbm: A highly efficient gradient boosting decision tree},
+  author={Ke, Guolin and Meng, Qi and Finley, Thomas and Wang, Taifeng and Chen, Wei and Ma, Weidong and Ye, Qiwei and Liu, Tie-Yan},
+  journal={Advances in neural information processing systems},
+  volume={30},
+  pages={3146--3154},
+  year={2017}
+} 
+
+@inproceedings{xgboost,
+ author = {Chen, Tianqi and Guestrin, Carlos},
+ title = {{XGBoost}: A Scalable Tree Boosting System},
+ booktitle = {Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining},
+ series = {KDD '16},
+ year = {2016},
+ isbn = {978-1-4503-4232-2},
+ location = {San Francisco, California, USA},
+ pages = {785--794},
+ numpages = {10},
+ url = {http://doi.acm.org/10.1145/2939672.2939785},
+ doi = {10.1145/2939672.2939785},
+ acmid = {2939785},
+ publisher = {ACM},
+ address = {New York, NY, USA},
+ keywords = {large-scale machine learning},
+}
+
+@article{stable-baselines3,
+  author  = {Antonin Raffin and Ashley Hill and Adam Gleave and Anssi Kanervisto and Maximilian Ernestus and Noah Dormann},
+  title   = {Stable-Baselines3: Reliable Reinforcement Learning Implementations},
+  journal = {Journal of Machine Learning Research},
+  year    = {2021},
+  volume  = {22},
+  number  = {268},
+  pages   = {1-8},
+  url     = {http://jmlr.org/papers/v22/20-1364.html}
+}
+
+@misc{openai,
+      title={OpenAI Gym}, 
+      author={Greg Brockman and Vicki Cheung and Ludwig Pettersson and Jonas Schneider and John Schulman and Jie Tang and Wojciech Zaremba},
+      year={2016},
+      eprint={1606.01540},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG}
+}
+
+@misc{tensorflow,
+title={ {TensorFlow}: Large-Scale Machine Learning on Heterogeneous Systems},
+url={https://www.tensorflow.org/},
+note={Software available from tensorflow.org},
+author={
+    Mart\'{i}n~Abadi and
+    Ashish~Agarwal and
+    Paul~Barham and
+    Eugene~Brevdo and
+    Zhifeng~Chen and
+    Craig~Citro and
+    Greg~S.~Corrado and
+    Andy~Davis and
+    Jeffrey~Dean and
+    Matthieu~Devin and
+    Sanjay~Ghemawat and
+    Ian~Goodfellow and
+    Andrew~Harp and
+    Geoffrey~Irving and
+    Michael~Isard and
+    Yangqing Jia and
+    Rafal~Jozefowicz and
+    Lukasz~Kaiser and
+    Manjunath~Kudlur and
+    Josh~Levenberg and
+    Dandelion~Man\'{e} and
+    Rajat~Monga and
+    Sherry~Moore and
+    Derek~Murray and
+    Chris~Olah and
+    Mike~Schuster and
+    Jonathon~Shlens and
+    Benoit~Steiner and
+    Ilya~Sutskever and
+    Kunal~Talwar and
+    Paul~Tucker and
+    Vincent~Vanhoucke and
+    Vijay~Vasudevan and
+    Fernanda~Vi\'{e}gas and
+    Oriol~Vinyals and
+    Pete~Warden and
+    Martin~Wattenberg and
+    Martin~Wicke and
+    Yuan~Yu and
+    Xiaoqiang~Zheng},
+  year={2015},
+}
+
+@incollection{pytorch,
+title = {PyTorch: An Imperative Style, High-Performance Deep Learning Library},
+author = {Paszke, Adam and Gross, Sam and Massa, Francisco and Lerer, Adam and Bradbury, James and Chanan, Gregory and Killeen, Trevor and Lin, Zeming and Gimelshein, Natalia and Antiga, Luca and Desmaison, Alban and Kopf, Andreas and Yang, Edward and DeVito, Zachary and Raison, Martin and Tejani, Alykhan and Chilamkurthy, Sasank and Steiner, Benoit and Fang, Lu and Bai, Junjie and Chintala, Soumith},
+booktitle = {Advances in Neural Information Processing Systems 32},
+editor = {H. Wallach and H. Larochelle and A. Beygelzimer and F. d\textquotesingle Alch\'{e}-Buc and E. Fox and R. Garnett},
+pages = {8024--8035},
+year = {2019},
+publisher = {Curran Associates, Inc.},
+url = {http://papers.neurips.cc/paper/9015-pytorch-an-imperative-style-high-performance-deep-learning-library.pdf}
+}
+
+@ARTICLE{scipy,
+  author  = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and
+            Haberland, Matt and Reddy, Tyler and Cournapeau, David and
+            Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and
+            Bright, Jonathan and {van der Walt}, St{\'e}fan J. and
+            Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and
+            Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and
+            Kern, Robert and Larson, Eric and Carey, C J and
+            Polat, {\.I}lhan and Feng, Yu and Moore, Eric W. and
+            {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and
+            Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and
+            Harris, Charles R. and Archibald, Anne M. and
+            Ribeiro, Ant{\^o}nio H. and Pedregosa, Fabian and
+            {van Mulbregt}, Paul and {SciPy 1.0 Contributors}},
+  title   = {{{SciPy} 1.0: Fundamental Algorithms for Scientific
+            Computing in Python}},
+  journal = {Nature Methods},
+  year    = {2020},
+  volume  = {17},
+  pages   = {261--272},
+  adsurl  = {https://rdcu.be/b08Wh},
+  doi     = {10.1038/s41592-019-0686-2},
+}
+
+@Article{numpy,
+ title         = {Array programming with {NumPy}},
+ author        = {Charles R. Harris and K. Jarrod Millman and St{\'{e}}fan J.
+                 van der Walt and Ralf Gommers and Pauli Virtanen and David
+                 Cournapeau and Eric Wieser and Julian Taylor and Sebastian
+                 Berg and Nathaniel J. Smith and Robert Kern and Matti Picus
+                 and Stephan Hoyer and Marten H. van Kerkwijk and Matthew
+                 Brett and Allan Haldane and Jaime Fern{\'{a}}ndez del
+                 R{\'{i}}o and Mark Wiebe and Pearu Peterson and Pierre
+                 G{\'{e}}rard-Marchant and Kevin Sheppard and Tyler Reddy and
+                 Warren Weckesser and Hameer Abbasi and Christoph Gohlke and
+                 Travis E. Oliphant},
+ year          = {2020},
+ month         = sep,
+ journal       = {Nature},
+ volume        = {585},
+ number        = {7825},
+ pages         = {357--362},
+ doi           = {10.1038/s41586-020-2649-2},
+ publisher     = {Springer Science and Business Media {LLC}},
+ url           = {https://doi.org/10.1038/s41586-020-2649-2}
+}
+
+ @inproceedings{pandas,
+  title={Data structures for statistical computing in python},
+  author={McKinney, Wes and others},
+  booktitle={Proceedings of the 9th Python in Science Conference},
+  volume={445},
+  pages={51--56},
+  year={2010},
+  organization={Austin, TX},
+  doi={10.25080/Majora-92bf1922-00a}
+}
+
+
+
+@online{finrl,
+  title = {AI4Finance-Foundation},
+  year = 2022,
+  url = {https://github.com/AI4Finance-Foundation/FinRL},
+  urldate = {2022-09-30}
+}
+
+
+@online{tensortrade,
+  title = {tensortrade},
+  year = 2022,
+  url = {https://tensortradex.readthedocs.io/en/latest/L},
+  urldate = {2022-09-30}
+}

docs/JOSS_paper/paper.jats

@@ -0,0 +1,941 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE article PUBLIC "-//NLM//DTD JATS (Z39.96) Journal Publishing DTD v1.2 20190208//EN"
+                  "JATS-publishing1.dtd">
+<article xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink" dtd-version="1.2" article-type="other">
+<front>
+<journal-meta>
+<journal-id></journal-id>
+<journal-title-group>
+<journal-title>Journal of Open Source Software</journal-title>
+<abbrev-journal-title>JOSS</abbrev-journal-title>
+</journal-title-group>
+<issn publication-format="electronic">2475-9066</issn>
+<publisher>
+<publisher-name>Open Journals</publisher-name>
+</publisher>
+</journal-meta>
+<article-meta>
+<article-id pub-id-type="publisher-id">0</article-id>
+<article-id pub-id-type="doi">N/A</article-id>
+<title-group>
+<article-title><monospace>FreqAI</monospace>: generalizing adaptive
+modeling for chaotic time-series market forecasts</article-title>
+</title-group>
+<contrib-group>
+<contrib contrib-type="author">
+<contrib-id contrib-id-type="orcid">0000-0001-5618-8629</contrib-id>
+<name>
+<surname>Ph.D</surname>
+<given-names>Robert A. Caulk</given-names>
+</name>
+<xref ref-type="aff" rid="aff-1"/>
+<xref ref-type="aff" rid="aff-2"/>
+</contrib>
+<contrib contrib-type="author">
+<contrib-id contrib-id-type="orcid">0000-0003-3289-8604</contrib-id>
+<name>
+<surname>Ph.D</surname>
+<given-names>Elin Törnquist</given-names>
+</name>
+<xref ref-type="aff" rid="aff-1"/>
+<xref ref-type="aff" rid="aff-2"/>
+</contrib>
+<contrib contrib-type="author">
+<name>
+<surname>Voppichler</surname>
+<given-names>Matthias</given-names>
+</name>
+<xref ref-type="aff" rid="aff-2"/>
+</contrib>
+<contrib contrib-type="author">
+<name>
+<surname>Lawless</surname>
+<given-names>Andrew R.</given-names>
+</name>
+<xref ref-type="aff" rid="aff-2"/>
+</contrib>
+<contrib contrib-type="author">
+<name>
+<surname>McMullan</surname>
+<given-names>Ryan</given-names>
+</name>
+<xref ref-type="aff" rid="aff-2"/>
+</contrib>
+<contrib contrib-type="author">
+<name>
+<surname>Santos</surname>
+<given-names>Wagner Costa</given-names>
+</name>
+<xref ref-type="aff" rid="aff-1"/>
+<xref ref-type="aff" rid="aff-2"/>
+</contrib>
+<contrib contrib-type="author">
+<name>
+<surname>Pogue</surname>
+<given-names>Timothy C.</given-names>
+</name>
+<xref ref-type="aff" rid="aff-1"/>
+<xref ref-type="aff" rid="aff-2"/>
+</contrib>
+<contrib contrib-type="author">
+<name>
+<surname>van der Vlugt</surname>
+<given-names>Johan</given-names>
+</name>
+<xref ref-type="aff" rid="aff-2"/>
+</contrib>
+<contrib contrib-type="author">
+<name>
+<surname>Gehring</surname>
+<given-names>Stefan P.</given-names>
+</name>
+<xref ref-type="aff" rid="aff-2"/>
+</contrib>
+<contrib contrib-type="author">
+<name>
+<surname>Schmidt</surname>
+<given-names>Pascal</given-names>
+</name>
+<xref ref-type="aff" rid="aff-2"/>
+</contrib>
+<aff id="aff-1">
+<institution-wrap>
+<institution>Emergent Methods LLC, Arvada Colorado, 80005,
+USA</institution>
+</institution-wrap>
+</aff>
+<aff id="aff-2">
+<institution-wrap>
+<institution>Freqtrade open source project</institution>
+</institution-wrap>
+</aff>
+</contrib-group>
+<volume>¿VOL?</volume>
+<issue>¿ISSUE?</issue>
+<fpage>¿PAGE?</fpage>
+<permissions>
+<copyright-statement>Authors of papers retain copyright and release the
+work under a Creative Commons Attribution 4.0 International License (CC
+BY 4.0)</copyright-statement>
+<copyright-year>2022</copyright-year>
+<copyright-holder>The article authors</copyright-holder>
+<license license-type="open-access" xlink:href="https://creativecommons.org/licenses/by/4.0/">
+<license-p>Authors of papers retain copyright and release the work under
+a Creative Commons Attribution 4.0 International License (CC BY
+4.0)</license-p>
+</license>
+</permissions>
+<kwd-group kwd-group-type="author">
+<kwd>Python</kwd>
+<kwd>Machine Learning</kwd>
+<kwd>adaptive modeling</kwd>
+<kwd>chaotic systems</kwd>
+<kwd>time-series forecasting</kwd>
+</kwd-group>
+</article-meta>
+</front>
+<body>
+<sec id="statement-of-need">
+  <title>Statement of need</title>
+  <p>Forecasting chaotic time-series based systems, such as
+  equity/cryptocurrency markets, requires a broad set of tools geared
+  toward testing a wide range of hypotheses. Fortunately, a recent
+  maturation of robust machine learning libraries
+  (e.g. <monospace>scikit-learn</monospace>), has opened up a wide range
+  of research possibilities. Scientists from a diverse range of fields
+  can now easily prototype their studies on an abundance of established
+  machine learning algorithms. Similarly, these user-friendly libraries
+  enable “citzen scientists” to use their basic Python skills for
+  data-exploration. However, leveraging these machine learning libraries
+  on historical and live chaotic data sources can be logistically
+  difficult and expensive. Additionally, robust data-collection,
+  storage, and handling presents a disparate challenge.
+  <ext-link ext-link-type="uri" xlink:href="https://www.freqtrade.io/en/latest/freqai/"><monospace>FreqAI</monospace></ext-link>
+  aims to provide a generalized and extensible open-sourced framework
+  geared toward live deployments of adaptive modeling for market
+  forecasting. The <monospace>FreqAI</monospace> framework is
+  effectively a sandbox for the rich world of open-source machine
+  learning libraries. Inside the <monospace>FreqAI</monospace> sandbox,
+  users find they can combine a wide variety of third-party libraries to
+  test creative hypotheses on a free live 24/7 chaotic data source -
+  cryptocurrency exchange data.</p>
+</sec>
+<sec id="summary">
+  <title>Summary</title>
+  <p><ext-link ext-link-type="uri" xlink:href="https://www.freqtrade.io/en/latest/freqai/"><monospace>FreqAI</monospace></ext-link>
+  evolved from a desire to test and compare a range of adaptive
+  time-series forecasting methods on chaotic data. Cryptocurrency
+  markets provide a unique data source since they are operational 24/7
+  and the data is freely available. Luckily, an existing open-source
+  software,
+  <ext-link ext-link-type="uri" xlink:href="https://www.freqtrade.io/en/stable/"><monospace>Freqtrade</monospace></ext-link>,
+  had already matured under a range of talented developers to support
+  robust data collection/storage, as well as robust live environmental
+  interactions for standard algorithmic trading.
+  <monospace>Freqtrade</monospace> also provides a set of data
+  analysis/visualization tools for the evaluation of historical
+  performance as well as live environmental feedback.
+  <monospace>FreqAI</monospace> builds on top of
+  <monospace>Freqtrade</monospace> to include a user-friendly well
+  tested interface for integrating external machine learning libraries
+  for adaptive time-series forecasting. Beyond enabling the integration
+  of existing libraries, <monospace>FreqAI</monospace> hosts a range of
+  custom algorithms and methodologies aimed at improving computational
+  and predictive performances. Thus, <monospace>FreqAI</monospace>
+  contains a range of unique features which can be easily tested in
+  combination with all the existing Python-accessible machine learning
+  libraries to generate novel research on live and historical data.</p>
+  <p>The high-level overview of the software is depicted in Figure
+  1.</p>
+  <p><named-content content-type="image">freqai-algo</named-content>
+  <italic>Abstracted overview of FreqAI algorithm</italic></p>
+  <sec id="connecting-machine-learning-libraries">
+    <title>Connecting machine learning libraries</title>
+    <p>Although the <monospace>FreqAI</monospace> framework is designed
+    to accommodate any Python library in the “Model training” and
+    “Feature set engineering” portions of the software (Figure 1), it
+    already boasts a wide range of well documented examples based on
+    various combinations of:</p>
+    <list list-type="bullet">
+      <list-item>
+        <p>scikit-learn
+        (<xref alt="Pedregosa et al., 2011" rid="ref-scikit-learn" ref-type="bibr">Pedregosa
+        et al., 2011</xref>), Catboost
+        (<xref alt="Prokhorenkova et al., 2018" rid="ref-catboost" ref-type="bibr">Prokhorenkova
+        et al., 2018</xref>), LightGBM
+        (<xref alt="Ke et al., 2017" rid="ref-lightgbm" ref-type="bibr">Ke
+        et al., 2017</xref>), XGBoost
+        (<xref alt="Chen &amp; Guestrin, 2016" rid="ref-xgboost" ref-type="bibr">Chen
+        &amp; Guestrin, 2016</xref>), stable_baselines3
+        (<xref alt="Raffin et al., 2021" rid="ref-stable-baselines3" ref-type="bibr">Raffin
+        et al., 2021</xref>), openai gym
+        (<xref alt="Brockman et al., 2016" rid="ref-openai" ref-type="bibr">Brockman
+        et al., 2016</xref>), tensorflow
+        (<xref alt="Abadi et al., 2015" rid="ref-tensorflow" ref-type="bibr">Abadi
+        et al., 2015</xref>), pytorch
+        (<xref alt="Paszke et al., 2019" rid="ref-pytorch" ref-type="bibr">Paszke
+        et al., 2019</xref>), Scipy
+        (<xref alt="Virtanen et al., 2020" rid="ref-scipy" ref-type="bibr">Virtanen
+        et al., 2020</xref>), Numpy
+        (<xref alt="Harris et al., 2020" rid="ref-numpy" ref-type="bibr">Harris
+        et al., 2020</xref>), and pandas
+        (<xref alt="McKinney &amp; others, 2010" rid="ref-pandas" ref-type="bibr">McKinney
+        &amp; others, 2010</xref>).</p>
+      </list-item>
+    </list>
+    <p>These mature projects contain a wide range of peer-reviewed and
+    industry standard methods, including:</p>
+    <list list-type="bullet">
+      <list-item>
+        <p>Regression, Classification, Neural Networks, Reinforcement
+        Learning, Support Vector Machines, Principal Component Analysis,
+        point clustering, and much more.</p>
+      </list-item>
+    </list>
+    <p>which are all leveraged in <monospace>FreqAI</monospace> for
+    users to use as templates or extend with their own methods.</p>
+  </sec>
+  <sec id="furnishing-novel-methods-and-features">
+    <title>Furnishing novel methods and features</title>
+    <p>Beyond the industry standard methods available through external
+    libraries - <monospace>FreqAI</monospace> includes novel methods
+    which are not available anywhere else in the open-source (or
+    scientific) world. For example, <monospace>FreqAI</monospace>
+    provides :</p>
+    <list list-type="bullet">
+      <list-item>
+        <p>a custom algorithm/methodology for adaptive modeling</p>
+      </list-item>
+      <list-item>
+        <p>rapid and self-monitored feature engineering tools</p>
+      </list-item>
+      <list-item>
+        <p>unique model features/indicators</p>
+      </list-item>
+      <list-item>
+        <p>optimized data collection algorithms</p>
+      </list-item>
+      <list-item>
+        <p>safely integrated outlier detection methods</p>
+      </list-item>
+      <list-item>
+        <p>websocket communicated forecasts</p>
+      </list-item>
+    </list>
+    <p>Of particular interest for researchers,
+    <monospace>FreqAI</monospace> provides the option of large scale
+    experimentation via an optimized websocket communications
+    interface.</p>
+  </sec>
+  <sec id="optimizing-the-back-end">
+    <title>Optimizing the back-end</title>
+    <p><monospace>FreqAI</monospace> aims to make it simple for users to
+    combine all the above tools to run studies based in two distinct
+    modules:</p>
+    <list list-type="bullet">
+      <list-item>
+        <p>backtesting studies</p>
+      </list-item>
+      <list-item>
+        <p>live-deployments</p>
+      </list-item>
+    </list>
+    <p>Both of these modules and their respective data management
+    systems are built on top of
+    <ext-link ext-link-type="uri" xlink:href="https://www.freqtrade.io/en/latest/"><monospace>Freqtrade</monospace></ext-link>,
+    a mature and actively developed cryptocurrency trading software.
+    This means that <monospace>FreqAI</monospace> benefits from a wide
+    range of tangential/disparate feature developments such as:</p>
+    <list list-type="bullet">
+      <list-item>
+        <p>FreqUI, a graphical interface for backtesting and live
+        monitoring</p>
+      </list-item>
+      <list-item>
+        <p>telegram control</p>
+      </list-item>
+      <list-item>
+        <p>robust database handling</p>
+      </list-item>
+      <list-item>
+        <p>futures/leverage trading</p>
+      </list-item>
+      <list-item>
+        <p>dollar cost averaging</p>
+      </list-item>
+      <list-item>
+        <p>trading strategy handling</p>
+      </list-item>
+      <list-item>
+        <p>a variety of free data sources via CCXT (FTX, Binance, Kucoin
+        etc.)</p>
+      </list-item>
+    </list>
+    <p>These features derive from a strong external developer community
+    that shares in the benefit and stability of a communal CI
+    (Continuous Integration) system. Beyond the developer community,
+    <monospace>FreqAI</monospace> benefits strongly from the userbase of
+    <monospace>Freqtrade</monospace>, where most
+    <monospace>FreqAI</monospace> beta-testers/developers originated.
+    This symbiotic relationship between <monospace>Freqtrade</monospace>
+    and <monospace>FreqAI</monospace> ignited a thoroughly tested
+    <ext-link ext-link-type="uri" xlink:href="https://github.com/freqtrade/freqtrade/pull/6832"><monospace>beta</monospace></ext-link>,
+    which demanded a four month beta and
+    <ext-link ext-link-type="uri" xlink:href="https://www.freqtrade.io/en/latest/freqai/">comprehensive
+    documentation</ext-link> containing:</p>
+    <list list-type="bullet">
+      <list-item>
+        <p>numerous example scripts</p>
+      </list-item>
+      <list-item>
+        <p>a full parameter table</p>
+      </list-item>
+      <list-item>
+        <p>methodological descriptions</p>
+      </list-item>
+      <list-item>
+        <p>high-resolution diagrams/figures</p>
+      </list-item>
+      <list-item>
+        <p>detailed parameter setting recommendations</p>
+      </list-item>
+    </list>
+  </sec>
+  <sec id="providing-a-reproducible-foundation-for-researchers">
+    <title>Providing a reproducible foundation for researchers</title>
+    <p><monospace>FreqAI</monospace> provides an extensible, robust,
+    framework for researchers and citizen data scientists. The
+    <monospace>FreqAI</monospace> sandbox enables rapid conception and
+    testing of exotic hypotheses. From a research perspective,
+    <monospace>FreqAI</monospace> handles the multitude of logistics
+    associated with live deployments, historical backtesting, and
+    feature engineering. With <monospace>FreqAI</monospace>, researchers
+    can focus on their primary interests of feature engineering and
+    hypothesis testing rather than figuring out how to collect and
+    handle data. Further - the well maintained and easily installed
+    open-source framework of <monospace>FreqAI</monospace> enables
+    reproducible scientific studies. This reproducibility component is
+    essential to general scientific advancement in time-series
+    forecasting for chaotic systems.</p>
+  </sec>
+</sec>
+<sec id="technical-details">
+  <title>Technical details</title>
+  <p>Typical users configure <monospace>FreqAI</monospace> via two
+  files:</p>
+  <list list-type="order">
+    <list-item>
+      <p>A <monospace>configuration</monospace> file
+      (<monospace>--config</monospace>) which provides access to the
+      full parameter list available
+      <ext-link ext-link-type="uri" xlink:href="https://www.freqtrade.io/en/latest/freqai/">here</ext-link>:</p>
+    </list-item>
+  </list>
+  <list list-type="bullet">
+    <list-item>
+      <p>control high-level feature engineering</p>
+    </list-item>
+    <list-item>
+      <p>customize adaptive modeling techniques</p>
+    </list-item>
+    <list-item>
+      <p>set any model training parameters available in third-party
+      libraries</p>
+    </list-item>
+    <list-item>
+      <p>manage adaptive modeling parameters (retrain frequency,
+      training window size, continual learning, etc.)</p>
+    </list-item>
+  </list>
+  <list list-type="order">
+    <list-item>
+      <label>2.</label>
+      <p>A strategy file (<monospace>--strategy</monospace>) where
+      users:</p>
+    </list-item>
+  </list>
+  <list list-type="bullet">
+    <list-item>
+      <p>list of the base training features</p>
+    </list-item>
+    <list-item>
+      <p>set standard technical-analysis strategies</p>
+    </list-item>
+    <list-item>
+      <p>control trade entry/exit criteria</p>
+    </list-item>
+  </list>
+  <p>With these two files, most users can exploit a wide range of
+  pre-existing integrations in <monospace>Catboost</monospace> and 7
+  other libraries with a simple command:</p>
+  <preformat>freqtrade trade --config config_freqai.example.json --strategy FreqaiExampleStrategy --freqaimodel CatboostRegressor</preformat>
+  <p>Advanced users will edit one of the existing
+  <monospace>--freqaimodel</monospace> files, which are simply an
+  children of the <monospace>IFreqaiModel</monospace> (details below).
+  Within these files, advanced users can customize training procedures,
+  prediction procedures, outlier detection methods, data preparation,
+  data saving methods, etc. This is all configured in a way where they
+  can customize as little or as much as they want. This flexible
+  customization is owed to the foundational architecture in
+  <monospace>FreqAI</monospace>, which is comprised of three distinct
+  Python objects:</p>
+  <list list-type="bullet">
+    <list-item>
+      <p><monospace>IFreqaiModel</monospace></p>
+      <list list-type="bullet">
+        <list-item>
+          <p>A singular long-lived object containing all the necessary
+          logic to collect data, store data, process data, engineer
+          features, run training, and inference models.</p>
+        </list-item>
+      </list>
+    </list-item>
+    <list-item>
+      <p><monospace>FreqaiDataKitchen</monospace></p>
+      <list list-type="bullet">
+        <list-item>
+          <p>A short-lived object which is uniquely created for each
+          asset/model. Beyond metadata, it also contains a variety of
+          data processing tools.</p>
+        </list-item>
+      </list>
+    </list-item>
+    <list-item>
+      <p><monospace>FreqaiDataDrawer</monospace></p>
+      <list list-type="bullet">
+        <list-item>
+          <p>Singular long-lived object containing all the historical
+          predictions, models, and save/load methods.</p>
+        </list-item>
+      </list>
+    </list-item>
+  </list>
+  <p>These objects interact with one another with one goal in mind - to
+  provide a clean data set to machine learning experts/enthusiasts at
+  the user endpoint. These power-users interact with an inherited
+  <monospace>IFreqaiModel</monospace> that allows them to dig as deep or
+  as shallow as they wish into the inheritence tree. Typical power-users
+  focus their efforts on customizing training procedures and testing
+  exotic functionalities available in third-party libraries. Thus,
+  power-users are freed from the algorithmic weight associated with data
+  management, and can instead focus their energy on testing creative
+  hypotheses. Meanwhile, some users choose to override deeper
+  functionalities within <monospace>IFreqaiModel</monospace> to help
+  them craft unique data structures and training procedures.</p>
+  <p>The class structure and algorithmic details are depicted in the
+  following diagram:</p>
+  <p><named-content content-type="image">image</named-content>
+  <italic>Class diagram summarizing object interactions in
+  FreqAI</italic></p>
+</sec>
+<sec id="online-documentation">
+  <title>Online documentation</title>
+  <p>The documentation for
+  <ext-link ext-link-type="uri" xlink:href="https://www.freqtrade.io/en/latest/freqai/"><monospace>FreqAI</monospace></ext-link>
+  is available online at
+  <ext-link ext-link-type="uri" xlink:href="https://www.freqtrade.io/en/latest/freqai/">https://www.freqtrade.io/en/latest/freqai/</ext-link>
+  and covers a wide range of materials:</p>
+  <list list-type="bullet">
+    <list-item>
+      <p>Quick-start with a single command and example files -
+      (beginners)</p>
+    </list-item>
+    <list-item>
+      <p>Introduction to the feature engineering interface and basic
+      configurations - (intermediate users)</p>
+    </list-item>
+    <list-item>
+      <p>Parameter table with indepth descriptions and default parameter
+      setting recommendations - (intermediate users)</p>
+    </list-item>
+    <list-item>
+      <p>Data analysis and post-processing - (advanced users)</p>
+    </list-item>
+    <list-item>
+      <p>Methodological considerations complemented by high resolution
+      figures - (advanced users)</p>
+    </list-item>
+    <list-item>
+      <p>Instructions for integrating third party machine learning
+      libraries into custom prediction models - (advanced users)</p>
+    </list-item>
+    <list-item>
+      <p>Software architectural description with class diagram -
+      (developers)</p>
+    </list-item>
+    <list-item>
+      <p>File structure descriptions - (developers)</p>
+    </list-item>
+  </list>
+  <p>The docs direct users to a variety of pre-made examples which
+  integrate <monospace>Catboost</monospace>,
+  <monospace>LightGBM</monospace>, <monospace>XGBoost</monospace>,
+  <monospace>Sklearn</monospace>,
+  <monospace>stable_baselines3</monospace>,
+  <monospace>torch</monospace>, <monospace>tensorflow</monospace>.
+  Meanwhile, developers will also find thorough docstrings and type
+  hinting throughout the source code to aid in code readability and
+  customization.</p>
+  <p><monospace>FreqAI</monospace> also benefits from a strong support
+  network of users and developers on the
+  <ext-link ext-link-type="uri" xlink:href="https://discord.gg/w6nDM6cM4y"><monospace>Freqtrade</monospace>
+  discord</ext-link> as well as on the
+  <ext-link ext-link-type="uri" xlink:href="https://discord.gg/xE4RMg4QYw"><monospace>FreqAI</monospace>
+  discord</ext-link>. Within the <monospace>FreqAI</monospace> discord,
+  users will find a deep and easily searched knowledge base containing
+  common errors. But more importantly, users in the
+  <monospace>FreqAI</monospace> discord share anectdotal and
+  quantitative observations which compare performance between various
+  third-party libraries and methods.</p>
+</sec>
+<sec id="state-of-the-field">
+  <title>State of the field</title>
+  <p>There are two other open-source tools which are geared toward
+  helping users build models for time-series forecasts on market based
+  data. However, each of these tools suffer from a non-generalized
+  frameworks that do not permit comparison of methods and libraries.
+  Additionally, they do not permit easy live-deployments or
+  adaptive-modeling methods. For example, two open-sourced projects
+  called
+  <ext-link ext-link-type="uri" xlink:href="https://tensortradex.readthedocs.io/en/latest/"><monospace>tensortrade</monospace></ext-link>
+  (<xref alt="Tensortrade, 2022" rid="ref-tensortrade" ref-type="bibr"><italic>Tensortrade</italic>,
+  2022</xref>) and
+  <ext-link ext-link-type="uri" xlink:href="https://github.com/AI4Finance-Foundation/FinRL"><monospace>FinRL</monospace></ext-link>
+  (<xref alt="AI4Finance-Foundation, 2022" rid="ref-finrl" ref-type="bibr"><italic>AI4Finance-Foundation</italic>,
+  2022</xref>) limit users to the exploration of reinforcement learning
+  on historical data. These softwares also do not provide robust live
+  deployments, they do not furnish novel feature engineering algorithms,
+  and they do not provide custom data analysis tools.
+  <monospace>FreqAI</monospace> fills the gap.</p>
+</sec>
+<sec id="on-going-research">
+  <title>On-going research</title>
+  <p>Emergent Methods, based in Arvada CO, is actively using
+  <monospace>FreqAI</monospace> to perform large scale experiments aimed
+  at comparing machine learning libraries in live and historical
+  environments. Past projects include backtesting parametric sweeps,
+  while active projects include a 3 week live deployment comparison
+  between <monospace>CatboosRegressor</monospace>,
+  <monospace>LightGBMRegressor</monospace>, and
+  <monospace>XGBoostRegressor</monospace>. Results from these studies
+  are on track for publication in scientific journals as well as more
+  general data science blogs (e.g. Medium).</p>
+</sec>
+<sec id="installing-and-running-freqai">
+  <title>Installing and running <monospace>FreqAI</monospace></title>
+  <p><monospace>FreqAI</monospace> is automatically installed with
+  <monospace>Freqtrade</monospace> using the following commands on linux
+  systems:</p>
+  <preformat>git clone git@github.com:freqtrade/freqtrade.git
+cd freqtrade
+./setup.sh -i</preformat>
+  <p>However, <monospace>FreqAI</monospace> also benefits from
+  <monospace>Freqtrade</monospace> docker distributions, and can be run
+  with docker by pulling the stable or develop images from
+  <monospace>Freqtrade</monospace> distributions.</p>
+</sec>
+<sec id="funding-sources">
+  <title>Funding sources</title>
+  <p><ext-link ext-link-type="uri" xlink:href="https://www.freqtrade.io/en/latest/freqai/"><monospace>FreqAI</monospace></ext-link>
+  has had no official sponsors, and is entirely grass roots. All
+  donations into the project (e.g. the GitHub sponsor system) are kept
+  inside the project to help support development of open-sourced and
+  communally beneficial features.</p>
+</sec>
+<sec id="acknowledgements">
+  <title>Acknowledgements</title>
+  <p>We would like to acknowledge various beta testers of
+  <monospace>FreqAI</monospace>:</p>
+  <list list-type="bullet">
+    <list-item>
+      <p>Richárd Józsa</p>
+    </list-item>
+    <list-item>
+      <p>Juha Nykänen</p>
+    </list-item>
+    <list-item>
+      <p>Salah Lamkadem</p>
+    </list-item>
+  </list>
+  <p>As well as various <monospace>Freqtrade</monospace>
+  <ext-link ext-link-type="uri" xlink:href="https://github.com/freqtrade/freqtrade/graphs/contributors">developers</ext-link>
+  maintaining tangential, yet essential, modules.</p>
+</sec>
+</body>
+<back>
+<ref-list>
+  <ref id="ref-scikit-learn">
+    <element-citation publication-type="article-journal">
+      <person-group person-group-type="author">
+        <name><surname>Pedregosa</surname><given-names>F.</given-names></name>
+        <name><surname>Varoquaux</surname><given-names>G.</given-names></name>
+        <name><surname>Gramfort</surname><given-names>A.</given-names></name>
+        <name><surname>Michel</surname><given-names>V.</given-names></name>
+        <name><surname>Thirion</surname><given-names>B.</given-names></name>
+        <name><surname>Grisel</surname><given-names>O.</given-names></name>
+        <name><surname>Blondel</surname><given-names>M.</given-names></name>
+        <name><surname>Prettenhofer</surname><given-names>P.</given-names></name>
+        <name><surname>Weiss</surname><given-names>R.</given-names></name>
+        <name><surname>Dubourg</surname><given-names>V.</given-names></name>
+        <name><surname>Vanderplas</surname><given-names>J.</given-names></name>
+        <name><surname>Passos</surname><given-names>A.</given-names></name>
+        <name><surname>Cournapeau</surname><given-names>D.</given-names></name>
+        <name><surname>Brucher</surname><given-names>M.</given-names></name>
+        <name><surname>Perrot</surname><given-names>M.</given-names></name>
+        <name><surname>Duchesnay</surname><given-names>E.</given-names></name>
+      </person-group>
+      <article-title>Scikit-learn: Machine learning in Python</article-title>
+      <source>Journal of Machine Learning Research</source>
+      <year iso-8601-date="2011">2011</year>
+      <volume>12</volume>
+      <fpage>2825</fpage>
+      <lpage>2830</lpage>
+    </element-citation>
+  </ref>
+  <ref id="ref-catboost">
+    <element-citation publication-type="paper-conference">
+      <person-group person-group-type="author">
+        <name><surname>Prokhorenkova</surname><given-names>Liudmila</given-names></name>
+        <name><surname>Gusev</surname><given-names>Gleb</given-names></name>
+        <name><surname>Vorobev</surname><given-names>Aleksandr</given-names></name>
+        <name><surname>Dorogush</surname><given-names>Anna Veronika</given-names></name>
+        <name><surname>Gulin</surname><given-names>Andrey</given-names></name>
+      </person-group>
+      <article-title>CatBoost: Unbiased boosting with categorical features</article-title>
+      <source>Proceedings of the 32nd international conference on neural information processing systems</source>
+      <publisher-name>Curran Associates Inc.</publisher-name>
+      <publisher-loc>Red Hook, NY, USA</publisher-loc>
+      <year iso-8601-date="2018">2018</year>
+      <fpage>6639</fpage>
+      <lpage>6649</lpage>
+    </element-citation>
+  </ref>
+  <ref id="ref-lightgbm">
+    <element-citation publication-type="article-journal">
+      <person-group person-group-type="author">
+        <name><surname>Ke</surname><given-names>Guolin</given-names></name>
+        <name><surname>Meng</surname><given-names>Qi</given-names></name>
+        <name><surname>Finley</surname><given-names>Thomas</given-names></name>
+        <name><surname>Wang</surname><given-names>Taifeng</given-names></name>
+        <name><surname>Chen</surname><given-names>Wei</given-names></name>
+        <name><surname>Ma</surname><given-names>Weidong</given-names></name>
+        <name><surname>Ye</surname><given-names>Qiwei</given-names></name>
+        <name><surname>Liu</surname><given-names>Tie-Yan</given-names></name>
+      </person-group>
+      <article-title>Lightgbm: A highly efficient gradient boosting decision tree</article-title>
+      <source>Advances in neural information processing systems</source>
+      <year iso-8601-date="2017">2017</year>
+      <volume>30</volume>
+      <fpage>3146</fpage>
+      <lpage>3154</lpage>
+    </element-citation>
+  </ref>
+  <ref id="ref-xgboost">
+    <element-citation publication-type="paper-conference">
+      <person-group person-group-type="author">
+        <name><surname>Chen</surname><given-names>Tianqi</given-names></name>
+        <name><surname>Guestrin</surname><given-names>Carlos</given-names></name>
+      </person-group>
+      <article-title>XGBoost: A scalable tree boosting system</article-title>
+      <source>Proceedings of the 22nd ACM SIGKDD international conference on knowledge discovery and data mining</source>
+      <publisher-name>ACM</publisher-name>
+      <publisher-loc>New York, NY, USA</publisher-loc>
+      <year iso-8601-date="2016">2016</year>
+      <isbn>978-1-4503-4232-2</isbn>
+      <uri>http://doi.acm.org/10.1145/2939672.2939785</uri>
+      <pub-id pub-id-type="doi">10.1145/2939672.2939785</pub-id>
+      <fpage>785</fpage>
+      <lpage>794</lpage>
+    </element-citation>
+  </ref>
+  <ref id="ref-stable-baselines3">
+    <element-citation publication-type="article-journal">
+      <person-group person-group-type="author">
+        <name><surname>Raffin</surname><given-names>Antonin</given-names></name>
+        <name><surname>Hill</surname><given-names>Ashley</given-names></name>
+        <name><surname>Gleave</surname><given-names>Adam</given-names></name>
+        <name><surname>Kanervisto</surname><given-names>Anssi</given-names></name>
+        <name><surname>Ernestus</surname><given-names>Maximilian</given-names></name>
+        <name><surname>Dormann</surname><given-names>Noah</given-names></name>
+      </person-group>
+      <article-title>Stable-Baselines3: Reliable reinforcement learning implementations</article-title>
+      <source>Journal of Machine Learning Research</source>
+      <year iso-8601-date="2021">2021</year>
+      <volume>22</volume>
+      <issue>268</issue>
+      <uri>http://jmlr.org/papers/v22/20-1364.html</uri>
+      <fpage>1</fpage>
+      <lpage>8</lpage>
+    </element-citation>
+  </ref>
+  <ref id="ref-openai">
+    <element-citation>
+      <person-group person-group-type="author">
+        <name><surname>Brockman</surname><given-names>Greg</given-names></name>
+        <name><surname>Cheung</surname><given-names>Vicki</given-names></name>
+        <name><surname>Pettersson</surname><given-names>Ludwig</given-names></name>
+        <name><surname>Schneider</surname><given-names>Jonas</given-names></name>
+        <name><surname>Schulman</surname><given-names>John</given-names></name>
+        <name><surname>Tang</surname><given-names>Jie</given-names></name>
+        <name><surname>Zaremba</surname><given-names>Wojciech</given-names></name>
+      </person-group>
+      <article-title>OpenAI gym</article-title>
+      <year iso-8601-date="2016">2016</year>
+      <uri>https://arxiv.org/abs/1606.01540</uri>
+    </element-citation>
+  </ref>
+  <ref id="ref-tensorflow">
+    <element-citation>
+      <person-group person-group-type="author">
+        <name><surname>Abadi</surname><given-names>Martín</given-names></name>
+        <name><surname>Agarwal</surname><given-names>Ashish</given-names></name>
+        <name><surname>Barham</surname><given-names>Paul</given-names></name>
+        <name><surname>Brevdo</surname><given-names>Eugene</given-names></name>
+        <name><surname>Chen</surname><given-names>Zhifeng</given-names></name>
+        <name><surname>Citro</surname><given-names>Craig</given-names></name>
+        <name><surname>Corrado</surname><given-names>Greg S.</given-names></name>
+        <name><surname>Davis</surname><given-names>Andy</given-names></name>
+        <name><surname>Dean</surname><given-names>Jeffrey</given-names></name>
+        <name><surname>Devin</surname><given-names>Matthieu</given-names></name>
+        <name><surname>Ghemawat</surname><given-names>Sanjay</given-names></name>
+        <name><surname>Goodfellow</surname><given-names>Ian</given-names></name>
+        <name><surname>Harp</surname><given-names>Andrew</given-names></name>
+        <name><surname>Irving</surname><given-names>Geoffrey</given-names></name>
+        <name><surname>Isard</surname><given-names>Michael</given-names></name>
+        <name><surname>Jia</surname><given-names>Yangqing</given-names></name>
+        <name><surname>Jozefowicz</surname><given-names>Rafal</given-names></name>
+        <name><surname>Kaiser</surname><given-names>Lukasz</given-names></name>
+        <name><surname>Kudlur</surname><given-names>Manjunath</given-names></name>
+        <name><surname>Levenberg</surname><given-names>Josh</given-names></name>
+        <name><surname>Mané</surname><given-names>Dandelion</given-names></name>
+        <name><surname>Monga</surname><given-names>Rajat</given-names></name>
+        <name><surname>Moore</surname><given-names>Sherry</given-names></name>
+        <name><surname>Murray</surname><given-names>Derek</given-names></name>
+        <name><surname>Olah</surname><given-names>Chris</given-names></name>
+        <name><surname>Schuster</surname><given-names>Mike</given-names></name>
+        <name><surname>Shlens</surname><given-names>Jonathon</given-names></name>
+        <name><surname>Steiner</surname><given-names>Benoit</given-names></name>
+        <name><surname>Sutskever</surname><given-names>Ilya</given-names></name>
+        <name><surname>Talwar</surname><given-names>Kunal</given-names></name>
+        <name><surname>Tucker</surname><given-names>Paul</given-names></name>
+        <name><surname>Vanhoucke</surname><given-names>Vincent</given-names></name>
+        <name><surname>Vasudevan</surname><given-names>Vijay</given-names></name>
+        <name><surname>Viégas</surname><given-names>Fernanda</given-names></name>
+        <name><surname>Vinyals</surname><given-names>Oriol</given-names></name>
+        <name><surname>Warden</surname><given-names>Pete</given-names></name>
+        <name><surname>Wattenberg</surname><given-names>Martin</given-names></name>
+        <name><surname>Wicke</surname><given-names>Martin</given-names></name>
+        <name><surname>Yu</surname><given-names>Yuan</given-names></name>
+        <name><surname>Zheng</surname><given-names>Xiaoqiang</given-names></name>
+      </person-group>
+      <article-title>TensorFlow: Large-scale machine learning on heterogeneous systems</article-title>
+      <year iso-8601-date="2015">2015</year>
+      <uri>https://www.tensorflow.org/</uri>
+    </element-citation>
+  </ref>
+  <ref id="ref-pytorch">
+    <element-citation publication-type="chapter">
+      <person-group person-group-type="author">
+        <name><surname>Paszke</surname><given-names>Adam</given-names></name>
+        <name><surname>Gross</surname><given-names>Sam</given-names></name>
+        <name><surname>Massa</surname><given-names>Francisco</given-names></name>
+        <name><surname>Lerer</surname><given-names>Adam</given-names></name>
+        <name><surname>Bradbury</surname><given-names>James</given-names></name>
+        <name><surname>Chanan</surname><given-names>Gregory</given-names></name>
+        <name><surname>Killeen</surname><given-names>Trevor</given-names></name>
+        <name><surname>Lin</surname><given-names>Zeming</given-names></name>
+        <name><surname>Gimelshein</surname><given-names>Natalia</given-names></name>
+        <name><surname>Antiga</surname><given-names>Luca</given-names></name>
+        <name><surname>Desmaison</surname><given-names>Alban</given-names></name>
+        <name><surname>Kopf</surname><given-names>Andreas</given-names></name>
+        <name><surname>Yang</surname><given-names>Edward</given-names></name>
+        <name><surname>DeVito</surname><given-names>Zachary</given-names></name>
+        <name><surname>Raison</surname><given-names>Martin</given-names></name>
+        <name><surname>Tejani</surname><given-names>Alykhan</given-names></name>
+        <name><surname>Chilamkurthy</surname><given-names>Sasank</given-names></name>
+        <name><surname>Steiner</surname><given-names>Benoit</given-names></name>
+        <name><surname>Fang</surname><given-names>Lu</given-names></name>
+        <name><surname>Bai</surname><given-names>Junjie</given-names></name>
+        <name><surname>Chintala</surname><given-names>Soumith</given-names></name>
+      </person-group>
+      <article-title>PyTorch: An imperative style, high-performance deep learning library</article-title>
+      <source>Advances in neural information processing systems 32</source>
+      <person-group person-group-type="editor">
+        <name><surname>Wallach</surname><given-names>H.</given-names></name>
+        <name><surname>Larochelle</surname><given-names>H.</given-names></name>
+        <name><surname>Beygelzimer</surname><given-names>A.</given-names></name>
+        <name><surname>dAlché-Buc</surname><given-names>F.</given-names></name>
+        <name><surname>Fox</surname><given-names>E.</given-names></name>
+        <name><surname>Garnett</surname><given-names>R.</given-names></name>
+      </person-group>
+      <publisher-name>Curran Associates, Inc.</publisher-name>
+      <year iso-8601-date="2019">2019</year>
+      <uri>http://papers.neurips.cc/paper/9015-pytorch-an-imperative-style-high-performance-deep-learning-library.pdf</uri>
+      <fpage>8024</fpage>
+      <lpage>8035</lpage>
+    </element-citation>
+  </ref>
+  <ref id="ref-scipy">
+    <element-citation publication-type="article-journal">
+      <person-group person-group-type="author">
+        <name><surname>Virtanen</surname><given-names>Pauli</given-names></name>
+        <name><surname>Gommers</surname><given-names>Ralf</given-names></name>
+        <name><surname>Oliphant</surname><given-names>Travis E.</given-names></name>
+        <name><surname>Haberland</surname><given-names>Matt</given-names></name>
+        <name><surname>Reddy</surname><given-names>Tyler</given-names></name>
+        <name><surname>Cournapeau</surname><given-names>David</given-names></name>
+        <name><surname>Burovski</surname><given-names>Evgeni</given-names></name>
+        <name><surname>Peterson</surname><given-names>Pearu</given-names></name>
+        <name><surname>Weckesser</surname><given-names>Warren</given-names></name>
+        <name><surname>Bright</surname><given-names>Jonathan</given-names></name>
+        <name><surname>van der Walt</surname><given-names>Stéfan J.</given-names></name>
+        <name><surname>Brett</surname><given-names>Matthew</given-names></name>
+        <name><surname>Wilson</surname><given-names>Joshua</given-names></name>
+        <name><surname>Millman</surname><given-names>K. Jarrod</given-names></name>
+        <name><surname>Mayorov</surname><given-names>Nikolay</given-names></name>
+        <name><surname>Nelson</surname><given-names>Andrew R. J.</given-names></name>
+        <name><surname>Jones</surname><given-names>Eric</given-names></name>
+        <name><surname>Kern</surname><given-names>Robert</given-names></name>
+        <name><surname>Larson</surname><given-names>Eric</given-names></name>
+        <name><surname>Carey</surname><given-names>C J</given-names></name>
+        <name><surname>Polat</surname><given-names>İlhan</given-names></name>
+        <name><surname>Feng</surname><given-names>Yu</given-names></name>
+        <name><surname>Moore</surname><given-names>Eric W.</given-names></name>
+        <name><surname>VanderPlas</surname><given-names>Jake</given-names></name>
+        <name><surname>Laxalde</surname><given-names>Denis</given-names></name>
+        <name><surname>Perktold</surname><given-names>Josef</given-names></name>
+        <name><surname>Cimrman</surname><given-names>Robert</given-names></name>
+        <name><surname>Henriksen</surname><given-names>Ian</given-names></name>
+        <name><surname>Quintero</surname><given-names>E. A.</given-names></name>
+        <name><surname>Harris</surname><given-names>Charles R.</given-names></name>
+        <name><surname>Archibald</surname><given-names>Anne M.</given-names></name>
+        <name><surname>Ribeiro</surname><given-names>Antônio H.</given-names></name>
+        <name><surname>Pedregosa</surname><given-names>Fabian</given-names></name>
+        <name><surname>van Mulbregt</surname><given-names>Paul</given-names></name>
+        <string-name>SciPy 1.0 Contributors</string-name>
+      </person-group>
+      <article-title>SciPy 1.0: Fundamental Algorithms for Scientific Computing in Python</article-title>
+      <source>Nature Methods</source>
+      <year iso-8601-date="2020">2020</year>
+      <volume>17</volume>
+      <pub-id pub-id-type="doi">10.1038/s41592-019-0686-2</pub-id>
+      <fpage>261</fpage>
+      <lpage>272</lpage>
+    </element-citation>
+  </ref>
+  <ref id="ref-numpy">
+    <element-citation publication-type="article-journal">
+      <person-group person-group-type="author">
+        <name><surname>Harris</surname><given-names>Charles R.</given-names></name>
+        <name><surname>Millman</surname><given-names>K. Jarrod</given-names></name>
+        <name><surname>Walt</surname><given-names>Stéfan J. van der</given-names></name>
+        <name><surname>Gommers</surname><given-names>Ralf</given-names></name>
+        <name><surname>Virtanen</surname><given-names>Pauli</given-names></name>
+        <name><surname>Cournapeau</surname><given-names>David</given-names></name>
+        <name><surname>Wieser</surname><given-names>Eric</given-names></name>
+        <name><surname>Taylor</surname><given-names>Julian</given-names></name>
+        <name><surname>Berg</surname><given-names>Sebastian</given-names></name>
+        <name><surname>Smith</surname><given-names>Nathaniel J.</given-names></name>
+        <name><surname>Kern</surname><given-names>Robert</given-names></name>
+        <name><surname>Picus</surname><given-names>Matti</given-names></name>
+        <name><surname>Hoyer</surname><given-names>Stephan</given-names></name>
+        <name><surname>Kerkwijk</surname><given-names>Marten H. van</given-names></name>
+        <name><surname>Brett</surname><given-names>Matthew</given-names></name>
+        <name><surname>Haldane</surname><given-names>Allan</given-names></name>
+        <name><surname>Río</surname><given-names>Jaime Fernández del</given-names></name>
+        <name><surname>Wiebe</surname><given-names>Mark</given-names></name>
+        <name><surname>Peterson</surname><given-names>Pearu</given-names></name>
+        <name><surname>Gérard-Marchant</surname><given-names>Pierre</given-names></name>
+        <name><surname>Sheppard</surname><given-names>Kevin</given-names></name>
+        <name><surname>Reddy</surname><given-names>Tyler</given-names></name>
+        <name><surname>Weckesser</surname><given-names>Warren</given-names></name>
+        <name><surname>Abbasi</surname><given-names>Hameer</given-names></name>
+        <name><surname>Gohlke</surname><given-names>Christoph</given-names></name>
+        <name><surname>Oliphant</surname><given-names>Travis E.</given-names></name>
+      </person-group>
+      <article-title>Array programming with NumPy</article-title>
+      <source>Nature</source>
+      <publisher-name>Springer Science; Business Media LLC</publisher-name>
+      <year iso-8601-date="2020-09">2020</year><month>09</month>
+      <volume>585</volume>
+      <issue>7825</issue>
+      <uri>https://doi.org/10.1038/s41586-020-2649-2</uri>
+      <pub-id pub-id-type="doi">10.1038/s41586-020-2649-2</pub-id>
+      <fpage>357</fpage>
+      <lpage>362</lpage>
+    </element-citation>
+  </ref>
+  <ref id="ref-pandas">
+    <element-citation publication-type="paper-conference">
+      <person-group person-group-type="author">
+        <name><surname>McKinney</surname><given-names>Wes</given-names></name>
+        <name><surname>others</surname></name>
+      </person-group>
+      <article-title>Data structures for statistical computing in python</article-title>
+      <source>Proceedings of the 9th python in science conference</source>
+      <publisher-name>Austin, TX</publisher-name>
+      <year iso-8601-date="2010">2010</year>
+      <volume>445</volume>
+      <fpage>51</fpage>
+      <lpage>56</lpage>
+    </element-citation>
+  </ref>
+  <ref id="ref-finrl">
+    <element-citation publication-type="webpage">
+      <article-title>AI4Finance-foundation</article-title>
+      <year iso-8601-date="2022">2022</year>
+      <date-in-citation content-type="access-date"><year iso-8601-date="2022-09-30">2022</year><month>09</month><day>30</day></date-in-citation>
+      <uri>https://github.com/AI4Finance-Foundation/FinRL</uri>
+    </element-citation>
+  </ref>
+  <ref id="ref-tensortrade">
+    <element-citation publication-type="webpage">
+      <article-title>Tensortrade</article-title>
+      <year iso-8601-date="2022">2022</year>
+      <date-in-citation content-type="access-date"><year iso-8601-date="2022-09-30">2022</year><month>09</month><day>30</day></date-in-citation>
+      <uri>https://tensortradex.readthedocs.io/en/latest/L</uri>
+    </element-citation>
+  </ref>
+</ref-list>
+</back>
+</article>

docs/JOSS_paper/paper.md

@@ -0,0 +1,212 @@
+---
+title: '`FreqAI`: generalizing adaptive modeling for chaotic time-series market forecasts'
+tags:
+  - Python
+  - Machine Learning
+  - adaptive modeling
+  - chaotic systems
+  - time-series forecasting
+authors:
+  - name: Robert A. Caulk
+    orcid: 0000-0001-5618-8629
+    affiliation: 1, 2 
+  - name: Elin Törnquist
+    orcid: 0000-0003-3289-8604
+    affiliation: 1, 2
+  - name: Matthias Voppichler 
+    orcid: 
+    affiliation: 2
+  - name: Andrew R. Lawless
+    orcid: 
+    affiliation: 2
+  - name: Ryan McMullan
+    orcid: 
+    affiliation: 2
+  - name: Wagner Costa Santos
+    orcid: 
+    affiliation: 1, 2
+  - name: Timothy C. Pogue
+    orcid: 
+    affiliation: 1, 2
+  - name: Johan van der Vlugt
+    orcid: 
+    affiliation: 2
+  - name: Stefan P. Gehring
+    orcid: 
+    affiliation: 2
+  - name: Pascal Schmidt
+    orcid: 0000-0001-9328-4345
+    affiliation: 2
+
+<!-- affiliation: "1, 2" # (Multiple affiliations must be quoted) -->
+affiliations:
+ - name: Emergent Methods LLC, Arvada Colorado, 80005, USA
+   index: 1
+ - name: Freqtrade open source project
+   index: 2
+date: October 2022
+bibliography: paper.bib
+
+
+---
+
+
+# Statement of need
+
+Forecasting chaotic time-series based systems, such as equity/cryptocurrency markets, requires a broad set of tools geared toward testing a wide range of hypotheses. Fortunately, a recent maturation of robust machine learning libraries (e.g. `scikit-learn`), has opened up a wide range of research possibilities. Scientists from a diverse range of fields can now easily prototype their studies on an abundance of established machine learning algorithms. Similarly, these user-friendly libraries enable "citizen scientists" to use their basic Python skills for data-exploration. However, leveraging these machine learning libraries on historical and live chaotic data sources can be logistically difficult and expensive. Additionally, robust data-collection, storage, and handling presents a disparate challenge. [`FreqAI`](https://www.freqtrade.io/en/latest/freqai/) aims to provide a generalized and extensible open-sourced framework geared toward live deployments of adaptive modeling for market forecasting. The `FreqAI` framework is effectively a sandbox for the rich world of open-source machine learning libraries. Inside the `FreqAI` sandbox, users find they can combine a wide variety of third-party libraries to test creative hypotheses on a free live 24/7 chaotic data source - cryptocurrency exchange data. 
+
+
+# Summary
+
+[`FreqAI`](https://www.freqtrade.io/en/latest/freqai/) evolved from a desire to test and compare a range of adaptive time-series forecasting methods on chaotic data. Cryptocurrency markets provide a unique data source since they are operational 24/7 and the data is freely available via a variety of open-sourced [exchange APIs](https://docs.ccxt.com/en/latest/manual.html#exchange-structure). Luckily, an existing open-source software, [`Freqtrade`](https://www.freqtrade.io/en/stable/), had already matured under a range of talented developers to support robust data collection/storage, as well as robust live environmental interactions for standard algorithmic trading. `Freqtrade` also provides a set of data analysis/visualization tools for the evaluation of historical performance as well as live environmental feedback. `FreqAI` builds on top of `Freqtrade` to include a user-friendly well tested interface for integrating external machine learning libraries for adaptive time-series forecasting. Beyond enabling the integration of existing libraries, `FreqAI` hosts a range of custom algorithms and methodologies aimed at improving computational and predictive performances. Thus, `FreqAI` contains a range of unique features which can be easily tested in combination with all the existing Python-accessible machine learning libraries to generate novel research on live and historical data. 
+
+The high-level overview of the software is depicted in Figure 1.
+
+![freqai-algo](assets/freqai_algo.jpg)
+*Abstracted overview of FreqAI algorithm*
+
+## Connecting machine learning libraries
+
+Although the `FreqAI`  framework is designed to accommodate any Python library in the "Model training" and "Feature set engineering" portions of the software (Figure 1), it already boasts a wide range of well documented examples based on various combinations of:
+
+* scikit-learn [@scikit-learn], Catboost [@catboost], LightGBM [@lightgbm], XGBoost [@xgboost], stable_baselines3 [@stable-baselines3], openai gym [@openai], tensorflow [@tensorflow], pytorch [@pytorch], Scipy [@scipy], Numpy [@numpy], and pandas [@pandas]. 
+
+These mature projects contain a wide range of peer-reviewed and industry standard methods, including:
+
+* Regression, Classification, Neural Networks, Reinforcement Learning, Support Vector Machines, Principal Component Analysis, point clustering, and much more. 
+
+which are all leveraged in `FreqAI` for users to use as templates or extend with their own methods.
+  
+## Furnishing novel methods and features
+
+Beyond the industry standard methods available through external libraries - `FreqAI` includes novel methods which are not available anywhere else in the open-source (or scientific) world. For example, `FreqAI` provides :
+
+* a custom algorithm/methodology for adaptive modeling details [here](https://www.freqtrade.io/en/stable/freqai/#general-approach) and [here](https://www.freqtrade.io/en/stable/freqai-developers/#project-architecture)
+* rapid and self-monitored feature engineering tools, details [here](https://www.freqtrade.io/en/stable/freqai-feature-engineering/#feature-engineering)
+* unique model features/indicators, such as the [inlier metric](https://www.freqtrade.io/en/stable/freqai-feature-engineering/#inlier-metric)
+* optimized data collection/storage algorithms, all code shown [here](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/freqai/data_drawer.py)
+* safely integrated outlier detection methods, details [here](https://www.freqtrade.io/en/stable/freqai-feature-engineering/#outlier-detection)
+* websocket communicated forecasts, details [here](https://www.freqtrade.io/en/stable/producer-consumer/)
+
+Of particular interest for researchers, `FreqAI` provides the option of large scale experimentation via an optimized [websocket communications interface](https://www.freqtrade.io/en/stable/producer-consumer/).
+
+## Optimizing the back-end
+
+`FreqAI` aims to make it simple for users to combine all the above tools to run studies based in two distinct modules:
+
+* backtesting studies
+* live-deployments 
+
+Both of these modules and their respective data management systems are built on top of [`Freqtrade`](https://www.freqtrade.io/en/latest/), a mature and actively developed cryptocurrency trading software. This means that `FreqAI` benefits from a wide range of tangential/disparate feature developments such as:
+
+* FreqUI, a graphical interface for backtesting and live monitoring
+* telegram control
+* robust database handling
+* futures/leverage trading
+* dollar cost averaging
+* trading strategy handling
+* a variety of free data sources via [CCXT](https://docs.ccxt.com/en/latest/manual.html#exchange-structure) (FTX, Binance, Kucoin etc.)
+
+These features derive from a strong external developer community that shares in the benefit and stability of a communal CI (Continuous Integration) system. Beyond the developer community, `FreqAI` benefits strongly from the userbase of `Freqtrade`, where most `FreqAI` beta-testers/developers originated. This symbiotic relationship between `Freqtrade` and `FreqAI` ignited a thoroughly tested [`beta`](https://github.com/freqtrade/freqtrade/pull/6832), which demanded a four month beta and [comprehensive documentation](https://www.freqtrade.io/en/latest/freqai/) containing:
+
+* numerous example scripts
+* a full parameter table
+* methodological descriptions
+* high-resolution diagrams/figures
+* detailed parameter setting recommendations
+
+## Providing a reproducible foundation for researchers
+
+`FreqAI` provides an extensible, robust, framework for researchers and citizen data scientists. The `FreqAI` sandbox enables rapid conception and testing of exotic hypotheses. From a research perspective, `FreqAI` handles the multitude of logistics associated with live deployments, historical backtesting, and feature engineering. With `FreqAI`, researchers can focus on their primary interests of feature engineering and hypothesis testing rather than figuring out how to collect and handle data. Further - the well maintained and easily installed open-source framework of `FreqAI` enables reproducible scientific studies. This reproducibility component is essential to general scientific advancement in time-series forecasting for chaotic systems. 
+
+# Technical details
+
+Typical users configure `FreqAI` via two files:
+
+1. A `configuration` file (`--config`) which provides access to the full parameter list available [here](https://www.freqtrade.io/en/latest/freqai/):
+  * control high-level feature engineering
+  * customize adaptive modeling techniques
+  * set any model training parameters available in third-party libraries
+  * manage adaptive modeling parameters (retrain frequency, training window size, continual learning, etc.)
+
+2. A strategy file (`--strategy`) where users:
+  * list of the base training features
+  * set standard technical-analysis strategies
+  * control trade entry/exit criteria
+
+With these two files, most users can exploit a wide range of pre-existing integrations in `Catboost` and 7 other libraries with a simple command:
+
+```
+freqtrade trade --config config_freqai.example.json --strategy FreqaiExampleStrategy --freqaimodel CatboostRegressor
+```
+
+Advanced users will edit one of the existing `--freqaimodel` files, which are simply an children of the `IFreqaiModel` (details below). Within these files, advanced users can customize training procedures, prediction procedures, outlier detection methods, data preparation, data saving methods, etc. This is all configured in a way where they can customize as little or as much as they want. This flexible customization is owed to the foundational architecture in `FreqAI`, which is comprised of three distinct Python objects:
+
+* `IFreqaiModel`
+  * A singular long-lived object containing all the necessary logic to collect data, store data, process data, engineer features, run training, and inference models. 
+* `FreqaiDataKitchen`
+  * A short-lived object which is uniquely created for each asset/model. Beyond metadata, it also contains a variety of data processing tools. 
+* `FreqaiDataDrawer`
+  * Singular long-lived object containing all the historical predictions, models, and save/load methods. 
+
+These objects interact with one another with one goal in mind - to provide a clean data set to machine learning experts/enthusiasts at the user endpoint. These power-users interact with an inherited `IFreqaiModel` that allows them to dig as deep or as shallow as they wish into the inheritence tree. Typical power-users focus their efforts on customizing training procedures and testing exotic functionalities available in third-party libraries. Thus, power-users are freed from the algorithmic weight associated with data management, and can instead focus their energy on testing creative hypotheses. Meanwhile, some users choose to override deeper functionalities within `IFreqaiModel` to help them craft unique data structures and training procedures.
+
+The class structure and algorithmic details are depicted in the following diagram: 
+
+![image](assets/freqai_algorithm-diagram.jpg)
+*Class diagram summarizing object interactions in FreqAI*
+
+# Online documentation
+
+The documentation for [`FreqAI`](https://www.freqtrade.io/en/latest/freqai/) is available online at [https://www.freqtrade.io/en/latest/freqai/](https://www.freqtrade.io/en/latest/freqai/) and covers a wide range of materials:
+
+* Quick-start with a single command and example files - (beginners)
+* Introduction to the feature engineering interface and basic configurations - (intermediate users)
+* Parameter table with indepth descriptions and default parameter setting recommendations - (intermediate users)
+* Data analysis and post-processing - (advanced users)
+* Methodological considerations complemented by high resolution figures - (advanced users)
+* Instructions for integrating third party machine learning libraries into custom prediction models - (advanced users)
+* Software architectural description with class diagram - (developers) 
+* File structure descriptions - (developers)
+
+The docs direct users to a variety of pre-made examples which integrate `Catboost`, `LightGBM`, `XGBoost`, `Sklearn`, `stable_baselines3`, `torch`, `tensorflow`. Meanwhile, developers will also find thorough docstrings and type hinting throughout the source code to aid in code readability and customization. 
+
+`FreqAI` also benefits from a strong support network of users and developers on the [`Freqtrade` discord](https://discord.gg/w6nDM6cM4y) as well as on the [`FreqAI` discord](https://discord.gg/xE4RMg4QYw). Within the `FreqAI` discord, users will find a deep and easily searched knowledge base containing common errors. But more importantly, users in the `FreqAI` discord share anectdotal and quantitative observations which compare performance between various third-party libraries and methods.
+
+# State of the field
+
+There are two other open-source tools which are geared toward helping users build models for time-series forecasts on market based data. However, each of these tools suffer from a non-generalized frameworks that do not permit comparison of methods and libraries. Additionally, they do not permit easy live-deployments or adaptive-modeling methods. For example, two open-sourced projects called [`tensortrade`](https://tensortradex.readthedocs.io/en/latest/) [@tensortrade] and [`FinRL`](https://github.com/AI4Finance-Foundation/FinRL) [@finrl] limit users to the exploration of reinforcement learning on historical data. These softwares also do not provide robust live deployments, they do not furnish novel feature engineering algorithms, and they do not provide custom data analysis tools. `FreqAI` fills the gap. 
+
+# On-going research
+
+Emergent Methods, based in Arvada CO, is actively using `FreqAI` to perform large scale experiments aimed at comparing machine learning libraries in live and historical environments. Past projects include backtesting parametric sweeps, while active projects include a 3 week live deployment comparison between `CatboostRegressor`, `LightGBMRegressor`, and `XGBoostRegressor`. Results from these studies are planned for submission to scientific journals as well as more general data science blogs (e.g. Medium).
+
+# Installing and running `FreqAI`
+
+`FreqAI` is automatically installed with `Freqtrade` using the following commands on linux systems:
+
+```
+git clone git@github.com:freqtrade/freqtrade.git
+cd freqtrade
+./setup.sh -i
+```
+
+However, `FreqAI` also benefits from `Freqtrade` docker distributions, and can be run with docker by pulling the stable or develop images from `Freqtrade` distributions.
+
+# Funding sources
+
+[`FreqAI`](https://www.freqtrade.io/en/latest/freqai/) has had no official sponsors, and is entirely grass roots. All donations into the project (e.g. the GitHub sponsor system) are kept inside the project to help support development of open-sourced and communally beneficial features. 
+
+# Acknowledgements
+
+We would like to acknowledge various beta testers of `FreqAI`:
+
+- Longlong Yu (lolongcovas)
+- Richárd Józsa (richardjozsa)
+- Juha Nykänen (suikula)
+- Emre Suzen (aemr3)
+- Salah Lamkadem (ikonx)
+
+As well as various `Freqtrade` [developers](https://github.com/freqtrade/freqtrade/graphs/contributors) maintaining tangential, yet essential, modules.
+
+# References

docs/advanced-backtesting.md

@@ -32,7 +32,7 @@ To analyze the entry/exit tags, we now need to use the `freqtrade backtesting-an
 with `--analysis-groups` option provided with space-separated arguments (default `0 1 2`):
 
 ``` bash
-freqtrade backtesting-analysis -c <config.json> --analysis-groups 0 1 2 3 4 5
+freqtrade backtesting-analysis -c <config.json> --analysis-groups 0 1 2 3 4
 ```
 
 This command will read from the last backtesting results. The `--analysis-groups` option is
@@ -43,7 +43,6 @@ ranging from the simplest (0) to the most detailed per pair, per buy and per sel
 * 2: profit summaries grouped by enter_tag and exit_tag
 * 3: profit summaries grouped by pair and enter_tag
 * 4: profit summaries grouped by pair, enter_ and exit_tag (this can get quite large)
-* 5: profit summaries grouped by exit_tag
 
 More options are available by running with the `-h` option.
 
@@ -101,17 +100,3 @@ freqtrade backtesting-analysis -c <config.json> --analysis-groups 0 2 --enter-re
 The indicators have to be present in your strategy's main DataFrame (either for your main
 timeframe or for informative timeframes) otherwise they will simply be ignored in the script
 output.
-
-### Filtering the trade output by date
-
-To show only trades between dates within your backtested timerange, supply the usual `timerange` option in `YYYYMMDD-[YYYYMMDD]` format:
-
-```
---timerange : Timerange to filter output trades, start date inclusive, end date exclusive. e.g. 20220101-20221231
-```
-
-For example, if your backtest timerange was `20220101-20221231` but you only want to output trades in January:
-
-```bash
-freqtrade backtesting-analysis -c <config.json> --timerange 20220101-20220201
-```

docs/advanced-hyperopt.md

@@ -75,11 +75,9 @@ This function needs to return a floating point number (`float`). Smaller numbers
 
 ## Overriding pre-defined spaces
 
-To override a pre-defined space (`roi_space`, `generate_roi_table`, `stoploss_space`, `trailing_space`, `max_open_trades_space`), define a nested class called Hyperopt and define the required spaces as follows:
+To override a pre-defined space (`roi_space`, `generate_roi_table`, `stoploss_space`, `trailing_space`), define a nested class called Hyperopt and define the required spaces as follows:
 
 ```python
-from freqtrade.optimize.space import Categorical, Dimension, Integer, SKDecimal
-
 class MyAwesomeStrategy(IStrategy):
     class HyperOpt:
         # Define a custom stoploss space.
@@ -96,39 +94,6 @@ class MyAwesomeStrategy(IStrategy):
                 SKDecimal(0.01, 0.07, decimals=3, name='roi_p2'),
                 SKDecimal(0.01, 0.20, decimals=3, name='roi_p3'),
             ]
-
-        def generate_roi_table(params: Dict) -> Dict[int, float]:
-
-            roi_table = {}
-            roi_table[0] = params['roi_p1'] + params['roi_p2'] + params['roi_p3']
-            roi_table[params['roi_t3']] = params['roi_p1'] + params['roi_p2']
-            roi_table[params['roi_t3'] + params['roi_t2']] = params['roi_p1']
-            roi_table[params['roi_t3'] + params['roi_t2'] + params['roi_t1']] = 0
-
-            return roi_table
-
-        def trailing_space() -> List[Dimension]:
-            # All parameters here are mandatory, you can only modify their type or the range.
-            return [
-                # Fixed to true, if optimizing trailing_stop we assume to use trailing stop at all times.
-                Categorical([True], name='trailing_stop'),
-
-                SKDecimal(0.01, 0.35, decimals=3, name='trailing_stop_positive'),
-                # 'trailing_stop_positive_offset' should be greater than 'trailing_stop_positive',
-                # so this intermediate parameter is used as the value of the difference between
-                # them. The value of the 'trailing_stop_positive_offset' is constructed in the
-                # generate_trailing_params() method.
-                # This is similar to the hyperspace dimensions used for constructing the ROI tables.
-                SKDecimal(0.001, 0.1, decimals=3, name='trailing_stop_positive_offset_p1'),
-
-                Categorical([True, False], name='trailing_only_offset_is_reached'),
-        ]
-
-        # Define a custom max_open_trades space
-        def max_open_trades_space(self) -> List[Dimension]:
-            return [
-                Integer(-1, 10, name='max_open_trades'),
-            ]
 ```
 
 !!! Note

docs/advanced-setup.md

@@ -192,7 +192,7 @@ $RepeatedMsgReduction on
 
 ### Logging to journald
 
-This needs the `cysystemd` python package installed as dependency (`pip install cysystemd`), which is not available on Windows. Hence, the whole journald logging functionality is not available for a bot running on Windows.
+This needs the `systemd` python package installed as the dependency, which is not available on Windows. Hence, the whole journald logging functionality is not available for a bot running on Windows.
 
 To send Freqtrade log messages to `journald` system service use the `--logfile` command line option with the value in the following format:
 

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 ======================================================
+========================================================= EXIT REASON STATS ==========================================================
-| 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        |   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               |
 |-----------------------------+---------------------|
@@ -301,11 +300,7 @@ A backtesting result will look like that:
 | Absolute profit             | 0.00762792 BTC      |
 | Total profit %              | 76.2%               |
 | CAGR %                      | 460.87%             |
-| Sortino                     | 1.88                |
-| Sharpe                      | 2.97                |
-| Calmar                      | 6.29                |
 | Profit factor               | 1.11                |
-| Expectancy                  | -0.15               |
 | Avg. stake amount           | 0.001      BTC      |
 | Total trade volume          | 0.429      BTC      |
 |                             |                     |
@@ -405,11 +400,7 @@ It contains some useful key metrics about performance of your strategy on backte
 | Absolute profit             | 0.00762792 BTC      |
 | Total profit %              | 76.2%               |
 | CAGR %                      | 460.87%             |
-| Sortino                     | 1.88                |
-| Sharpe                      | 2.97                |
-| Calmar                      | 6.29                |
 | Profit factor               | 1.11                |
-| Expectancy                  | -0.15               |
 | Avg. stake amount           | 0.001      BTC      |
 | Total trade volume          | 0.429      BTC      |
 |                             |                     |
@@ -456,9 +447,6 @@ It contains some useful key metrics about performance of your strategy on backte
 - `Absolute profit`: Profit made in stake currency.
 - `Total profit %`: Total profit. Aligned to the `TOTAL` row's `Tot Profit %` from the first table. Calculated as `(End capital − Starting capital) / Starting capital`.
 - `CAGR %`: Compound annual growth rate.
-- `Sortino`: Annualized Sortino ratio.
-- `Sharpe`: Annualized Sharpe ratio.
-- `Calmar`: Annualized Calmar ratio.
 - `Profit factor`: profit / loss.
 - `Avg. stake amount`: Average stake amount, either `stake_amount` or the average when using dynamic stake amount.
 - `Total trade volume`: Volume generated on the exchange to reach the above profit.
@@ -534,13 +522,13 @@ Since backtesting lacks some detailed information about what happens within a ca
 - ROI
   - exits are compared to high - but the ROI value is used (e.g. ROI = 2%, high=5% - so the exit will be at 2%)
   - exits are never "below the candle", so a ROI of 2% may result in a exit at 2.4% if low was at 2.4% profit
-  - Force-exits caused by `<N>=-1` ROI entries use low as exit value, unless N falls on the candle open (e.g. `120: -1` for 1h candles)
+  - Forceexits caused by `<N>=-1` ROI entries use low as exit value, unless N falls on the candle open (e.g. `120: -1` for 1h candles)
 - Stoploss exits happen exactly at stoploss price, even if low was lower, but the loss will be `2 * fees` higher than the stoploss price
 - Stoploss is evaluated before ROI within one candle. So you can often see more trades with the `stoploss` exit reason comparing to the results obtained with the same strategy in the Dry Run/Live Trade modes
 - Low happens before high for stoploss, protecting capital first
 - Trailing stoploss
   - Trailing Stoploss is only adjusted if it's below the candle's low (otherwise it would be triggered)
-  - On trade entry candles that trigger trailing stoploss, the "minimum offset" (`stop_positive_offset`) is assumed (instead of high) - and the stop is calculated from this point. This rule is NOT applicable to custom-stoploss scenarios, since there's no information about the stoploss logic available.
+  - On trade entry candles that trigger trailing stoploss, the "minimum offset" (`stop_positive_offset`) is assumed (instead of high) - and the stop is calculated from this point
   - High happens first - adjusting stoploss
   - Low uses the adjusted stoploss (so exits with large high-low difference are backtested correctly)
   - ROI applies before trailing-stop, ensuring profits are "top-capped" at ROI if both ROI and trailing stop applies
@@ -558,8 +546,8 @@ In addition to the above assumptions, strategy authors should carefully read the
 
 ### Trading limits in backtesting
 
-Exchanges have certain trading limits, like minimum (and maximum) base currency, or minimum/maximum stake (quote) currency.
+Exchanges have certain trading limits, like minimum base currency, or minimum stake (quote) currency.
-These limits are usually listed in the exchange documentation as "trading rules" or similar and can be quite different between different pairs.
+These limits are usually listed in the exchange documentation as "trading rules" or similar.
 
 Backtesting (as well as live and dry-run) does honor these limits, and will ensure that a stoploss can be placed below this value - so the value will be slightly higher than what the exchange specifies.
 Freqtrade has however no information about historic limits.
@@ -595,8 +583,7 @@ To utilize this, you can append `--timeframe-detail 5m` to your regular backtest
 freqtrade backtesting --strategy AwesomeStrategy --timeframe 1h --timeframe-detail 5m
 ```
 
-This will load 1h data as well as 5m data for the timeframe. The strategy will be analyzed with the 1h timeframe, and Entry orders will only be placed at the main timeframe, however Order fills and exit signals will be evaluated at the 5m candle, simulating intra-candle movements.
+This will load 1h data as well as 5m data for the timeframe. The strategy will be analyzed with the 1h timeframe - and for every "open trade candle" (candles where a trade is open) the 5m data will be used to simulate intra-candle movements.
-
 All callback functions (`custom_exit()`, `custom_stoploss()`, ... ) will be running for each 5m candle once the trade is opened (so 12 times in the above example of 1h timeframe, and 5m detailed timeframe).
 
 `--timeframe-detail` must be smaller than the original timeframe, otherwise backtesting will fail to start.

docs/bot-basics.md

@@ -12,9 +12,6 @@ This page provides you some basic concepts on how Freqtrade works and operates.
 * **Indicators**: Technical indicators (SMA, EMA, RSI, ...).
 * **Limit order**: Limit orders which execute at the defined limit price or better.
 * **Market order**: Guaranteed to fill, may move price depending on the order size.
-* **Current Profit**: Currently pending (unrealized) profit for this trade. This is mainly used throughout the bot and UI.
-* **Realized Profit**: Already realized profit. Only relevant in combination with [partial exits](strategy-callbacks.md#adjust-trade-position) - which also explains the calculation logic for this.
-* **Total Profit**: Combined realized and unrealized profit. The relative number (%) is calculated against the total investment in this trade.
 
 ## Fee handling
 
@@ -60,10 +57,10 @@ This loop will be repeated again and again until the bot is stopped.
 
 * Load historic data for configured pairlist.
 * Calls `bot_start()` once.
+* Calls `bot_loop_start()` once.
 * Calculate indicators (calls `populate_indicators()` once per pair).
 * Calculate entry / exit signals (calls `populate_entry_trend()` and `populate_exit_trend()` once per pair).
 * Loops per candle simulating entry and exit points.
-  * Calls `bot_loop_start()` strategy callback.
   * Check for Order timeouts, either via the `unfilledtimeout` configuration, or via `check_entry_timeout()` / `check_exit_timeout()` strategy callbacks.
   * Calls `adjust_entry_price()` strategy callback for open entry orders.
   * Check for trade entry signals (`enter_long` / `enter_short` columns).
@@ -78,7 +75,3 @@ This loop will be repeated again and again until the bot is stopped.
 
 !!! Note
     Both Backtesting and Hyperopt include exchange default Fees in the calculation. Custom fees can be passed to backtesting / hyperopt by specifying the `--fee` argument.
-
-!!! Warning "Callback call frequency"
-    Backtesting will call each callback at max. once per candle (`--timeframe-detail` modifies this behavior to once per detailed candle).
-    Most callbacks will be called once per iteration in live (usually every ~5s) - which can cause backtesting mismatches.

docs/configuration.md

@@ -11,7 +11,7 @@ Per default, the bot loads the configuration from the `config.json` file, locate
 
 You can specify a different configuration file used by the bot with the `-c/--config` command-line option.
 
-If you used the [Quick start](docker_quickstart.md#docker-quick-start) method for installing
+If you used the [Quick start](installation.md/#quick-start) method for installing
 the bot, the installation script should have already created the default configuration file (`config.json`) for you.
 
 If the default configuration file is not created we recommend to use `freqtrade new-config --config config.json` to generate a basic configuration file.
@@ -134,7 +134,7 @@ Mandatory parameters are marked as **Required**, which means that they are requi
 
 |  Parameter | Description |
 |------------|-------------|
-| `max_open_trades` | **Required.** Number of open trades your bot is allowed to have. Only one open trade per pair is possible, so the length of your pairlist is another limitation that can apply. If -1 then it is ignored (i.e. potentially unlimited open trades, limited by the pairlist). [More information below](#configuring-amount-per-trade). [Strategy Override](#parameters-in-the-strategy).<br> **Datatype:** Positive integer or -1.
+| `max_open_trades` | **Required.** Number of open trades your bot is allowed to have. Only one open trade per pair is possible, so the length of your pairlist is another limitation that can apply. If -1 then it is ignored (i.e. potentially unlimited open trades, limited by the pairlist). [More information below](#configuring-amount-per-trade).<br> **Datatype:** Positive integer or -1.
 | `stake_currency` | **Required.** Crypto-currency used for trading. <br> **Datatype:** String
 | `stake_amount` | **Required.** Amount of crypto-currency your bot will use for each trade. Set it to `"unlimited"` to allow the bot to use all available balance. [More information below](#configuring-amount-per-trade). <br> **Datatype:** Positive float or `"unlimited"`.
 | `tradable_balance_ratio` | Ratio of the total account balance the bot is allowed to trade. [More information below](#configuring-amount-per-trade). <br>*Defaults to `0.99` 99%).*<br> **Datatype:** Positive float between `0.1` and `1.0`.
@@ -215,18 +215,16 @@ Mandatory parameters are marked as **Required**, which means that they are requi
 | `telegram.balance_dust_level` | Dust-level (in stake currency) - currencies with a balance below this will not be shown by `/balance`. <br> **Datatype:** float
 | `telegram.reload` | Allow "reload" buttons on telegram messages. <br>*Defaults to `True`.<br> **Datatype:** boolean
 | `telegram.notification_settings.*` | Detailed notification settings. Refer to the [telegram documentation](telegram-usage.md) for details.<br> **Datatype:** dictionary
-| `telegram.allow_custom_messages` | Enable the sending of Telegram messages from strategies via the dataprovider.send_msg() function. <br> **Datatype:** Boolean
 | | **Webhook**
 | `webhook.enabled` | Enable usage of Webhook notifications <br> **Datatype:** Boolean
 | `webhook.url` | URL for the webhook. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.entry` | Payload to send on entry. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
+| `webhook.webhookentry` | Payload to send on entry. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.entry_cancel` | Payload to send on entry order cancel. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
+| `webhook.webhookentrycancel` | Payload to send on entry order cancel. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.entry_fill` | Payload to send on entry order filled. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
+| `webhook.webhookentryfill` | Payload to send on entry order filled. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.exit` | Payload to send on exit. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
+| `webhook.webhookexit` | Payload to send on exit. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.exit_cancel` | Payload to send on exit order cancel. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
+| `webhook.webhookexitcancel` | Payload to send on exit order cancel. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.exit_fill` | Payload to send on exit order filled. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
+| `webhook.webhookexitfill` | Payload to send on exit order filled. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.status` | Payload to send on status calls. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
+| `webhook.webhookstatus` | Payload to send on status calls. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details. <br> **Datatype:** String
-| `webhook.allow_custom_messages` | Enable the sending of Webhook messages from strategies via the dataprovider.send_msg() function. <br> **Datatype:** Boolean
 | | **Rest API / FreqUI / Producer-Consumer**
 | `api_server.enabled` | Enable usage of API Server. See the [API Server documentation](rest-api.md) for more details. <br> **Datatype:** Boolean
 | `api_server.listen_ip_address` | Bind IP address. See the [API Server documentation](rest-api.md) for more details. <br> **Datatype:** IPv4
@@ -253,7 +251,6 @@ Mandatory parameters are marked as **Required**, which means that they are requi
 | `add_config_files` | Additional config files. These files will be loaded and merged with the current config file. The files are resolved relative to the initial file.<br> *Defaults to `[]`*. <br> **Datatype:** List of strings
 | `dataformat_ohlcv` | Data format to use to store historical candle (OHLCV) data. <br> *Defaults to `json`*. <br> **Datatype:** String
 | `dataformat_trades` | Data format to use to store historical trades data. <br> *Defaults to `jsongz`*. <br> **Datatype:** String
-| `reduce_df_footprint` | Recast all numeric columns to float32/int32, with the objective of reducing ram/disk usage (and decreasing train/inference timing in FreqAI). (Currently only affects FreqAI use-cases) <br> **Datatype:** Boolean. <br> Default: `False`.
 
 ### Parameters in the strategy
 
@@ -263,7 +260,6 @@ Values set in the configuration file always overwrite values set in the strategy
 * `minimal_roi`
 * `timeframe`
 * `stoploss`
-* `max_open_trades`
 * `trailing_stop`
 * `trailing_stop_positive`
 * `trailing_stop_positive_offset`
@@ -554,7 +550,7 @@ The possible values are: `GTC` (default), `FOK` or `IOC`.
 ```
 
 !!! Warning
-    This is ongoing work. For now, it is supported only for binance, gate and kucoin.
+    This is ongoing work. For now, it is supported only for binance, gate, ftx and kucoin.
     Please don't change the default value unless you know what you are doing and have researched the impact of using different values for your particular exchange.
 
 ### What values can be used for fiat_display_currency?
@@ -666,7 +662,6 @@ You should also make sure to read the [Exchanges](exchanges.md) section of the d
 ### Using proxy with Freqtrade
 
 To use a proxy with freqtrade, export your proxy settings using the variables `"HTTP_PROXY"` and `"HTTPS_PROXY"` set to the appropriate values.
-This will have the proxy settings applied to everything (telegram, coingecko, ...) **except** for exchange requests.
 
 ``` bash
 export HTTP_PROXY="http://addr:port"
@@ -674,21 +669,17 @@ export HTTPS_PROXY="http://addr:port"
 freqtrade
 ```
 
-#### Proxy exchange requests
+#### Proxy just exchange requests
 
-To use a proxy for exchange connections - you will have to define the proxies as part of the ccxt configuration.
+To use a proxy just for exchange connections (skips/ignores telegram and coingecko) - you can also define the proxies as part of the ccxt configuration.
 
 ``` json
-{ 
+"ccxt_config": {
-  "exchange": {
+    "aiohttp_proxy": "http://addr:port",
-    "ccxt_config": {
+    "proxies": {
-      "aiohttp_proxy": "http://addr:port",
-      "proxies": {
         "http": "http://addr:port",
         "https": "http://addr:port"
-      },
+    },
-    }
-  }
 }
 ```
 

docs/data-analysis.md

@@ -5,7 +5,7 @@ You can analyze the results of backtests and trading history easily using Jupyte
 ## Quick start with docker
 
 Freqtrade provides a docker-compose file which starts up a jupyter lab server.
-You can run this server using the following command: `docker compose -f docker/docker-compose-jupyter.yml up`
+You can run this server using the following command: `docker-compose -f docker/docker-compose-jupyter.yml up`
 
 This will create a dockercontainer running jupyter lab, which will be accessible using `https://127.0.0.1:8888/lab`.
 Please use the link that's printed in the console after startup for simplified login.
@@ -83,7 +83,7 @@ from pathlib import Path
 project_root = "somedir/freqtrade"
 i=0
 try:
-    os.chdir(project_root)
+    os.chdirdir(project_root)
     assert Path('LICENSE').is_file()
 except:
     while i<4 and (not Path('LICENSE').is_file()):

docs/data-download.md

@@ -177,13 +177,13 @@ freqtrade download-data --exchange binance --pairs ETH/USDT XRP/USDT BTC/USDT --
 
 ### Data format
 
-Freqtrade currently supports the following data-formats:
+Freqtrade currently supports 3 data-formats for both OHLCV and trades data:
 
 * `json` -  plain "text" json files
 * `jsongz` - a gzip-zipped version of json files
 * `hdf5` - a high performance datastore
-* `feather` - a dataformat based on Apache Arrow (OHLCV only)
+* `feather` - a dataformat based on Apache Arrow
-* `parquet` - columnar datastore (OHLCV only)
+* `parquet` - columnar datastore
 
 By default, OHLCV data is stored as `json` data, while trades data is stored as `jsongz` data.
 

docs/deprecated.md

@@ -66,16 +66,11 @@ We will keep a compatibility layer for 1-2 versions (so both `buy_tag` and `ente
 
 #### Naming changes
 
-Webhook terminology changed from "sell" to "exit", and from "buy" to "entry", removing "webhook" in the process.
+Webhook terminology changed from "sell" to "exit", and from "buy" to "entry".
 
-* `webhookbuy`, `webhookentry` -> `entry`
+* `webhookbuy` -> `webhookentry`
-* `webhookbuyfill`, `webhookentryfill` -> `entry_fill`
+* `webhookbuyfill` -> `webhookentryfill`
-* `webhookbuycancel`, `webhookentrycancel` -> `entry_cancel`
+* `webhookbuycancel` -> `webhookentrycancel`
-* `webhooksell`, `webhookexit` -> `exit`
+* `webhooksell` -> `webhookexit`
-* `webhooksellfill`, `webhookexitfill` -> `exit_fill`
+* `webhooksellfill` -> `webhookexitfill`
-* `webhooksellcancel`, `webhookexitcancel` -> `exit_cancel`
+* `webhooksellcancel` -> `webhookexitcancel`
-
-
-## Removal of `populate_any_indicators`
-
-version 2023.3 saw the removal of `populate_any_indicators` in favor of split methods for feature engineering and targets. Please read the [migration document](strategy_migration.md#freqai-strategy) for full details.

docs/developer.md

@@ -24,7 +24,7 @@ This will spin up a local server (usually on port 8000) so you can see if everyt
 To configure a development environment, you can either use the provided [DevContainer](#devcontainer-setup), or use the `setup.sh` script and answer "y" when asked "Do you want to install dependencies for dev [y/N]? ".
 Alternatively (e.g. if your system is not supported by the setup.sh script), follow the manual installation process and run `pip3 install -e .[all]`.
 
-This will install all required tools for development, including `pytest`, `ruff`, `mypy`, and `coveralls`.
+This will install all required tools for development, including `pytest`, `flake8`, `mypy`, and `coveralls`.
 
 Then install the git hook scripts by running `pre-commit install`, so your changes will be verified locally before committing.
 This avoids a lot of waiting for CI already, as some basic formatting checks are done locally on your machine.
@@ -49,13 +49,6 @@ For more information about the [Remote container extension](https://code.visuals
 New code should be covered by basic unittests. Depending on the complexity of the feature, Reviewers may request more in-depth unittests.
 If necessary, the Freqtrade team can assist and give guidance with writing good tests (however please don't expect anyone to write the tests for you).
 
-#### How to run tests
-
-Use `pytest` in root folder to run all available testcases and confirm your local environment is setup correctly
-
-!!! Note "feature branches"
-    Tests are expected to pass on the `develop` and `stable` branches. Other branches may be work in progress with tests not working yet.
-
 #### Checking log content in tests
 
 Freqtrade uses 2 main methods to check log content in tests, `log_has()` and `log_has_re()` (to check using regex, in case of dynamic log-messages).
@@ -363,7 +356,7 @@ from pathlib import Path
 exchange = ccxt.binance({
     'apiKey': '<apikey>',
     'secret': '<secret>'
-    'options': {'defaultType': 'swap'}
+    'options': {'defaultType': 'future'}
     })
 _ = exchange.load_markets()
 
@@ -441,11 +434,6 @@ To keep the release-log short, best wrap the full git changelog into a collapsib
 </details>
 ```
 
-### FreqUI release
-
-If FreqUI has been updated substantially, make sure to create a release before merging the release branch.
-Make sure that freqUI CI on the release is finished and passed before merging the release.
-
 ### Create github release / tag
 
 Once the PR against stable is merged (best right after merging):

docs/docker_quickstart.md

@@ -4,22 +4,20 @@ This page explains how to run the bot with Docker. It is not meant to work out o
 
 ## Install Docker
 
-Start by downloading and installing Docker / Docker Desktop for your platform:
+Start by downloading and installing Docker CE for your platform:
 
 * [Mac](https://docs.docker.com/docker-for-mac/install/)
 * [Windows](https://docs.docker.com/docker-for-windows/install/)
 * [Linux](https://docs.docker.com/install/)
 
-!!! Info "Docker compose install"
+To simplify running freqtrade, [`docker-compose`](https://docs.docker.com/compose/install/) should be installed and available to follow the below [docker quick start guide](#docker-quick-start).
-    Freqtrade documentation assumes the use of Docker desktop (or the docker compose plugin).  
-    While the docker-compose standalone installation still works, it will require changing all `docker compose` commands from `docker compose` to `docker-compose` to work (e.g. `docker compose up -d` will become `docker-compose up -d`).
 
-## Freqtrade with docker
+## Freqtrade with docker-compose
 
-Freqtrade provides an official Docker image on [Dockerhub](https://hub.docker.com/r/freqtradeorg/freqtrade/), as well as a [docker compose file](https://github.com/freqtrade/freqtrade/blob/stable/docker-compose.yml) ready for usage.
+Freqtrade provides an official Docker image on [Dockerhub](https://hub.docker.com/r/freqtradeorg/freqtrade/), as well as a [docker-compose file](https://github.com/freqtrade/freqtrade/blob/stable/docker-compose.yml) ready for usage.
 
 !!! Note
-    - The following section assumes that `docker` is installed and available to the logged in user.
+    - The following section assumes that `docker` and `docker-compose` are installed and available to the logged in user.
     - All below commands use relative directories and will have to be executed from the directory containing the `docker-compose.yml` file.
 
 ### Docker quick start
@@ -33,13 +31,13 @@ cd ft_userdata/
 curl https://raw.githubusercontent.com/freqtrade/freqtrade/stable/docker-compose.yml -o docker-compose.yml
 
 # Pull the freqtrade image
-docker compose pull
+docker-compose pull
 
 # Create user directory structure
-docker compose run --rm freqtrade create-userdir --userdir user_data
+docker-compose run --rm freqtrade create-userdir --userdir user_data
 
 # Create configuration - Requires answering interactive questions
-docker compose run --rm freqtrade new-config --config user_data/config.json
+docker-compose run --rm freqtrade new-config --config user_data/config.json
 ```
 
 The above snippet creates a new directory called `ft_userdata`, downloads the latest compose file and pulls the freqtrade image.
@@ -66,7 +64,7 @@ The `SampleStrategy` is run by default.
 Once this is done, you're ready to launch the bot in trading mode (Dry-run or Live-trading, depending on your answer to the corresponding question you made above).
 
 ``` bash
-docker compose up -d
+docker-compose up -d
 ```
 
 !!! Warning "Default configuration"
@@ -86,27 +84,27 @@ You can now access the UI by typing localhost:8080 in your browser.
 
 #### Monitoring the bot
 
-You can check for running instances with `docker compose ps`.
+You can check for running instances with `docker-compose ps`.
 This should list the service `freqtrade` as `running`. If that's not the case, best check the logs (see next point).
 
-#### Docker compose logs
+#### Docker-compose logs
 
 Logs will be written to: `user_data/logs/freqtrade.log`.  
-You can also check the latest log with the command `docker compose logs -f`.
+You can also check the latest log with the command `docker-compose logs -f`.
 
 #### Database
 
 The database will be located at: `user_data/tradesv3.sqlite`
 
-#### Updating freqtrade with docker
+#### Updating freqtrade with docker-compose
 
-Updating freqtrade when using `docker` is as simple as running the following 2 commands:
+Updating freqtrade when using `docker-compose` is as simple as running the following 2 commands:
 
 ``` bash
 # Download the latest image
-docker compose pull
+docker-compose pull
 # Restart the image
-docker compose up -d
+docker-compose up -d
 ```
 
 This will first pull the latest image, and will then restart the container with the just pulled version.
@@ -118,43 +116,43 @@ This will first pull the latest image, and will then restart the container with
 
 Advanced users may edit the docker-compose file further to include all possible options or arguments.
 
-All freqtrade arguments will be available by running `docker compose run --rm freqtrade <command> <optional arguments>`.
+All freqtrade arguments will be available by running `docker-compose run --rm freqtrade <command> <optional arguments>`.
 
-!!! Warning "`docker compose` for trade commands"
+!!! Warning "`docker-compose` for trade commands"
-    Trade commands (`freqtrade trade <...>`) should not be ran via `docker compose run` - but should use `docker compose up -d` instead.
+    Trade commands (`freqtrade trade <...>`) should not be ran via `docker-compose run` - but should use `docker-compose up -d` instead.
     This makes sure that the container is properly started (including port forwardings) and will make sure that the container will restart after a system reboot.
     If you intend to use freqUI, please also ensure to adjust the [configuration accordingly](rest-api.md#configuration-with-docker), otherwise the UI will not be available.
 
-!!! Note "`docker compose run --rm`"
+!!! Note "`docker-compose run --rm`"
     Including `--rm` will remove the container after completion, and is highly recommended for all modes except trading mode (running with `freqtrade trade` command).
 
-??? Note "Using docker without docker"
+??? Note "Using docker without docker-compose"
-    "`docker compose run --rm`" will require a compose file to be provided.
+    "`docker-compose run --rm`" will require a compose file to be provided.
     Some freqtrade commands that don't require authentication such as `list-pairs` can be run with "`docker run --rm`" instead.  
     For example `docker run --rm freqtradeorg/freqtrade:stable list-pairs --exchange binance --quote BTC --print-json`.  
     This can be useful for fetching exchange information to add to your `config.json` without affecting your running containers.
 
-#### Example: Download data with docker
+#### Example: Download data with docker-compose
 
 Download backtesting data for 5 days for the pair ETH/BTC and 1h timeframe from Binance. The data will be stored in the directory `user_data/data/` on the host.
 
 ``` bash
-docker compose run --rm freqtrade download-data --pairs ETH/BTC --exchange binance --days 5 -t 1h
+docker-compose run --rm freqtrade download-data --pairs ETH/BTC --exchange binance --days 5 -t 1h
 ```
 
 Head over to the [Data Downloading Documentation](data-download.md) for more details on downloading data.
 
-#### Example: Backtest with docker
+#### Example: Backtest with docker-compose
 
 Run backtesting in docker-containers for SampleStrategy and specified timerange of historical data, on 5m timeframe:
 
 ``` bash
-docker compose run --rm freqtrade backtesting --config user_data/config.json --strategy SampleStrategy --timerange 20190801-20191001 -i 5m
+docker-compose run --rm freqtrade backtesting --config user_data/config.json --strategy SampleStrategy --timerange 20190801-20191001 -i 5m
 ```
 
 Head over to the [Backtesting Documentation](backtesting.md) to learn more.
 
-### Additional dependencies with docker
+### Additional dependencies with docker-compose
 
 If your strategy requires dependencies not included in the default image - it will be necessary to build the image on your host.
 For this, please create a Dockerfile containing installation steps for the additional dependencies (have a look at [docker/Dockerfile.custom](https://github.com/freqtrade/freqtrade/blob/develop/docker/Dockerfile.custom) for an example).
@@ -168,15 +166,15 @@ You'll then also need to modify the `docker-compose.yml` file and uncomment the
       dockerfile: "./Dockerfile.<yourextension>"
 ```
 
-You can then run `docker compose build --pull` to build the docker image, and run it using the commands described above.
+You can then run `docker-compose build --pull` to build the docker image, and run it using the commands described above.
 
-### Plotting with docker
+### Plotting with docker-compose
 
 Commands `freqtrade plot-profit` and `freqtrade plot-dataframe` ([Documentation](plotting.md)) are available by changing the image to `*_plot` in your docker-compose.yml file.
 You can then use these commands as follows:
 
 ``` bash
-docker compose run --rm freqtrade plot-dataframe --strategy AwesomeStrategy -p BTC/ETH --timerange=20180801-20180805
+docker-compose run --rm freqtrade plot-dataframe --strategy AwesomeStrategy -p BTC/ETH --timerange=20180801-20180805
 ```
 
 The output will be stored in the `user_data/plot` directory, and can be opened with any modern browser.
@@ -187,7 +185,7 @@ Freqtrade provides a docker-compose file which starts up a jupyter lab server.
 You can run this server using the following command:
 
 ``` bash
-docker compose -f docker/docker-compose-jupyter.yml up
+docker-compose -f docker/docker-compose-jupyter.yml up
 ```
 
 This will create a docker-container running jupyter lab, which will be accessible using `https://127.0.0.1:8888/lab`.
@@ -196,7 +194,7 @@ Please use the link that's printed in the console after startup for simplified l
 Since part of this image is built on your machine, it is recommended to rebuild the image from time to time to keep freqtrade (and dependencies) up-to-date.
 
 ``` bash
-docker compose -f docker/docker-compose-jupyter.yml build --no-cache
+docker-compose -f docker/docker-compose-jupyter.yml build --no-cache
 ```
 
 ## Troubleshooting

docs/exchanges.md

@@ -54,9 +54,6 @@ This configuration enables kraken, as well as rate-limiting to avoid bans from t
 
 ## Binance
 
-!!! Warning "Server location and geo-ip restrictions"
-    Please be aware that binance restrict api access regarding the server country. The currents and non exhaustive countries blocked are United States, Malaysia (Singapour), Ontario (Canada). Please go to [binance terms > b. Eligibility](https://www.binance.com/en/terms) to find up to date list.
-
 Binance supports [time_in_force](configuration.md#understand-order_time_in_force).
 
 !!! Tip "Stoploss on Exchange"
@@ -75,25 +72,6 @@ Binance has been split into 2, and users must use the correct ccxt exchange ID f
 * [binance.com](https://www.binance.com/) - International users. Use exchange id: `binance`.
 * [binance.us](https://www.binance.us/) - US based users. Use exchange id: `binanceus`.
 
-### Binance RSA keys
-
-Freqtrade supports binance RSA API keys.
-
-We recommend to use them as environment variable.
-
-``` bash
-export FREQTRADE__EXCHANGE__SECRET="$(cat ./rsa_binance.private)"
-```
-
-They can however also be configured via configuration file. Since json doesn't support multi-line strings, you'll have to replace all newlines with `\n` to have a valid json file.
-
-``` json
-// ...
- "key": "<someapikey>",
- "secret": "-----BEGIN PRIVATE KEY-----\nMIIEvQIBABACAFQA<...>s8KX8=\n-----END PRIVATE KEY-----"
-// ...
-```
-
 ### Binance Futures
 
 Binance has specific (unfortunately complex) [Futures Trading Quantitative Rules](https://www.binance.com/en/support/faq/4f462ebe6ff445d4a170be7d9e897272) which need to be followed, and which prohibit a too low stake-amount (among others) for too many orders.
@@ -195,6 +173,26 @@ res = [p for p, x in lm.items() if 'US' in x['info']['prohibitedIn']]
 print(res)
 ```
 
+## FTX
+
+!!! Tip "Stoploss on Exchange"
+    FTX supports `stoploss_on_exchange` and can use both stop-loss-market and stop-loss-limit orders. It provides great advantages, so we recommend to benefit from it.
+    You can use either `"limit"` or `"market"` in the `order_types.stoploss` configuration setting to decide which type of stoploss shall be used.
+
+### Using subaccounts
+
+To use subaccounts with FTX, you need to edit the configuration and add the following:
+
+``` json
+"exchange": {
+    "ccxt_config": {
+        "headers": {
+            "FTX-SUBACCOUNT": "name"
+        }
+    },
+}
+```
+
 ## Kucoin
 
 Kucoin requires a passphrase for each api key, you will therefore need to add this key into the configuration so your exchange section looks as follows:
@@ -243,8 +241,8 @@ OKX requires a passphrase for each api key, you will therefore need to add this
     OKX only provides 100 candles per api call. Therefore, the strategy will only have a pretty low amount of data available in backtesting mode.
 
 !!! Warning "Futures"
-    OKX Futures has the concept of "position mode" - which can be "Buy/Sell" or long/short (hedge mode).
+    OKX Futures has the concept of "position mode" - which can be Net or long/short (hedge mode).
-    Freqtrade supports both modes (we recommend to use Buy/Sell mode) - but changing the mode mid-trading is not supported and will lead to exceptions and failures to place trades.
+    Freqtrade supports both modes (we recommend to use net mode) - but changing the mode mid-trading is not supported and will lead to exceptions and failures to place trades.
     OKX also only provides MARK candles for the past ~3 months. Backtesting futures prior to that date will therefore lead to slight deviations, as funding-fees cannot be calculated correctly without this data.
 
 ## Gate.io
@@ -255,18 +253,6 @@ OKX requires a passphrase for each api key, you will therefore need to add this
 Gate.io allows the use of `POINT` to pay for fees. As this is not a tradable currency (no regular market available), automatic fee calculations will fail (and default to a fee of 0).
 The configuration parameter `exchange.unknown_fee_rate` can be used to specify the exchange rate between Point and the stake currency. Obviously, changing the stake-currency will also require changes to this value.
 
-## Bybit
-
-Futures trading on bybit is currently supported for USDT markets, and will use isolated futures mode.
-Users with unified accounts (there's no way back) can create a Sub-account which will start as "non-unified", and can therefore use isolated futures.
-On startup, freqtrade will set the position mode to "One-way Mode" for the whole (sub)account. This avoids making this call over and over again (slowing down bot operations), but means that changes to this setting may result in exceptions and errors.
-
-As bybit doesn't provide funding rate history, the dry-run calculation is used for live trades as well.
-
-!!! Tip "Stoploss on Exchange"
-    Bybit (futures only) supports `stoploss_on_exchange` and uses `stop-loss-limit` orders. It provides great advantages, so we recommend to benefit from it by enabling stoploss on exchange.
-    On futures, Bybit supports both `stop-limit` as well as `stop-market` orders. You can use either `"limit"` or `"market"` in the `order_types.stoploss` configuration setting to decide which type to use.
-
 ## All exchanges
 
 Should you experience constant errors with Nonce (like `InvalidNonce`), it is best to regenerate the API keys. Resetting Nonce is difficult and it's usually easier to regenerate the API keys.

docs/faq.md

@@ -2,7 +2,7 @@
 
 ## Supported Markets
 
-Freqtrade supports spot trading, as well as (isolated) futures trading for some selected exchanges. Please refer to the [documentation start page](index.md#supported-futures-exchanges-experimental) for an uptodate list of supported exchanges.
+Freqtrade supports spot trading only.
 
 ### Can my bot open short positions?
 
@@ -102,12 +102,6 @@ If this happens for all pairs in the pairlist, this might indicate a recent exch
 
 Irrespectively of the reason, Freqtrade will fill up these candles with "empty" candles, where open, high, low and close are set to the previous candle close - and volume is empty. In a chart, this will look like a `_` - and is aligned with how exchanges usually represent 0 volume candles.
 
-### I'm getting "Price jump between 2 candles detected"
-
-This message is a warning that the candles had a price jump of > 30%.
-This might be a sign that the pair stopped trading, and some token exchange took place (e.g. COCOS in 2021 - where price jumped from 0.0000154 to 0.01621).
-This message is often accompanied by ["Missing data fillup"](#im-getting-missing-data-fillup-messages-in-the-log) - as trading on such pairs is often stopped for some time.
-
 ### I'm getting "Outdated history for pair xxx" in the log
 
 The bot is trying to tell you that it got an outdated last candle (not the last complete candle).
@@ -248,26 +242,8 @@ The Edge module is mostly a result of brainstorming of [@mishaker](https://githu
 You can find further info on expectancy, win rate, risk management and position size in the following sources:
 
 - https://www.tradeciety.com/ultimate-math-guide-for-traders/
+- http://www.vantharp.com/tharp-concepts/expectancy.asp
 - https://samuraitradingacademy.com/trading-expectancy/
 - https://www.learningmarkets.com/determining-expectancy-in-your-trading/
-- https://www.lonestocktrader.com/make-money-trading-positive-expectancy/
+- http://www.lonestocktrader.com/make-money-trading-positive-expectancy/
 - https://www.babypips.com/trading/trade-expectancy-matter
-
-## Official channels
-
-Freqtrade is using exclusively the following official channels:
-
-* [Freqtrade discord server](https://discord.gg/p7nuUNVfP7)
-* [Freqtrade documentation (https://freqtrade.io)](https://freqtrade.io)
-* [Freqtrade github organization](https://github.com/freqtrade)
-
-Nobody affiliated with the freqtrade project will ask you about your exchange keys or anything else exposing your funds to exploitation.
-Should you be asked to expose your exchange keys or send funds to some random wallet, then please don't follow these instructions.
-
-Failing to follow these guidelines will not be responsibility of freqtrade.
-
-## "Freqtrade token"
-
-Freqtrade does not have a Crypto token offering.
-
-Token offerings you find on the internet referring Freqtrade, FreqAI or freqUI must be considered to be a scam, trying to exploit freqtrade's popularity for their own, nefarious gains.

docs/freqai-configuration.md

@@ -9,7 +9,7 @@ FreqAI is configured through the typical [Freqtrade config file](configuration.m
 ```json
     "freqai": {
         "enabled": true,
-        "purge_old_models": 2,
+        "purge_old_models": true,
         "train_period_days": 30,
         "backtest_period_days": 7,
         "identifier" : "unique-id",
@@ -26,7 +26,10 @@ FreqAI is configured through the typical [Freqtrade config file](configuration.m
         },
         "data_split_parameters" : {
             "test_size": 0.25
-        }
+        },
+        "model_training_parameters" : {
+            "n_estimators": 100
+        },
     }
 ```
 
@@ -43,113 +46,119 @@ The FreqAI strategy requires including the following lines of code in the standa
 
     def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
 
-        # the model will return all labels created by user in `set_freqai_labels()`
+        # the model will return all labels created by user in `populate_any_indicators`
         # (& appended targets), an indication of whether or not the prediction should be accepted,
         # the target mean/std values for each of the labels created by user in
-        # `feature_engineering_*` for each training period.
+        # `populate_any_indicators()` for each training period.
 
         dataframe = self.freqai.start(dataframe, metadata, self)
 
         return dataframe
 
-    def feature_engineering_expand_all(self, dataframe, period, **kwargs):
+    def populate_any_indicators(
+        self, pair, df, tf, informative=None, set_generalized_indicators=False
+    ):
         """
-        *Only functional with FreqAI enabled strategies*
+        Function designed to automatically generate, name and merge features
-        This function will automatically expand the defined features on the config defined
+        from user indicated timeframes in the configuration file. User controls the indicators
-        `indicator_periods_candles`, `include_timeframes`, `include_shifted_candles`, and
+        passed to the training/prediction by prepending indicators with `'%-' + coin `
-        `include_corr_pairs`. In other words, a single feature defined in this function
+        (see convention below). I.e. user should not prepend any supporting metrics
-        will automatically expand to a total of
+        (e.g. bb_lowerband below) with % unless they explicitly want to pass that metric to the
-        `indicator_periods_candles` * `include_timeframes` * `include_shifted_candles` *
+        model.
-        `include_corr_pairs` numbers of features added to the model.
+        :param pair: pair to be used as informative
-
+        :param df: strategy dataframe which will receive merges from informatives
-        All features must be prepended with `%` to be recognized by FreqAI internals.
+        :param tf: timeframe of the dataframe which will modify the feature names
-
+        :param informative: the dataframe associated with the informative pair
-        :param df: strategy dataframe which will receive the features
+        :param coin: the name of the coin which will modify the feature names.
-        :param period: period of the indicator - usage example:
-        dataframe["%-ema-period"] = ta.EMA(dataframe, timeperiod=period)
         """
 
-        dataframe["%-rsi-period"] = ta.RSI(dataframe, timeperiod=period)
+        coin = pair.split('/')[0]
-        dataframe["%-mfi-period"] = ta.MFI(dataframe, timeperiod=period)
-        dataframe["%-adx-period"] = ta.ADX(dataframe, timeperiod=period)
-        dataframe["%-sma-period"] = ta.SMA(dataframe, timeperiod=period)
-        dataframe["%-ema-period"] = ta.EMA(dataframe, timeperiod=period)
 
-        return dataframe
+        if informative is None:
+            informative = self.dp.get_pair_dataframe(pair, tf)
 
-    def feature_engineering_expand_basic(self, dataframe, **kwargs):
+        # first loop is automatically duplicating indicators for time periods
-        """
+        for t in self.freqai_info["feature_parameters"]["indicator_periods_candles"]:
-        *Only functional with FreqAI enabled strategies*
+            t = int(t)
-        This function will automatically expand the defined features on the config defined
+            informative[f"%-{coin}rsi-period_{t}"] = ta.RSI(informative, timeperiod=t)
-        `include_timeframes`, `include_shifted_candles`, and `include_corr_pairs`.
+            informative[f"%-{coin}mfi-period_{t}"] = ta.MFI(informative, timeperiod=t)
-        In other words, a single feature defined in this function
+            informative[f"%-{coin}adx-period_{t}"] = ta.ADX(informative, window=t)
-        will automatically expand to a total of
-        `include_timeframes` * `include_shifted_candles` * `include_corr_pairs`
-        numbers of features added to the model.
 
-        Features defined here will *not* be automatically duplicated on user defined
+        indicators = [col for col in informative if col.startswith("%")]
-        `indicator_periods_candles`
+        # This loop duplicates and shifts all indicators to add a sense of recency to data
+        for n in range(self.freqai_info["feature_parameters"]["include_shifted_candles"] + 1):
+            if n == 0:
+                continue
+            informative_shift = informative[indicators].shift(n)
+            informative_shift = informative_shift.add_suffix("_shift-" + str(n))
+            informative = pd.concat((informative, informative_shift), axis=1)
 
-        All features must be prepended with `%` to be recognized by FreqAI internals.
+        df = merge_informative_pair(df, informative, self.config["timeframe"], tf, ffill=True)
+        skip_columns = [
+            (s + "_" + tf) for s in ["date", "open", "high", "low", "close", "volume"]
+        ]
+        df = df.drop(columns=skip_columns)
 
-        :param df: strategy dataframe which will receive the features
+        # Add generalized indicators here (because in live, it will call this
-        dataframe["%-pct-change"] = dataframe["close"].pct_change()
+        # function to populate indicators during training). Notice how we ensure not to
-        dataframe["%-ema-200"] = ta.EMA(dataframe, timeperiod=200)
+        # add them multiple times
-        """
+        if set_generalized_indicators:
-        dataframe["%-pct-change"] = dataframe["close"].pct_change()
-        dataframe["%-raw_volume"] = dataframe["volume"]
-        dataframe["%-raw_price"] = dataframe["close"]
-        return dataframe
 
-    def feature_engineering_standard(self, dataframe, **kwargs):
+            # user adds targets here by prepending them with &- (see convention below)
-        """
+            # If user wishes to use multiple targets, a multioutput prediction model
-        *Only functional with FreqAI enabled strategies*
+            # needs to be used such as templates/CatboostPredictionMultiModel.py
-        This optional function will be called once with the dataframe of the base timeframe.
+            df["&-s_close"] = (
-        This is the final function to be called, which means that the dataframe entering this
+                df["close"]
-        function will contain all the features and columns created by all other
+                .shift(-self.freqai_info["feature_parameters"]["label_period_candles"])
-        freqai_feature_engineering_* functions.
+                .rolling(self.freqai_info["feature_parameters"]["label_period_candles"])
-
+                .mean()
-        This function is a good place to do custom exotic feature extractions (e.g. tsfresh).
+                / df["close"]
-        This function is a good place for any feature that should not be auto-expanded upon
+                - 1
-        (e.g. day of the week).
-
-        All features must be prepended with `%` to be recognized by FreqAI internals.
-
-        :param df: strategy dataframe which will receive the features
-        usage example: dataframe["%-day_of_week"] = (dataframe["date"].dt.dayofweek + 1) / 7
-        """
-        dataframe["%-day_of_week"] = (dataframe["date"].dt.dayofweek + 1) / 7
-        dataframe["%-hour_of_day"] = (dataframe["date"].dt.hour + 1) / 25
-        return dataframe
-
-    def set_freqai_targets(self, dataframe, **kwargs):
-        """
-        *Only functional with FreqAI enabled strategies*
-        Required function to set the targets for the model.
-        All targets must be prepended with `&` to be recognized by the FreqAI internals.
-
-        :param df: strategy dataframe which will receive the targets
-        usage example: dataframe["&-target"] = dataframe["close"].shift(-1) / dataframe["close"]
-        """
-        dataframe["&-s_close"] = (
-            dataframe["close"]
-            .shift(-self.freqai_info["feature_parameters"]["label_period_candles"])
-            .rolling(self.freqai_info["feature_parameters"]["label_period_candles"])
-            .mean()
-            / dataframe["close"]
-            - 1
             )
+
+        return df
+
+
 ```
 
-Notice how the `feature_engineering_*()` is where [features](freqai-feature-engineering.md#feature-engineering) are added. Meanwhile `set_freqai_targets()` adds the labels/targets. A full example strategy is available in `templates/FreqaiExampleStrategy.py`.
+Notice how the `populate_any_indicators()` is where [features](freqai-feature-engineering.md#feature-engineering) and labels/targets are added. A full example strategy is available in `templates/FreqaiExampleStrategy.py`. 
+
+Notice also the location of the labels under `if set_generalized_indicators:` at the bottom of the example. This is where single features and labels/targets should be added to the feature set to avoid duplication of them from various configuration parameters that multiply the feature set, such as `include_timeframes`.
 
 !!! Note
     The `self.freqai.start()` function cannot be called outside the `populate_indicators()`.
 
 !!! Note
-    Features **must** be defined in `feature_engineering_*()`. Defining FreqAI features in `populate_indicators()`
+    Features **must** be defined in `populate_any_indicators()`. Defining FreqAI features in `populate_indicators()`
-    will cause the algorithm to fail in live/dry mode. In order to add generalized features that are not associated with a specific pair or timeframe, you should use `feature_engineering_standard()`
+    will cause the algorithm to fail in live/dry mode. In order to add generalized features that are not associated with a specific pair or timeframe, the following structure inside `populate_any_indicators()` should be used
-    (as exemplified in `freqtrade/templates/FreqaiExampleStrategy.py`).
+    (as exemplified in `freqtrade/templates/FreqaiExampleStrategy.py`):
+
+    ```python
+        def populate_any_indicators(self, metadata, pair, df, tf, informative=None, coin="", set_generalized_indicators=False):
+
+            ...
+
+            # Add generalized indicators here (because in live, it will call only this function to populate
+            # indicators for retraining). Notice how we ensure not to add them multiple times by associating
+            # these generalized indicators to the basepair/timeframe
+            if set_generalized_indicators:
+                df['%-day_of_week'] = (df["date"].dt.dayofweek + 1) / 7
+                df['%-hour_of_day'] = (df['date'].dt.hour + 1) / 25
+
+                # user adds targets here by prepending them with &- (see convention below)
+                # If user wishes to use multiple targets, a multioutput prediction model
+                # needs to be used such as templates/CatboostPredictionMultiModel.py
+                df["&-s_close"] = (
+                    df["close"]
+                    .shift(-self.freqai_info["feature_parameters"]["label_period_candles"])
+                    .rolling(self.freqai_info["feature_parameters"]["label_period_candles"])
+                    .mean()
+                    / df["close"]
+                    - 1
+                    )
+    ```
+
+    Please see the example script located in `freqtrade/templates/FreqaiExampleStrategy.py` for a full example of `populate_any_indicators()`.
 
 ## Important dataframe key patterns
 
@@ -157,18 +166,18 @@ Below are the values you can expect to include/use inside a typical strategy dat
 
 |  DataFrame Key | Description |
 |------------|-------------|
-| `df['&*']` | Any dataframe column prepended with `&` in `set_freqai_targets()` is treated as a training target (label) inside FreqAI (typically following the naming convention `&-s*`). For example, to predict the close price 40 candles into the future, you would set `df['&-s_close'] = df['close'].shift(-self.freqai_info["feature_parameters"]["label_period_candles"])` with `"label_period_candles": 40` in the config. FreqAI makes the predictions and gives them back under the same key (`df['&-s_close']`) to be used in `populate_entry/exit_trend()`. <br> **Datatype:** Depends on the output of the model.
+| `df['&*']` | Any dataframe column prepended with `&` in `populate_any_indicators()` is treated as a training target (label) inside FreqAI (typically following the naming convention `&-s*`). For example, to predict the close price 40 candles into the future, you would set `df['&-s_close'] = df['close'].shift(-self.freqai_info["feature_parameters"]["label_period_candles"])` with `"label_period_candles": 40` in the config. FreqAI makes the predictions and gives them back under the same key (`df['&-s_close']`) to be used in `populate_entry/exit_trend()`. <br> **Datatype:** Depends on the output of the model.
 | `df['&*_std/mean']` | Standard deviation and mean values of the defined labels during training (or live tracking with `fit_live_predictions_candles`). Commonly used to understand the rarity of a prediction (use the z-score as shown in `templates/FreqaiExampleStrategy.py` and explained [here](#creating-a-dynamic-target-threshold) to evaluate how often a particular prediction was observed during training or historically with `fit_live_predictions_candles`). <br> **Datatype:** Float.
 | `df['do_predict']` | Indication of an outlier data point. The return value is integer between -2 and 2, which lets you know if the prediction is trustworthy or not. `do_predict==1` means that the prediction is trustworthy. If the Dissimilarity Index (DI, see details [here](freqai-feature-engineering.md#identifying-outliers-with-the-dissimilarity-index-di)) of the input data point is above the threshold defined in the config, FreqAI will subtract 1 from `do_predict`, resulting in `do_predict==0`. If `use_SVM_to_remove_outliers()` is active, the Support Vector Machine (SVM, see details [here](freqai-feature-engineering.md#identifying-outliers-using-a-support-vector-machine-svm)) may also detect outliers in training and prediction data. In this case, the SVM will also subtract 1 from `do_predict`. If the input data point was considered an outlier by the SVM but not by the DI, or vice versa, the result will be `do_predict==0`. If both the DI and the SVM considers the input data point to be an outlier, the result will be `do_predict==-1`. As with the SVM, if `use_DBSCAN_to_remove_outliers` is active, DBSCAN (see details [here](freqai-feature-engineering.md#identifying-outliers-with-dbscan)) may also detect outliers and subtract 1 from `do_predict`. Hence, if both the SVM and DBSCAN are active and identify a datapoint that was above the DI threshold as an outlier, the result will be `do_predict==-2`. A particular case is when `do_predict == 2`, which means that the model has expired due to exceeding `expired_hours`. <br> **Datatype:** Integer between -2 and 2.
 | `df['DI_values']` | Dissimilarity Index (DI) values are proxies for the level of confidence FreqAI has in the prediction. A lower DI means the prediction is close to the training data, i.e., higher prediction confidence. See details about the DI [here](freqai-feature-engineering.md#identifying-outliers-with-the-dissimilarity-index-di). <br> **Datatype:** Float.
-| `df['%*']` | Any dataframe column prepended with `%` in `feature_engineering_*()` is treated as a training feature. For example, you can include the RSI in the training feature set (similar to in `templates/FreqaiExampleStrategy.py`) by setting `df['%-rsi']`. See more details on how this is done [here](freqai-feature-engineering.md). <br> **Note:** Since the number of features prepended with `%` can multiply very quickly (10s of thousands of features are easily engineered using the multiplictative functionality of, e.g., `include_shifted_candles` and `include_timeframes` as described in the [parameter table](freqai-parameter-table.md)), these features are removed from the dataframe that is returned from FreqAI to the strategy. To keep a particular type of feature for plotting purposes, you would prepend it with `%%`. <br> **Datatype:** Depends on the output of the model.
+| `df['%*']` | Any dataframe column prepended with `%` in `populate_any_indicators()` is treated as a training feature. For example, you can include the RSI in the training feature set (similar to in `templates/FreqaiExampleStrategy.py`) by setting `df['%-rsi']`. See more details on how this is done [here](freqai-feature-engineering.md). <br> **Note:** Since the number of features prepended with `%` can multiply very quickly (10s of thousands of features are easily engineered using the multiplictative functionality of, e.g., `include_shifted_candles` and `include_timeframes` as described in the [parameter table](freqai-parameter-table.md)), these features are removed from the dataframe that is returned from FreqAI to the strategy. To keep a particular type of feature for plotting purposes, you would prepend it with `%%`. <br> **Datatype:** Depends on the output of the model.
 
 ## Setting the `startup_candle_count`
 
-The `startup_candle_count` in the FreqAI strategy needs to be set up in the same way as in the standard Freqtrade strategy (see details [here](strategy-customization.md#strategy-startup-period)). This value is used by Freqtrade to ensure that a sufficient amount of data is provided when calling the `dataprovider`, to avoid any NaNs at the beginning of the first training. You can easily set this value by identifying the longest period (in candle units) which is passed to the indicator creation functions (e.g., TA-Lib functions). In the presented example, `startup_candle_count` is 20 since this is the maximum value in `indicators_periods_candles`.
+The `startup_candle_count` in the FreqAI strategy needs to be set up in the same way as in the standard Freqtrade strategy (see details [here](strategy-customization.md#strategy-startup-period)). This value is used by Freqtrade to ensure that a sufficient amount of data is provided when calling the `dataprovider`, to avoid any NaNs at the beginning of the first training. You can easily set this value by identifying the longest period (in candle units) which is passed to the indicator creation functions (e.g., Ta-Lib functions). In the presented example, `startup_candle_count` is 20 since this is the maximum value in `indicators_periods_candles`.
 
 !!! Note
-    There are instances where the TA-Lib functions actually require more data than just the passed `period` or else the feature dataset gets populated with NaNs. Anecdotally, multiplying the `startup_candle_count` by 2 always leads to a fully NaN free training dataset. Hence, it is typically safest to multiply the expected `startup_candle_count` by 2. Look out for this log message to confirm that the data is clean:
+    There are instances where the Ta-Lib functions actually require more data than just the passed `period` or else the feature dataset gets populated with NaNs. Anecdotally, multiplying the `startup_candle_count` by 2 always leads to a fully NaN free training dataset. Hence, it is typically safest to multiply the expected `startup_candle_count` by 2. Look out for this log message to confirm that the data is clean:
 
     ```
     2022-08-31 15:14:04 - freqtrade.freqai.data_kitchen - INFO - dropped 0 training points due to NaNs in populated dataset 4319.
@@ -183,11 +192,11 @@ dataframe["target_roi"] = dataframe["&-s_close_mean"] + dataframe["&-s_close_std
 dataframe["sell_roi"] = dataframe["&-s_close_mean"] - dataframe["&-s_close_std"] * 1.25
 ```
 
-To consider the population of *historical predictions* for creating the dynamic target instead of information from the training as discussed above, you would set `fit_live_predictions_candles` in the config to the number of historical prediction candles you wish to use to generate target statistics.
+To consider the population of *historical predictions* for creating the dynamic target instead of information from the training as discussed above, you would set `fit_live_prediction_candles` in the config to the number of historical prediction candles you wish to use to generate target statistics.
 
 ```json
     "freqai": {
-        "fit_live_predictions_candles": 300,
+        "fit_live_prediction_candles": 300,
     }
 ```
 
@@ -195,202 +204,14 @@ If this value is set, FreqAI will initially use the predictions from the trainin
 
 ## Using different prediction models
 
-FreqAI has multiple example prediction model libraries that are ready to be used as is via the flag `--freqaimodel`. These libraries include `CatBoost`, `LightGBM`, and `XGBoost` regression, classification, and multi-target models, and can be found in `freqai/prediction_models/`.
+FreqAI has multiple example prediction model libraries that are ready to be used as is via the flag `--freqaimodel`. These libraries include `Catboost`, `LightGBM`, and `XGBoost` regression, classification, and multi-target models, and can be found in `freqai/prediction_models/`. However, it is possible to customize and create your own prediction models using the `IFreqaiModel` class. You are encouraged to inherit `fit()`, `train()`, and `predict()` to let these customize various aspects of the training procedures.
 
-Regression and classification models differ in what targets they predict - a regression model will predict a target of continuous values, for example what price BTC will be at tomorrow, whilst a classifier will predict a target of discrete values, for example if the price of BTC will go up tomorrow or not. This means that you have to specify your targets differently depending on which model type you are using (see details [below](#setting-model-targets)).
+### Setting classifier targets
 
-All of the aforementioned model libraries implement gradient boosted decision tree algorithms. They all work on the principle of ensemble learning, where predictions from multiple simple learners are combined to get a final prediction that is more stable and generalized. The simple learners in this case are decision trees. Gradient boosting refers to the method of learning, where each simple learner is built in sequence - the subsequent learner is used to improve on the error from the previous learner. If you want to learn more about the different model libraries you can find the information in their respective docs:
+FreqAI includes a variety of classifiers, such as the `CatboostClassifier` via the flag `--freqaimodel CatboostClassifier`. If you elects to use a classifier, the classes need to be set using strings. For example:
-
-* CatBoost: https://catboost.ai/en/docs/
-* LightGBM: https://lightgbm.readthedocs.io/en/v3.3.2/#
-* XGBoost: https://xgboost.readthedocs.io/en/stable/#
-
-There are also numerous online articles describing and comparing the algorithms. Some relatively lightweight examples would be [CatBoost vs. LightGBM vs. XGBoost — Which is the best algorithm?](https://towardsdatascience.com/catboost-vs-lightgbm-vs-xgboost-c80f40662924#:~:text=In%20CatBoost%2C%20symmetric%20trees%2C%20or,the%20same%20depth%20can%20differ.) and [XGBoost, LightGBM or CatBoost — which boosting algorithm should I use?](https://medium.com/riskified-technology/xgboost-lightgbm-or-catboost-which-boosting-algorithm-should-i-use-e7fda7bb36bc). Keep in mind that the performance of each model is highly dependent on the application and so any reported metrics might not be true for your particular use of the model.
-
-Apart from the models already available in FreqAI, it is also possible to customize and create your own prediction models using the `IFreqaiModel` class. You are encouraged to inherit `fit()`, `train()`, and `predict()` to customize various aspects of the training procedures. You can place custom FreqAI models in `user_data/freqaimodels` - and freqtrade will pick them up from there based on the provided `--freqaimodel` name - which has to correspond to the class name of your custom model.
-Make sure to use unique names to avoid overriding built-in models.
-
-### Setting model targets
-
-#### Regressors
-
-If you are using a regressor, you need to specify a target that has continuous values. FreqAI includes a variety of regressors, such as the `CatboostRegressor`via the flag `--freqaimodel CatboostRegressor`. An example of how you could set a regression target for predicting the price 100 candles into the future would be
-
-```python
-df['&s-close_price'] = df['close'].shift(-100)
-```
-
-If you want to predict multiple targets, you need to define multiple labels using the same syntax as shown above.
-
-#### Classifiers
-
-If you are using a classifier, you need to specify a target that has discrete values. FreqAI includes a variety of classifiers, such as the `CatboostClassifier` via the flag `--freqaimodel CatboostClassifier`. If you elects to use a classifier, the classes need to be set using strings. For example, if you want to predict if the price 100 candles into the future goes up or down you would set
 
 ```python
 df['&s-up_or_down'] = np.where( df["close"].shift(-100) > df["close"], 'up', 'down')
 ```
 
-If you want to predict multiple targets you must specify all labels in the same label column. You could, for example, add the label `same` to define where the price was unchanged by setting
+Additionally, the example classifier models do not accommodate multiple labels, but they do allow multi-class classification within a single label column.
-
-```python
-df['&s-up_or_down'] = np.where( df["close"].shift(-100) > df["close"], 'up', 'down')
-df['&s-up_or_down'] = np.where( df["close"].shift(-100) == df["close"], 'same', df['&s-up_or_down'])
-```
-
-## PyTorch Module
-
-### Quick start
-
-The easiest way to quickly run a pytorch model is with the following command (for regression task):
-
-```bash
-freqtrade trade --config config_examples/config_freqai.example.json --strategy FreqaiExampleStrategy --freqaimodel PyTorchMLPRegressor --strategy-path freqtrade/templates 
-```
-
-!!! note "Installation/docker"
-    The PyTorch module requires large packages such as `torch`, which should be explicitly requested during `./setup.sh -i` by answering "y" to the question "Do you also want dependencies for freqai-rl or PyTorch (~700mb additional space required) [y/N]?".
-    Users who prefer docker should ensure they use the docker image appended with `_freqaitorch`.
-
-### Structure
-
-#### Model
-
-You can construct your own Neural Network architecture in PyTorch by simply defining your `nn.Module` class inside your custom [`IFreqaiModel` file](#using-different-prediction-models) and then using that class in your `def train()` function. Here is an example of logistic regression model implementation using PyTorch (should be used with nn.BCELoss criterion) for classification tasks.
-
-```python
-
-class LogisticRegression(nn.Module):
-    def __init__(self, input_size: int):
-        super().__init__()
-        # Define your layers
-        self.linear = nn.Linear(input_size, 1)
-        self.activation = nn.Sigmoid()
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        # Define the forward pass
-        out = self.linear(x)
-        out = self.activation(out)
-        return out
-
-class MyCoolPyTorchClassifier(BasePyTorchClassifier):
-    """
-    This is a custom IFreqaiModel showing how a user might setup their own 
-    custom Neural Network architecture for their training.
-    """
-
-    @property
-    def data_convertor(self) -> PyTorchDataConvertor:
-        return DefaultPyTorchDataConvertor(target_tensor_type=torch.float)
-
-    def __init__(self, **kwargs) -> None:
-        super().__init__(**kwargs)
-        config = self.freqai_info.get("model_training_parameters", {})
-        self.learning_rate: float = config.get("learning_rate",  3e-4)
-        self.model_kwargs: Dict[str, Any] = config.get("model_kwargs",  {})
-        self.trainer_kwargs: Dict[str, Any] = config.get("trainer_kwargs",  {})
-
-    def fit(self, data_dictionary: Dict, dk: FreqaiDataKitchen, **kwargs) -> Any:
-        """
-        User sets up the training and test data to fit their desired model here
-        :param data_dictionary: the dictionary holding all data for train, test,
-            labels, weights
-        :param dk: The datakitchen object for the current coin/model
-        """
-
-        class_names = self.get_class_names()
-        self.convert_label_column_to_int(data_dictionary, dk, class_names)
-        n_features = data_dictionary["train_features"].shape[-1]
-        model = LogisticRegression(
-            input_dim=n_features
-        )
-        model.to(self.device)
-        optimizer = torch.optim.AdamW(model.parameters(), lr=self.learning_rate)
-        criterion = torch.nn.CrossEntropyLoss()
-        init_model = self.get_init_model(dk.pair)
-        trainer = PyTorchModelTrainer(
-            model=model,
-            optimizer=optimizer,
-            criterion=criterion,
-            model_meta_data={"class_names": class_names},
-            device=self.device,
-            init_model=init_model,
-            data_convertor=self.data_convertor,
-            **self.trainer_kwargs,
-        )
-        trainer.fit(data_dictionary, self.splits)
-        return trainer
-
-```
-
-#### Trainer
-
-The `PyTorchModelTrainer` performs the idiomatic PyTorch train loop:
-Define our model, loss function, and optimizer, and then move them to the appropriate device (GPU or CPU). Inside the loop, we iterate through the batches in the dataloader, move the data to the device, compute the prediction and loss, backpropagate, and update the model parameters using the optimizer. 
-
-In addition, the trainer is responsible for the following:
- - saving and loading the model
- - converting the data from `pandas.DataFrame` to `torch.Tensor`. 
-
-#### Integration with Freqai module 
-
-Like all freqai models, PyTorch models inherit `IFreqaiModel`. `IFreqaiModel` declares three abstract methods: `train`, `fit`, and `predict`. we implement these methods in three levels of hierarchy.
-From top to bottom:
-
-1. `BasePyTorchModel` - Implements the `train` method. all `BasePyTorch*` inherit it. responsible for general data preparation (e.g., data normalization) and calling the `fit` method. Sets `device` attribute used by children classes. Sets `model_type` attribute used by the parent class.
-2. `BasePyTorch*` -  Implements the `predict` method. Here, the `*` represents a group of algorithms, such as classifiers or regressors. responsible for data preprocessing, predicting, and postprocessing if needed.
-3. `PyTorch*Classifier` / `PyTorch*Regressor` - implements the `fit` method. responsible for the main train flaw, where we initialize the trainer and model objects.
-
-![image](assets/freqai_pytorch-diagram.png)
-
-#### Full example
-
-Building a PyTorch regressor using MLP (multilayer perceptron) model, MSELoss criterion, and AdamW optimizer.
-
-```python
-class PyTorchMLPRegressor(BasePyTorchRegressor):
-    def __init__(self, **kwargs) -> None:
-        super().__init__(**kwargs)
-        config = self.freqai_info.get("model_training_parameters", {})
-        self.learning_rate: float = config.get("learning_rate",  3e-4)
-        self.model_kwargs: Dict[str, Any] = config.get("model_kwargs",  {})
-        self.trainer_kwargs: Dict[str, Any] = config.get("trainer_kwargs",  {})
-
-    def fit(self, data_dictionary: Dict, dk: FreqaiDataKitchen, **kwargs) -> Any:
-        n_features = data_dictionary["train_features"].shape[-1]
-        model = PyTorchMLPModel(
-            input_dim=n_features,
-            output_dim=1,
-            **self.model_kwargs
-        )
-        model.to(self.device)
-        optimizer = torch.optim.AdamW(model.parameters(), lr=self.learning_rate)
-        criterion = torch.nn.MSELoss()
-        init_model = self.get_init_model(dk.pair)
-        trainer = PyTorchModelTrainer(
-            model=model,
-            optimizer=optimizer,
-            criterion=criterion,
-            device=self.device,
-            init_model=init_model,
-            target_tensor_type=torch.float,
-            **self.trainer_kwargs,
-        )
-        trainer.fit(data_dictionary)
-        return trainer
-```
-
-Here we create a `PyTorchMLPRegressor` class that implements the `fit` method. The `fit` method specifies the training building blocks: model, optimizer, criterion, and trainer. We inherit both `BasePyTorchRegressor` and `BasePyTorchModel`, where the former implements the `predict` method that is suitable for our regression task, and the latter implements the train method.
-
-??? Note "Setting Class Names for Classifiers"
-    When using classifiers, the user must declare the class names (or targets) by overriding the `IFreqaiModel.class_names` attribute. This is achieved by setting `self.freqai.class_names` in the FreqAI strategy inside the `set_freqai_targets` method.
-    
-    For example, if you are using a binary classifier to predict price movements as up or down, you can set the class names as follows:
-    ```python
-    def set_freqai_targets(self, dataframe: DataFrame, metadata: Dict, **kwargs):
-        self.freqai.class_names = ["down", "up"]
-        dataframe['&s-up_or_down'] = np.where(dataframe["close"].shift(-100) >
-                                                  dataframe["close"], 'up', 'down')
-    
-        return dataframe
-    ```
-    To see a full example, you can refer to the [classifier test strategy class](https://github.com/freqtrade/freqtrade/blob/develop/tests/strategy/strats/freqai_test_classifier.py).

docs/freqai-feature-engineering.md

@@ -2,150 +2,96 @@
 
 ## Defining the features
 
-Low level feature engineering is performed in the user strategy within a set of functions called `feature_engineering_*`. These function set the `base features` such as, `RSI`, `MFI`, `EMA`, `SMA`, time of day, volume, etc. The `base features` can be custom indicators or they can be imported from any technical-analysis library that you can find. FreqAI is equipped with a set of functions to simplify rapid large-scale feature engineering:
+Low level feature engineering is performed in the user strategy within a function called `populate_any_indicators()`. That function sets the `base features` such as, `RSI`, `MFI`, `EMA`, `SMA`, time of day, volume, etc. The `base features` can be custom indicators or they can be imported from any technical-analysis library that you can find. One important syntax rule is that all `base features` string names are prepended with `%`, while labels/targets are prepended with `&`.
-
-|  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_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.
 
 Meanwhile, high level feature engineering is handled within `"feature_parameters":{}` in the FreqAI config. Within this file, it is possible to decide large scale feature expansions on top of the `base_features` such as "including correlated pairs" or "including informative timeframes" or even "including recent candles."
 
-It is advisable to start from the template `feature_engineering_*` functions in the source provided example strategy (found in `templates/FreqaiExampleStrategy.py`) to ensure that the feature definitions are following the correct conventions. Here is an example of how to set the indicators and labels in the strategy:
+It is advisable to start from the template `populate_any_indicators()` in the source provided example strategy (found in `templates/FreqaiExampleStrategy.py`) to ensure that the feature definitions are following the correct conventions. Here is an example of how to set the indicators and labels in the strategy:
 
 ```python
-    def feature_engineering_expand_all(self, dataframe, period, metadata, **kwargs):
+    def populate_any_indicators(
+        self, pair, df, tf, informative=None, set_generalized_indicators=False
+    ):
         """
-        *Only functional with FreqAI enabled strategies*
+        Function designed to automatically generate, name, and merge features
-        This function will automatically expand the defined features on the config defined
+        from user-indicated timeframes in the configuration file. The user controls the indicators
-        `indicator_periods_candles`, `include_timeframes`, `include_shifted_candles`, and
+        passed to the training/prediction by prepending indicators with `'%-' + coin `
-        `include_corr_pairs`. In other words, a single feature defined in this function
+        (see convention below). I.e., the user should not prepend any supporting metrics
-        will automatically expand to a total of
+        (e.g., bb_lowerband below) with % unless they explicitly want to pass that metric to the
-        `indicator_periods_candles` * `include_timeframes` * `include_shifted_candles` *
+        model.
-        `include_corr_pairs` numbers of features added to the model.
+        :param pair: pair to be used as informative
-
+        :param df: strategy dataframe which will receive merges from informatives
-        All features must be prepended with `%` to be recognized by FreqAI internals.
+        :param tf: timeframe of the dataframe which will modify the feature names
-
+        :param informative: the dataframe associated with the informative pair
-        Access metadata such as the current pair/timeframe/period with:
+        :param coin: the name of the coin which will modify the feature names.
-
-        `metadata["pair"]` `metadata["tf"]`  `metadata["period"]`
-
-        :param df: strategy dataframe which will receive the features
-        :param period: period of the indicator - usage example:
-        :param metadata: metadata of current pair
-        dataframe["%-ema-period"] = ta.EMA(dataframe, timeperiod=period)
         """
 
-        dataframe["%-rsi-period"] = ta.RSI(dataframe, timeperiod=period)
+        coin = pair.split('/')[0]
-        dataframe["%-mfi-period"] = ta.MFI(dataframe, timeperiod=period)
-        dataframe["%-adx-period"] = ta.ADX(dataframe, timeperiod=period)
-        dataframe["%-sma-period"] = ta.SMA(dataframe, timeperiod=period)
-        dataframe["%-ema-period"] = ta.EMA(dataframe, timeperiod=period)
 
-        bollinger = qtpylib.bollinger_bands(
+        if informative is None:
-            qtpylib.typical_price(dataframe), window=period, stds=2.2
+            informative = self.dp.get_pair_dataframe(pair, tf)
-        )
-        dataframe["bb_lowerband-period"] = bollinger["lower"]
-        dataframe["bb_middleband-period"] = bollinger["mid"]
-        dataframe["bb_upperband-period"] = bollinger["upper"]
 
-        dataframe["%-bb_width-period"] = (
+        # first loop is automatically duplicating indicators for time periods
-            dataframe["bb_upperband-period"]
+        for t in self.freqai_info["feature_parameters"]["indicator_periods_candles"]:
-            - dataframe["bb_lowerband-period"]
+            t = int(t)
-        ) / dataframe["bb_middleband-period"]
+            informative[f"%-{coin}rsi-period_{t}"] = ta.RSI(informative, timeperiod=t)
-        dataframe["%-close-bb_lower-period"] = (
+            informative[f"%-{coin}mfi-period_{t}"] = ta.MFI(informative, timeperiod=t)
-            dataframe["close"] / dataframe["bb_lowerband-period"]
+            informative[f"%-{coin}adx-period_{t}"] = ta.ADX(informative, window=t)
-        )
 
-        dataframe["%-roc-period"] = ta.ROC(dataframe, timeperiod=period)
+            bollinger = qtpylib.bollinger_bands(
+                qtpylib.typical_price(informative), window=t, stds=2.2
+            )
+            informative[f"{coin}bb_lowerband-period_{t}"] = bollinger["lower"]
+            informative[f"{coin}bb_middleband-period_{t}"] = bollinger["mid"]
+            informative[f"{coin}bb_upperband-period_{t}"] = bollinger["upper"]
 
-        dataframe["%-relative_volume-period"] = (
+            informative[f"%-{coin}bb_width-period_{t}"] = (
-            dataframe["volume"] / dataframe["volume"].rolling(period).mean()
+                informative[f"{coin}bb_upperband-period_{t}"]
-        )
+                - informative[f"{coin}bb_lowerband-period_{t}"]
-
+            ) / informative[f"{coin}bb_middleband-period_{t}"]
-        return dataframe
+            informative[f"%-{coin}close-bb_lower-period_{t}"] = (
-
+                informative["close"] / informative[f"{coin}bb_lowerband-period_{t}"]
-    def feature_engineering_expand_basic(self, dataframe, metadata, **kwargs):
-        """
-        *Only functional with FreqAI enabled strategies*
-        This function will automatically expand the defined features on the config defined
-        `include_timeframes`, `include_shifted_candles`, and `include_corr_pairs`.
-        In other words, a single feature defined in this function
-        will automatically expand to a total of
-        `include_timeframes` * `include_shifted_candles` * `include_corr_pairs`
-        numbers of features added to the model.
-
-        Features defined here will *not* be automatically duplicated on user defined
-        `indicator_periods_candles`
-
-        Access metadata such as the current pair/timeframe with:
-
-        `metadata["pair"]` `metadata["tf"]`
-
-        All features must be prepended with `%` to be recognized by FreqAI internals.
-
-        :param df: strategy dataframe which will receive the features
-        :param metadata: metadata of current pair
-        dataframe["%-pct-change"] = dataframe["close"].pct_change()
-        dataframe["%-ema-200"] = ta.EMA(dataframe, timeperiod=200)
-        """
-        dataframe["%-pct-change"] = dataframe["close"].pct_change()
-        dataframe["%-raw_volume"] = dataframe["volume"]
-        dataframe["%-raw_price"] = dataframe["close"]
-        return dataframe
-
-    def feature_engineering_standard(self, dataframe, metadata, **kwargs):
-        """
-        *Only functional with FreqAI enabled strategies*
-        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 created by all other
-        freqai_feature_engineering_* functions.
-
-        This function is a good place to do custom exotic feature extractions (e.g. tsfresh).
-        This function is a good place for any feature that should not be auto-expanded upon
-        (e.g. day of the week).
-
-        Access metadata such as the current pair with:
-
-        `metadata["pair"]`
-
-        All features must be prepended with `%` to be recognized by FreqAI internals.
-
-        :param df: strategy dataframe which will receive the features
-        :param metadata: metadata of current pair
-        usage example: dataframe["%-day_of_week"] = (dataframe["date"].dt.dayofweek + 1) / 7
-        """
-        dataframe["%-day_of_week"] = (dataframe["date"].dt.dayofweek + 1) / 7
-        dataframe["%-hour_of_day"] = (dataframe["date"].dt.hour + 1) / 25
-        return dataframe
-
-    def set_freqai_targets(self, dataframe, metadata, **kwargs):
-        """
-        *Only functional with FreqAI enabled strategies*
-        Required function to set the targets for the model.
-        All targets must be prepended with `&` to be recognized by the FreqAI internals.
-
-        Access metadata such as the current pair with:
-
-        `metadata["pair"]`
-
-        :param df: strategy dataframe which will receive the targets
-        :param metadata: metadata of current pair
-        usage example: dataframe["&-target"] = dataframe["close"].shift(-1) / dataframe["close"]
-        """
-        dataframe["&-s_close"] = (
-            dataframe["close"]
-            .shift(-self.freqai_info["feature_parameters"]["label_period_candles"])
-            .rolling(self.freqai_info["feature_parameters"]["label_period_candles"])
-            .mean()
-            / dataframe["close"]
-            - 1
             )
 
-        return dataframe
+            informative[f"%-{coin}relative_volume-period_{t}"] = (
+                informative["volume"] / informative["volume"].rolling(t).mean()
+            )
+
+        indicators = [col for col in informative if col.startswith("%")]
+        # This loop duplicates and shifts all indicators to add a sense of recency to data
+        for n in range(self.freqai_info["feature_parameters"]["include_shifted_candles"] + 1):
+            if n == 0:
+                continue
+            informative_shift = informative[indicators].shift(n)
+            informative_shift = informative_shift.add_suffix("_shift-" + str(n))
+            informative = pd.concat((informative, informative_shift), axis=1)
+
+        df = merge_informative_pair(df, informative, self.config["timeframe"], tf, ffill=True)
+        skip_columns = [
+            (s + "_" + tf) for s in ["date", "open", "high", "low", "close", "volume"]
+        ]
+        df = df.drop(columns=skip_columns)
+
+        # Add generalized indicators here (because in live, it will call this
+        # function to populate indicators during training). Notice how we ensure not to
+        # add them multiple times
+        if set_generalized_indicators:
+            df["%-day_of_week"] = (df["date"].dt.dayofweek + 1) / 7
+            df["%-hour_of_day"] = (df["date"].dt.hour + 1) / 25
+
+            # user adds targets here by prepending them with &- (see convention below)
+            # If user wishes to use multiple targets, a multioutput prediction model
+            # needs to be used such as templates/CatboostPredictionMultiModel.py
+            df["&-s_close"] = (
+                df["close"]
+                .shift(-self.freqai_info["feature_parameters"]["label_period_candles"])
+                .rolling(self.freqai_info["feature_parameters"]["label_period_candles"])
+                .mean()
+                / df["close"]
+                - 1
+            )
+
+        return df
 ```
 
 In the presented example, the user does not wish to pass the `bb_lowerband` as a feature to the model,
@@ -172,28 +118,15 @@ After having defined the `base features`, the next step is to expand upon them u
     }
 ```
 
-The `include_timeframes` in the config above are the timeframes (`tf`) of each call to `feature_engineering_expand_*()` in the strategy. In the presented case, the user is asking for the `5m`, `15m`, and `4h` timeframes of the `rsi`, `mfi`, `roc`, and `bb_width` to be included in the feature set.
+The `include_timeframes` in the config above are the timeframes (`tf`) of each call to `populate_any_indicators()` in the strategy. In the presented case, the user is asking for the `5m`, `15m`, and `4h` timeframes of the `rsi`, `mfi`, `roc`, and `bb_width` to be included in the feature set.
 
-You can ask for each of the defined features to be included also for informative pairs using the `include_corr_pairlist`. This means that the feature set will include all the features from `feature_engineering_expand_*()` on all the `include_timeframes` for each of the correlated pairs defined in the config (`ETH/USD`, `LINK/USD`, and `BNB/USD` in the presented example).
+You can ask for each of the defined features to be included also for informative pairs using the `include_corr_pairlist`. This means that the feature set will include all the features from `populate_any_indicators` on all the `include_timeframes` for each of the correlated pairs defined in the config (`ETH/USD`, `LINK/USD`, and `BNB/USD` in the presented example).
 
 `include_shifted_candles` indicates the number of previous candles to include in the feature set. For example, `include_shifted_candles: 2` tells FreqAI to include the past 2 candles for each of the features in the feature set.
 
-In total, the number of features the user of the presented example strat has created is: length of `include_timeframes` * no. features in `feature_engineering_expand_*()` * length of `include_corr_pairlist` * no. `include_shifted_candles` * length of `indicator_periods_candles`
+In total, the number of features the user of the presented example strat has created is: length of `include_timeframes` * no. features in `populate_any_indicators()` * length of `include_corr_pairlist` * no. `include_shifted_candles` * length of `indicator_periods_candles`
  $= 3 * 3 * 3 * 2 * 2 = 108$.
 
-
-### 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
-def feature_engineering_expand_all(self, dataframe, period, metadata, **kwargs):
- if metadata["tf"] == "1h":
-    dataframe["%-roc-period"] = ta.ROC(dataframe, timeperiod=period)
-```
-
-This will block `ta.ROC()` from being added to any timeframes other than `"1h"`.
-
 ### Returning additional info from training
 
 Important metrics can be returned to the strategy at the end of each model training by assigning them to `dk.data['extra_returns_per_train']['my_new_value'] = XYZ` inside the custom prediction model class. 
@@ -234,7 +167,7 @@ This will perform PCA on the features and reduce their dimensionality so that th
 
 ## Inlier metric
 
-The `inlier_metric` is a metric aimed at quantifying how similar the features of a data point are to the most recent historical data points. 
+The `inlier_metric` is a metric aimed at quantifying how similar a the features of a data point are to the most recent historic data points. 
 
 You define the lookback window by setting `inlier_metric_window` and FreqAI computes the distance between the present time point and each of the previous `inlier_metric_window` lookback points. A Weibull function is fit to each of the lookback distributions and its cumulative distribution function (CDF) is used to produce a quantile for each lookback point. The `inlier_metric` is then computed for each time point as the average of the corresponding lookback quantiles. The figure below explains the concept for an `inlier_metric_window` of 5.
 

docs/freqai-parameter-table.md

@@ -4,39 +4,31 @@ The table below will list all configuration parameters available for FreqAI. Som
 
 Mandatory parameters are marked as **Required** and have to be set in one of the suggested ways.
 
-### General configuration parameters
-
 |  Parameter | Description |
 |------------|-------------|
-|  |  **General configuration parameters within the `config.freqai` tree**
+|  |  **General configuration parameters**
 | `freqai` | **Required.** <br> The parent dictionary containing all the parameters for controlling FreqAI. <br> **Datatype:** Dictionary.
 | `train_period_days` | **Required.** <br> Number of days to use for the training data (width of the sliding window). <br> **Datatype:** Positive integer.
 | `backtest_period_days` | **Required.** <br> Number of days to inference from the trained model before sliding the `train_period_days` window defined above, and retraining the model during backtesting (more info [here](freqai-running.md#backtesting)). This can be fractional days, but beware that the provided `timerange` will be divided by this number to yield the number of trainings necessary to complete the backtest. <br> **Datatype:** Float.
 | `identifier` | **Required.** <br> A unique ID for the current model. If models are saved to disk, the `identifier` allows for reloading specific pre-trained models/data. <br> **Datatype:** String.
 | `live_retrain_hours` | Frequency of retraining during dry/live runs. <br> **Datatype:** Float > 0. <br> Default: `0` (models retrain as often as possible).
 | `expiration_hours` | Avoid making predictions if a model is more than `expiration_hours` old. <br> **Datatype:** Positive integer. <br> Default: `0` (models never expire).
-| `purge_old_models` | Number of models to keep on disk (not relevant to backtesting). Default is 2, which means that dry/live runs will keep the latest 2 models on disk. Setting to 0 keeps all models. This parameter also accepts a boolean to maintain backwards compatibility. <br> **Datatype:** Integer. <br> Default: `2`.
+| `purge_old_models` | Delete obsolete models. <br> **Datatype:** Boolean. <br> Default: `False` (all historic models remain on disk).
 | `save_backtest_models` | Save models to disk when running backtesting. Backtesting operates most efficiently by saving the prediction data and reusing them directly for subsequent runs (when you wish to tune entry/exit parameters). Saving backtesting models to disk also allows to use the same model files for starting a dry/live instance with the same model `identifier`. <br> **Datatype:** Boolean. <br> Default: `False` (no models are saved).
 | `fit_live_predictions_candles` | Number of historical candles to use for computing target (label) statistics from prediction data, instead of from the training dataset (more information can be found [here](freqai-configuration.md#creating-a-dynamic-target-threshold)). <br> **Datatype:** Positive integer.
+| `follow_mode` | Use a `follower` that will look for models associated with a specific `identifier` and load those for inferencing. A `follower` will **not** train new models. <br> **Datatype:** Boolean. <br> Default: `False`.
 | `continual_learning` | Use the final state of the most recently trained model as starting point for the new model, allowing for incremental learning (more information can be found [here](freqai-running.md#continual-learning)). <br> **Datatype:** Boolean. <br> Default: `False`.
-| `write_metrics_to_disk` | Collect train timings, inference timings and cpu usage in json file. <br> **Datatype:** Boolean. <br> Default: `False`
+|  |  **Feature parameters**
-| `data_kitchen_thread_count` | <br> Designate the number of threads you want to use for data processing (outlier methods, normalization, etc.). This has no impact on the number of threads used for training. If user does not set it (default), FreqAI will use max number of threads - 2 (leaving 1 physical core available for Freqtrade bot and FreqUI) <br> **Datatype:** Positive integer.
-
-### Feature parameters
-
-|  Parameter | Description |
-|------------|-------------|
-|  |  **Feature parameters within the `freqai.feature_parameters` sub dictionary**
 | `feature_parameters` | A dictionary containing the parameters used to engineer the feature set. Details and examples are shown [here](freqai-feature-engineering.md). <br> **Datatype:** Dictionary.
-| `include_timeframes` | A list of timeframes that all indicators in `feature_engineering_expand_*()` will be created for. The list is added as features to the base indicators dataset. <br> **Datatype:** List of timeframes (strings).
+| `include_timeframes` | A list of timeframes that all indicators in `populate_any_indicators` will be created for. The list is added as features to the base indicators dataset. <br> **Datatype:** List of timeframes (strings).
-| `include_corr_pairlist` | A list of correlated coins that FreqAI will add as additional features to all `pair_whitelist` coins. All indicators set in `feature_engineering_expand_*()` during feature engineering (see details [here](freqai-feature-engineering.md)) will be created for each correlated coin. The correlated coins features are added to the base indicators dataset. <br> **Datatype:** List of assets (strings).
+| `include_corr_pairlist` | A list of correlated coins that FreqAI will add as additional features to all `pair_whitelist` coins. All indicators set in `populate_any_indicators` during feature engineering (see details [here](freqai-feature-engineering.md)) will be created for each correlated coin. The correlated coins features are added to the base indicators dataset. <br> **Datatype:** List of assets (strings).
-| `label_period_candles` | Number of candles into the future that the labels are created for. This is used in `feature_engineering_expand_all()` (see `templates/FreqaiExampleStrategy.py` for detailed usage). You can create custom labels and choose whether to make use of this parameter or not. <br> **Datatype:** Positive integer.
+| `label_period_candles` | Number of candles into the future that the labels are created for. This is used in `populate_any_indicators` (see `templates/FreqaiExampleStrategy.py` for detailed usage). You can create custom labels and choose whether to make use of this parameter or not. <br> **Datatype:** Positive integer.
 | `include_shifted_candles` | Add features from previous candles to subsequent candles with the intent of adding historical information. If used, FreqAI will duplicate and shift all features from the `include_shifted_candles` previous candles so that the information is available for the subsequent candle. <br> **Datatype:** Positive integer.
 | `weight_factor` | Weight training data points according to their recency (see details [here](freqai-feature-engineering.md#weighting-features-for-temporal-importance)). <br> **Datatype:** Positive float (typically < 1).
-| `indicator_max_period_candles` | **No longer used (#7325)**. Replaced by `startup_candle_count` which is set in the [strategy](freqai-configuration.md#building-a-freqai-strategy). `startup_candle_count` is timeframe independent and defines the maximum *period* used in `feature_engineering_*()` for indicator creation. FreqAI uses this parameter together with the maximum timeframe in `include_time_frames` to calculate how many data points to download such that the first data point does not include a NaN. <br> **Datatype:** Positive integer.
+| `indicator_max_period_candles` | **No longer used (#7325)**. Replaced by `startup_candle_count` which is set in the [strategy](freqai-configuration.md#building-a-freqai-strategy). `startup_candle_count` is timeframe independent and defines the maximum *period* used in `populate_any_indicators()` for indicator creation. FreqAI uses this parameter together with the maximum timeframe in `include_time_frames` to calculate how many data points to download such that the first data point does not include a NaN. <br> **Datatype:** Positive integer.
 | `indicator_periods_candles` | Time periods to calculate indicators for. The indicators are added to the base indicator dataset. <br> **Datatype:** List of positive integers.
 | `principal_component_analysis` | Automatically reduce the dimensionality of the data set using Principal Component Analysis. See details about how it works [here](#reducing-data-dimensionality-with-principal-component-analysis) <br> **Datatype:** Boolean. <br> Default: `False`.
-| `plot_feature_importances` | Create a feature importance plot for each model for the top/bottom `plot_feature_importances` number of features. Plot is stored in `user_data/models/<identifier>/sub-train-<COIN>_<timestamp>.html`. <br> **Datatype:** Integer. <br> Default: `0`.
+| `plot_feature_importances` | Create a feature importance plot for each model for the top/bottom `plot_feature_importances` number of features. <br> **Datatype:** Integer. <br> Default: `0`.
 | `DI_threshold` | Activates the use of the Dissimilarity Index for outlier detection when set to > 0. See details about how it works [here](freqai-feature-engineering.md#identifying-outliers-with-the-dissimilarity-index-di). <br> **Datatype:** Positive float (typically < 1).
 | `use_SVM_to_remove_outliers` | Train a support vector machine to detect and remove outliers from the training dataset, as well as from incoming data points. See details about how it works [here](freqai-feature-engineering.md#identifying-outliers-using-a-support-vector-machine-svm). <br> **Datatype:** Boolean.
 | `svm_params` | All parameters available in Sklearn's `SGDOneClassSVM()`. See details about some select parameters [here](freqai-feature-engineering.md#identifying-outliers-using-a-support-vector-machine-svm). <br> **Datatype:** Dictionary.
@@ -45,73 +37,25 @@ Mandatory parameters are marked as **Required** and have to be set in one of the
 | `noise_standard_deviation` | If set, FreqAI adds noise to the training features with the aim of preventing overfitting. FreqAI generates random deviates from a gaussian distribution with a standard deviation of `noise_standard_deviation` and adds them to all data points. `noise_standard_deviation` should be kept relative to the normalized space, i.e., between -1 and 1. In other words, since data in FreqAI is always normalized to be between -1 and 1, `noise_standard_deviation: 0.05` would result in 32% of the data being randomly increased/decreased by more than 2.5% (i.e., the percent of data falling within the first standard deviation). <br> **Datatype:** Integer. <br> Default: `0`.
 | `outlier_protection_percentage` | Enable to prevent outlier detection methods from discarding too much data. If more than `outlier_protection_percentage` % of points are detected as outliers by the SVM or DBSCAN, FreqAI will log a warning message and ignore outlier detection, i.e., the original dataset will be kept intact. If the outlier protection is triggered, no predictions will be made based on the training dataset. <br> **Datatype:** Float. <br> Default: `30`.
 | `reverse_train_test_order` | Split the feature dataset (see below) and use the latest data split for training and test on historical split of the data. This allows the model to be trained up to the most recent data point, while avoiding overfitting. However, you should be careful to understand the unorthodox nature of this parameter before employing it. <br> **Datatype:** Boolean. <br> Default: `False` (no reversal).
-| `shuffle_after_split` | Split the data into train and test sets, and then shuffle both sets individually. <br> **Datatype:** Boolean. <br> Default: `False`.
+|  |  **Data split parameters**
-| `buffer_train_data_candles` | Cut `buffer_train_data_candles` off the beginning and end of the training data *after* the indicators were populated. The main example use is when predicting maxima and minima, the argrelextrema function  cannot know the maxima/minima at the edges of the timerange. To improve model accuracy, it is best to compute argrelextrema on the full timerange and then use this function to cut off the edges (buffer) by the kernel. In another case, if the targets are set to a shifted price movement, this buffer is unnecessary because the shifted candles at the end of the timerange will be NaN and FreqAI will automatically cut those off of the training dataset.<br> **Datatype:** Integer. <br> Default: `0`.
+| `data_split_parameters` | Include any additional parameters available from Scikit-learn `test_train_split()`, which are shown [here](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html) (external website). <br> **Datatype:** Dictionary.
-
-### Data split parameters
-
-|  Parameter | Description |
-|------------|-------------|
-|  |  **Data split parameters within the `freqai.data_split_parameters` sub dictionary**
-| `data_split_parameters` | Include any additional parameters available from scikit-learn `test_train_split()`, which are shown [here](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html) (external website). <br> **Datatype:** Dictionary.
 | `test_size` | The fraction of data that should be used for testing instead of training. <br> **Datatype:** Positive float < 1.
 | `shuffle` | Shuffle the training data points during training. Typically, to not remove the chronological order of data in time-series forecasting, this is set to `False`. <br> **Datatype:** Boolean. <br> Defaut: `False`.
-
+|  |  **Model training parameters**
-### Model training parameters
+| `model_training_parameters` | A flexible dictionary that includes all parameters available by the selected model library. For example, if you use `LightGBMRegressor`, this dictionary can contain any parameter available by the `LightGBMRegressor` [here](https://lightgbm.readthedocs.io/en/latest/pythonapi/lightgbm.LGBMRegressor.html) (external website). If you select a different model, this dictionary can contain any parameter from that model.  <br> **Datatype:** Dictionary.
-
-|  Parameter | Description |
-|------------|-------------|
-|  |  **Model training parameters within the `freqai.model_training_parameters` sub dictionary**
-| `model_training_parameters` | A flexible dictionary that includes all parameters available by the selected model library. For example, if you use `LightGBMRegressor`, this dictionary can contain any parameter available by the `LightGBMRegressor` [here](https://lightgbm.readthedocs.io/en/latest/pythonapi/lightgbm.LGBMRegressor.html) (external website). If you select a different model, this dictionary can contain any parameter from that model. A list of the currently available models can be found [here](freqai-configuration.md#using-different-prediction-models).  <br> **Datatype:** Dictionary.
 | `n_estimators` | The number of boosted trees to fit in the training of the model. <br> **Datatype:** Integer.
 | `learning_rate` | Boosting learning rate during training of the model. <br> **Datatype:** Float.
 | `n_jobs`, `thread_count`, `task_type` | Set the number of threads for parallel processing and the `task_type` (`gpu` or `cpu`). Different model libraries use different parameter names. <br> **Datatype:** Float.
-
+|  |  *Reinforcement Learning Parameters**
-### Reinforcement Learning parameters
-
-|  Parameter | Description |
-|------------|-------------|
-|  |  **Reinforcement Learning Parameters within the `freqai.rl_config` sub dictionary**
 | `rl_config` | A dictionary containing the control parameters for a Reinforcement Learning model. <br> **Datatype:** Dictionary.
 | `train_cycles` | Training time steps will be set based on the `train_cycles * number of training data points. <br> **Datatype:** Integer.
 | `cpu_count` | Number of processors to dedicate to the Reinforcement Learning training process. <br> **Datatype:** int.
-| `max_trade_duration_candles`| Guides the agent training to keep trades below desired length. Example usage shown in `prediction_models/ReinforcementLearner.py` within the customizable `calculate_reward()` function. <br> **Datatype:** int.
+| `max_trade_duration_candles`| Guides the agent training to keep trades below desired length. Example usage shown in `prediction_models/ReinforcementLearner.py` within the user customizable `calculate_reward()` <br> **Datatype:** int.
 | `model_type` | Model string from stable_baselines3 or SBcontrib. Available strings include: `'TRPO', 'ARS', 'RecurrentPPO', 'MaskablePPO', 'PPO', 'A2C', 'DQN'`. User should ensure that `model_training_parameters` match those available to the corresponding stable_baselines3 model by visiting their documentaiton. [PPO doc](https://stable-baselines3.readthedocs.io/en/master/modules/ppo.html) (external website) <br> **Datatype:** string.
 | `policy_type` | One of the available policy types from stable_baselines3 <br> **Datatype:** string.
 | `max_training_drawdown_pct` | The maximum drawdown that the agent is allowed to experience during training. <br> **Datatype:** float. <br> Default: 0.8
-| `cpu_count` | Number of threads/cpus to dedicate to the Reinforcement Learning training process (depending on if `ReinforcementLearning_multiproc` is selected or not). Recommended to leave this untouched, by default, this value is set to the total number of physical cores minus 1. <br> **Datatype:** int. 
+| `cpu_count` | Number of threads/cpus to dedicate to the Reinforcement Learning training process (depending on if `ReinforcementLearning_multiproc` is selected or not). <br> **Datatype:** int. 
-| `model_reward_parameters` | Parameters used inside the customizable `calculate_reward()` function in `ReinforcementLearner.py` <br> **Datatype:** int.
+| `model_reward_parameters` | Parameters used inside the user customizable `calculate_reward()` function in `ReinforcementLearner.py` <br> **Datatype:** int.
-| `add_state_info` | Tell FreqAI to include state information in the feature set for training and inferencing. The current state variables include trade duration, current profit, trade position. This is only available in dry/live runs, and is automatically switched to false for backtesting. <br> **Datatype:** bool. <br> Default: `False`.
-| `net_arch` | Network architecture which is well described in [`stable_baselines3` doc](https://stable-baselines3.readthedocs.io/en/master/guide/custom_policy.html#examples). In summary: `[<shared layers>, dict(vf=[<non-shared value network layers>], pi=[<non-shared policy network layers>])]`. By default this is set to `[128, 128]`, which defines 2 shared hidden layers with 128 units each.
-| `randomize_starting_position` | Randomize the starting point of each episode to avoid overfitting. <br> **Datatype:** bool. <br> Default: `False`.
-| `drop_ohlc_from_features` | Do not include the normalized ohlc data in the feature set passed to the agent during training (ohlc will still be used for driving the environment in all cases) <br> **Datatype:** Boolean. <br> **Default:** `False`
-
-### PyTorch parameters
-
-#### general
-
-|  Parameter | Description |
-|------------|-------------|
-|  |  **Model training parameters within the `freqai.model_training_parameters` sub dictionary**
-| `learning_rate` | Learning rate to be passed to the optimizer. <br> **Datatype:** float. <br> Default: `3e-4`.
-| `model_kwargs` | Parameters to be passed to the model class. <br> **Datatype:** dict. <br> Default: `{}`.
-| `trainer_kwargs` | Parameters to be passed to the trainer class. <br> **Datatype:** dict. <br> Default: `{}`.
-
-#### trainer_kwargs
-
-|  Parameter | Description |
-|------------|-------------|
-|  |  **Model training parameters within the `freqai.model_training_parameters.model_kwargs` sub dictionary**
-| `max_iters` | The number of training iterations to run. iteration here refers to the number of times we call self.optimizer.step(). used to calculate n_epochs. <br> **Datatype:** int. <br> Default: `100`.
-| `batch_size` | The size of the batches to use during training.. <br> **Datatype:** int. <br> Default: `64`.
-| `max_n_eval_batches` | The maximum number batches to use for evaluation.. <br> **Datatype:** int, optional. <br> Default: `None`.
-
-
-### Additional parameters
-
-|  Parameter | Description |
-|------------|-------------|
 |  |  **Extraneous parameters**
-| `freqai.keras` | If the selected model makes use of Keras (typical for TensorFlow-based prediction models), this flag needs to be activated so that the model save/loading follows Keras standards. <br> **Datatype:** Boolean. <br> Default: `False`.
+| `keras` | If the selected model makes use of Keras (typical for Tensorflow-based prediction models), this flag needs to be activated so that the model save/loading follows Keras standards. <br> **Datatype:** Boolean. <br> Default: `False`.
-| `freqai.conv_width` | The width of a convolutional neural network input tensor. This replaces the need for shifting candles (`include_shifted_candles`) by feeding in historical data points as the second dimension of the tensor. Technically, this parameter can also be used for regressors, but it only adds computational overhead and does not change the model training/prediction. <br> **Datatype:** Integer. <br> Default: `2`.
+| `conv_width` | The width of a convolutional neural network input tensor. This replaces the need for shifting candles (`include_shifted_candles`) by feeding in historical data points as the second dimension of the tensor. Technically, this parameter can also be used for regressors, but it only adds computational overhead and does not change the model training/prediction. <br> **Datatype:** Integer. <br> Default: `2`.
-| `freqai.reduce_df_footprint` | Recast all numeric columns to float32/int32, with the objective of reducing ram/disk usage and decreasing train/inference timing. This parameter is set in the main level of the Freqtrade configuration file (not inside FreqAI). <br> **Datatype:** Boolean. <br> Default: `False`.

docs/freqai-reinforcement-learning.md

@@ -1,32 +1,7 @@
 # Reinforcement Learning
 
-!!! Note "Installation size"
+!!! Note
-    Reinforcement learning dependencies include large packages such as `torch`, which should be explicitly requested during `./setup.sh -i` by answering "y" to the question "Do you also want dependencies for freqai-rl (~700mb additional space required) [y/N]?".
+    Reinforcement learning dependencies include large packages such as `torch`, which should be explicitly requested during `./setup.sh -i` by answering "y" to the question "Do you also want dependencies for freqai-rl (~700mb additional space required) [y/N]?" Users who prefer docker should ensure they use the docker image appended with `_freqaiRL`. 
-    Users who prefer docker should ensure they use the docker image appended with `_freqairl`.
-
-## Background and terminology
-
-### What is RL and why does FreqAI need it?
-
-Reinforcement learning involves two important components, the *agent* and the training *environment*. During agent training, the agent moves through historical data candle by candle, always making 1 of a set of actions: Long entry, long exit, short entry, short exit, neutral). During this training process, the environment tracks the performance of these actions and rewards the agent according to a custom user made `calculate_reward()` (here we offer a default reward for users to build on if they wish [details here](#creating-a-custom-reward-function)). The reward is used to train weights in a neural network.
-
-A second important component of the FreqAI RL implementation is the use of *state* information. State information is fed into the network at each step, including current profit, current position, and current trade duration. These are used to train the agent in the training environment, and to reinforce the agent in dry/live (this functionality is not available in backtesting). *FreqAI + Freqtrade is a perfect match for this reinforcing mechanism since this information is readily available in live deployments.*
-
-Reinforcement learning is a natural progression for FreqAI, since it adds a new layer of adaptivity and market reactivity that Classifiers and Regressors cannot match. However, Classifiers and Regressors have strengths that RL does not have such as robust predictions. Improperly trained RL agents may find "cheats" and "tricks" to maximize reward without actually winning any trades. For this reason, RL is more complex and demands a higher level of understanding than typical Classifiers and Regressors.
-
-### The RL interface
-
-With the current framework, we aim to expose the training environment via the common "prediction model" file, which is a user inherited `BaseReinforcementLearner` object (e.g. `freqai/prediction_models/ReinforcementLearner`). Inside this user class, the RL environment is available and customized via `MyRLEnv` as [shown below](#creating-a-custom-reward-function).
-
-We envision the majority of users focusing their effort on creative design of the `calculate_reward()` function [details here](#creating-a-custom-reward-function), while leaving the rest of the environment untouched. Other users may not touch the environment at all, and they will only play with the configuration settings and the powerful feature engineering that already exists in FreqAI. Meanwhile, we enable advanced users to create their own model classes entirely.
-
-The framework is built on stable_baselines3 (torch) and OpenAI gym for the base environment class. But generally speaking, the model class is well isolated. Thus, the addition of competing libraries can be easily integrated into the existing framework. For the environment, it is inheriting from `gym.env` which means that it is necessary to write an entirely new environment in order to switch to a different library.
-
-### Important considerations
-
-As explained above, the agent is "trained" in an artificial trading "environment". In our case, that environment may seem quite similar to a real Freqtrade backtesting environment, but it is *NOT*. In fact, the RL training environment is much more simplified. It does not incorporate any of the complicated strategy logic, such as callbacks like `custom_exit`, `custom_stoploss`, leverage controls, etc. The RL environment is instead a very "raw" representation of the true market, where the agent has free will to learn the policy (read: stoploss, take profit, etc.) which is enforced by the `calculate_reward()`. Thus, it is important to consider that the agent training environment is not identical to the real world.
-
-## Running Reinforcement Learning
 
 Setting up and running a Reinforcement Learning model is the same as running a Regressor or Classifier. The same two flags, `--freqaimodel` and `--strategy`, must be defined on the command line:
 
@@ -34,39 +9,70 @@ Setting up and running a Reinforcement Learning model is the same as running a R
 freqtrade trade --freqaimodel ReinforcementLearner --strategy MyRLStrategy --config config.json
 ```
 
-where `ReinforcementLearner` will use the templated `ReinforcementLearner` from `freqai/prediction_models/ReinforcementLearner` (or a custom user defined one located in `user_data/freqaimodels`). The strategy, on the other hand, follows the same base [feature engineering](freqai-feature-engineering.md) with `feature_engineering_*` as a typical Regressor. The difference lies in the creation of the targets, Reinforcement Learning doesn't require them. However, FreqAI requires a default (neutral) value to be set in the action column:
+where `ReinforcementLearner` will use the templated `ReinforcementLearner` from `freqai/prediction_models/ReinforcementLearner`. The strategy, on the other hand, follows the same base [feature engineering](freqai-feature-engineering.md) with `populate_any_indicators` as a typical Regressor:
 
 ```python
-    def set_freqai_targets(self, dataframe, **kwargs):
+    def populate_any_indicators(
-        """
+        self, pair, df, tf, informative=None, set_generalized_indicators=False
-        *Only functional with FreqAI enabled strategies*
+    ):
-        Required function to set the targets for the model.
-        All targets must be prepended with `&` to be recognized by the FreqAI internals.
 
-        More details about feature engineering available:
+        coin = pair.split('/')[0]
 
-        https://www.freqtrade.io/en/latest/freqai-feature-engineering
+        if informative is None:
+            informative = self.dp.get_pair_dataframe(pair, tf)
 
-        :param df: strategy dataframe which will receive the targets
+        # first loop is automatically duplicating indicators for time periods
-        usage example: dataframe["&-target"] = dataframe["close"].shift(-1) / dataframe["close"]
+        for t in self.freqai_info["feature_parameters"]["indicator_periods_candles"]:
-        """
-        # For RL, there are no direct targets to set. This is filler (neutral)
-        # until the agent sends an action.
-        dataframe["&-action"] = 0
-```
 
-Most of the function remains the same as for typical Regressors, however, the function below shows how the strategy must pass the raw price data to the agent so that it has access to raw OHLCV in the training environment:
+            t = int(t)
+            informative[f"%-{coin}rsi-period_{t}"] = ta.RSI(informative, timeperiod=t)
+            informative[f"%-{coin}mfi-period_{t}"] = ta.MFI(informative, timeperiod=t)
+            informative[f"%-{coin}adx-period_{t}"] = ta.ADX(informative, window=t)
 
-```python
-    def feature_engineering_standard(self, dataframe, **kwargs):
         # The following features are necessary for RL models
-        dataframe[f"%-raw_close"] = dataframe["close"]
+        informative[f"%-{coin}raw_close"] = informative["close"]
-        dataframe[f"%-raw_open"] = dataframe["open"]
+        informative[f"%-{coin}raw_open"] = informative["open"]
-        dataframe[f"%-raw_high"] = dataframe["high"]
+        informative[f"%-{coin}raw_high"] = informative["high"]
-        dataframe[f"%-raw_low"] = dataframe["low"]
+        informative[f"%-{coin}raw_low"] = informative["low"]
+
+        indicators = [col for col in informative if col.startswith("%")]
+        # This loop duplicates and shifts all indicators to add a sense of recency to data
+        for n in range(self.freqai_info["feature_parameters"]["include_shifted_candles"] + 1):
+            if n == 0:
+                continue
+            informative_shift = informative[indicators].shift(n)
+            informative_shift = informative_shift.add_suffix("_shift-" + str(n))
+            informative = pd.concat((informative, informative_shift), axis=1)
+
+        df = merge_informative_pair(df, informative, self.config["timeframe"], tf, ffill=True)
+        skip_columns = [
+            (s + "_" + tf) for s in ["date", "open", "high", "low", "close", "volume"]
+        ]
+        df = df.drop(columns=skip_columns)
+
+        # Add generalized indicators here (because in live, it will call this
+        # function to populate indicators during training). Notice how we ensure not to
+        # add them multiple times
+        if set_generalized_indicators:
+
+            # For RL, there are no direct targets to set. This is filler (neutral)
+            # until the agent sends an action.
+            df["&-action"] = 0
+
+        return df
 ```
 
-Finally, there is no explicit "label" to make - instead it is necessary to assign the `&-action` column which will contain the agent's actions when accessed in `populate_entry/exit_trends()`. In the present example, the neutral action to 0. This value should align with the environment used. FreqAI provides two environments, both use 0 as the neutral action.
+Most of the function remains the same as for typical Regressors, however, the function above shows how the strategy must pass the raw price data to the agent so that it has access to raw OHLCV in the training environent:
+
+```python
+        # The following features are necessary for RL models
+        informative[f"%-{coin}raw_close"] = informative["close"]
+        informative[f"%-{coin}raw_open"] = informative["open"]
+        informative[f"%-{coin}raw_high"] = informative["high"]
+        informative[f"%-{coin}raw_low"] = informative["low"]
+```
+
+Finally, there is no explicit "label" to make - instead the you need to assign the `&-action` column which will contain the agent's actions when accessed in `populate_entry/exit_trends()`. In the present example, the user set the neutral action to 0. This value should align with the environment used. FreqAI provides two environments, both use 0 as the neutral action.
 
 After users realize there are no labels to set, they will soon understand that the agent is making its "own" entry and exit decisions. This makes strategy construction rather simple. The entry and exit signals come from the agent in the form of an integer - which are used directly to decide entries and exits in the strategy:
 
@@ -105,12 +111,11 @@ It is important to consider that `&-action` depends on which environment they ch
 
 ## Configuring the Reinforcement Learner
 
-In order to configure the `Reinforcement Learner` the following dictionary must exist in the `freqai` config:
+In order to configure the `Reinforcement Learner` the following dictionary to their `freqai` config:
 
 ```json
         "rl_config": {
             "train_cycles": 25,
-            "add_state_info": true,
             "max_trade_duration_candles": 300,
             "max_training_drawdown_pct": 0.02,
             "cpu_count": 8,
@@ -123,147 +128,75 @@ In order to configure the `Reinforcement Learner` the following dictionary must
         }
 ```
 
-Parameter details can be found [here](freqai-parameter-table.md), but in general the `train_cycles` decides how many times the agent should cycle through the candle data in its artificial environment to train weights in the model. `model_type` is a string which selects one of the available models in [stable_baselines](https://stable-baselines3.readthedocs.io/en/master/)(external link).
+Parameter details can be found [here](freqai-parameter-table.md), but in general the `train_cycles` decides how many times the agent should cycle through the candle data in its artificial environemtn to train weights in the model. `model_type` is a string which selects one of the available models in [stable_baselines](https://stable-baselines3.readthedocs.io/en/master/)(external link). 
 
-!!! Note
+## Creating the reward
-    If you would like to experiment with `continual_learning`, then you should set that value to `true` in the main `freqai` configuration dictionary. This will tell the Reinforcement Learning library to continue training new models from the final state of previous models, instead of retraining new models from scratch each time a retrain is initiated.
 
-!!! Note
+As users begin to modify the strategy and the prediction model, they will quickly realize some important differences between the Reinforcement Learner and the Regressors/Classifiers. Firstly, the strategy does not set a target value (no labels!). Instead, the user sets a `calculate_reward()` function inside their custom `ReinforcementLearner.py` file. A default `calculate_reward()` is provided inside `prediction_models/ReinforcementLearner.py` to give users the necessary building blocks to start their own models. It is inside the `calculate_reward()` where users express their creative theories about the market. For example, the user wants to reward their agent when it makes a winning trade, and penalize the agent when it makes a losing trade. Or perhaps, the user wishes to reward the agnet for entering trades, and penalize the agent for sitting in trades too long. Below we show examples of how these rewards are all calculated:
-    Remember that the general `model_training_parameters` dictionary should contain all the model hyperparameter customizations for the particular `model_type`. For example, `PPO` parameters can be found [here](https://stable-baselines3.readthedocs.io/en/master/modules/ppo.html).
-
-## Creating a custom reward function
-
-As you begin to modify the strategy and the prediction model, you will quickly realize some important differences between the Reinforcement Learner and the Regressors/Classifiers. Firstly, the strategy does not set a target value (no labels!). Instead, you set the `calculate_reward()` function inside the `MyRLEnv` class (see below). A default `calculate_reward()` is provided inside `prediction_models/ReinforcementLearner.py` to demonstrate the necessary building blocks for creating rewards, but users are encouraged to create their own custom reinforcement learning model class (see below) and save it to `user_data/freqaimodels`. It is inside the `calculate_reward()` where creative theories about the market can be expressed. For example, you can reward your agent when it makes a winning trade, and penalize the agent when it makes a losing trade. Or perhaps, you wish to reward the agent for entering trades, and penalize the agent for sitting in trades too long. Below we show examples of how these rewards are all calculated:
 
 ```python
-    from freqtrade.freqai.prediction_models.ReinforcementLearner import ReinforcementLearner
+    class MyRLEnv(Base5ActionRLEnv):
-    from freqtrade.freqai.RL.Base5ActionRLEnv import Actions, Base5ActionRLEnv, Positions
-
-
-    class MyCoolRLModel(ReinforcementLearner):
         """
-        User created RL prediction model.
+        User made custom environment. This class inherits from BaseEnvironment and gym.env.
-
+        Users can override any functions from those parent classes. Here is an example
-        Save this file to `freqtrade/user_data/freqaimodels`
+        of a user customized `calculate_reward()` function.
-
-        then use it with:
-
-        freqtrade trade --freqaimodel MyCoolRLModel --config config.json --strategy SomeCoolStrat
-
-        Here the users can override any of the functions
-        available in the `IFreqaiModel` inheritance tree. Most importantly for RL, this
-        is where the user overrides `MyRLEnv` (see below), to define custom
-        `calculate_reward()` function, or to override any other parts of the environment.
-
-        This class also allows users to override any other part of the IFreqaiModel tree.
-        For example, the user can override `def fit()` or `def train()` or `def predict()`
-        to take fine-tuned control over these processes.
-
-        Another common override may be `def data_cleaning_predict()` where the user can
-        take fine-tuned control over the data handling pipeline.
         """
-        class MyRLEnv(Base5ActionRLEnv):
+        def calculate_reward(self, action):
-            """
+            # first, penalize if the action is not valid
-            User made custom environment. This class inherits from BaseEnvironment and gym.env.
+            if not self._is_valid(action):
-            Users can override any functions from those parent classes. Here is an example
+                return -2
-            of a user customized `calculate_reward()` function.
+            pnl = self.get_unrealized_profit()
-            """
-            def calculate_reward(self, action: int) -> float:
-                # first, penalize if the action is not valid
-                if not self._is_valid(action):
-                    return -2
-                pnl = self.get_unrealized_profit()
 
-                factor = 100
+            factor = 100
-
+            # reward agent for entering trades
-                pair = self.pair.replace(':', '')
+            if action in (Actions.Long_enter.value, Actions.Short_enter.value) \
-
+                    and self._position == Positions.Neutral:
-                # you can use feature values from dataframe
+                return 25
-                # Assumes the shifted RSI indicator has been generated in the strategy.
+            # discourage agent from not entering trades
-                rsi_now = self.raw_features[f"%-rsi-period_10_shift-1_{pair}_"
+            if action == Actions.Neutral.value and self._position == Positions.Neutral:
-                                f"{self.config['timeframe']}"].iloc[self._current_tick]
+                return -1
-
+            max_trade_duration = self.rl_config.get('max_trade_duration_candles', 300)
-                # reward agent for entering trades
+            trade_duration = self._current_tick - self._last_trade_tick
-                if (action in (Actions.Long_enter.value, Actions.Short_enter.value)
+            if trade_duration <= max_trade_duration:
-                        and self._position == Positions.Neutral):
+                factor *= 1.5
-                    if rsi_now < 40:
+            elif trade_duration > max_trade_duration:
-                        factor = 40 / rsi_now
+                factor *= 0.5
-                    else:
+            # discourage sitting in position
-                        factor = 1
+            if self._position in (Positions.Short, Positions.Long) and \
-                    return 25 * factor
+               action == Actions.Neutral.value:
-
+                return -1 * trade_duration / max_trade_duration
-                # discourage agent from not entering trades
+            # close long
-                if action == Actions.Neutral.value and self._position == Positions.Neutral:
+            if action == Actions.Long_exit.value and self._position == Positions.Long:
-                    return -1
+                if pnl > self.profit_aim * self.rr:
-                max_trade_duration = self.rl_config.get('max_trade_duration_candles', 300)
+                    factor *= self.rl_config['model_reward_parameters'].get('win_reward_factor', 2)
-                trade_duration = self._current_tick - self._last_trade_tick
+                return float(pnl * factor)
-                if trade_duration <= max_trade_duration:
+            # close short
-                    factor *= 1.5
+            if action == Actions.Short_exit.value and self._position == Positions.Short:
-                elif trade_duration > max_trade_duration:
+                if pnl > self.profit_aim * self.rr:
-                    factor *= 0.5
+                    factor *= self.rl_config['model_reward_parameters'].get('win_reward_factor', 2)
-                # discourage sitting in position
+                return float(pnl * factor)
-                if self._position in (Positions.Short, Positions.Long) and \
+            return 0.
-                action == Actions.Neutral.value:
-                    return -1 * trade_duration / max_trade_duration
-                # close long
-                if action == Actions.Long_exit.value and self._position == Positions.Long:
-                    if pnl > self.profit_aim * self.rr:
-                        factor *= self.rl_config['model_reward_parameters'].get('win_reward_factor', 2)
-                    return float(pnl * factor)
-                # close short
-                if action == Actions.Short_exit.value and self._position == Positions.Short:
-                    if pnl > self.profit_aim * self.rr:
-                        factor *= self.rl_config['model_reward_parameters'].get('win_reward_factor', 2)
-                    return float(pnl * factor)
-                return 0.
 ```
 
+### Creating a custom agent
+
+Users can inherit from `stable_baselines3` and customize anything they wish about their agent. Doing this is for advanced users only, an example is presented in `freqai/RL/ReinforcementLearnerCustomAgent.py`
+
 ### Using Tensorboard
 
-Reinforcement Learning models benefit from tracking training metrics. FreqAI has integrated Tensorboard to allow users to track training and evaluation performance across all coins and across all retrainings. Tensorboard is activated via the following command:
+Reinforcement Learning models benefit from tracking training metrics. FreqAI has integrated Tensorboard to allow users to track training and evaluation performance across all coins and across all retrainings. To start, the user should ensure Tensorboard is installed on their computer:
+
+```bash
+pip3 install tensorboard
+```
+
+Next, the user can activate Tensorboard with the following command:
 
 ```bash
 cd freqtrade
 tensorboard --logdir user_data/models/unique-id
 ```
 
-where `unique-id` is the `identifier` set in the `freqai` configuration file. This command must be run in a separate shell to view the output in their browser at 127.0.0.1:6006 (6006 is the default port used by Tensorboard).
+where `unique-id` is the `identifier` set in the `freqai` configuration file. This command must be run in a separate shell if the user wishes to view the output in their browser at 127.0.0.1:6060 (6060 is the default port used by Tensorboard).
 
-![tensorboard](assets/tensorboard.jpg)
+![tensorboard](assets/tensorboard.png)
-
-
-### Custom logging
-
-FreqAI also provides a built in episodic summary logger called `self.tensorboard_log` for adding custom information to the Tensorboard log. By default, this function is already called once per step inside the environment to record the agent actions. All values accumulated for all steps in a single episode are reported at the conclusion of each episode, followed by a full reset of all metrics to 0 in preparation for the subsequent episode.
-
-
-`self.tensorboard_log` can also be used anywhere inside the environment, for example, it can be added to the `calculate_reward` function to collect more detailed information about how often various parts of the reward were called:
-
-```py
-        class MyRLEnv(Base5ActionRLEnv):
-            """
-            User made custom environment. This class inherits from BaseEnvironment and gym.env.
-            Users can override any functions from those parent classes. Here is an example
-            of a user customized `calculate_reward()` function.
-            """
-            def calculate_reward(self, action: int) -> float:
-                if not self._is_valid(action):
-                    self.tensorboard_log("invalid")
-                    return -2
-
-```
-
-!!! Note
-    The `self.tensorboard_log()` function is designed for tracking incremented objects only i.e. events, actions inside the training environment. If the event of interest is a float, the float can be passed as the second argument e.g. `self.tensorboard_log("float_metric1", 0.23)`. In this case the metric values are not incremented.
-
-### Choosing a base environment
-
-FreqAI provides three base environments, `Base3ActionRLEnvironment`, `Base4ActionEnvironment` and `Base5ActionEnvironment`. As the names imply, the environments are customized for agents that can select from 3, 4 or 5 actions. The `Base3ActionEnvironment` is the simplest, the agent can select from hold, long, or short. This environment can also be used for long-only bots (it automatically follows the `can_short` flag from the strategy), where long is the enter condition and short is the exit condition. Meanwhile, in the `Base4ActionEnvironment`, the agent can enter long, enter short, hold neutral, or exit position. Finally, in the `Base5ActionEnvironment`, the agent has the same actions as Base4, but instead of a single exit action, it separates exit long and exit short. The main changes stemming from the environment selection include:
-
-* the actions available in the `calculate_reward`
-* the actions consumed by the user strategy
-
-All of the FreqAI provided environments inherit from an action/position agnostic environment object called the `BaseEnvironment`, which contains all shared logic. The architecture is designed to be easily customized. The simplest customization is the `calculate_reward()` (see details [here](#creating-a-custom-reward-function)). However, the customizations can be further extended into any of the functions inside the environment. You can do this by simply overriding those functions inside your `MyRLEnv` in the prediction model file. Or for more advanced customizations, it is encouraged to create an entirely new environment inherited from `BaseEnvironment`.
-
-!!! Note
-    Only the `Base3ActionRLEnv` can do long-only training/trading (set the user strategy attribute `can_short = False`).

docs/freqai-running.md

@@ -67,29 +67,18 @@ Backtesting mode requires [downloading the necessary data](#downloading-data-to-
     *want* to retrain a new model with the same config file, you should simply change the `identifier`.
     This way, you can return to using any model you wish by simply specifying the `identifier`.
 
-!!! Note
-    Backtesting calls `set_freqai_targets()` one time for each backtest window (where the number of windows is the full backtest timerange divided by the `backtest_period_days` parameter). Doing this means that the targets simulate dry/live behavior without look ahead bias. However, the definition of the features in `feature_engineering_*()` is performed once on the entire backtest timerange. This means that you should be sure that features do look-ahead into the future.
-    More details about look-ahead bias can be found in [Common Mistakes](strategy-customization.md#common-mistakes-when-developing-strategies).
-
 ---
 
 ### Saving prediction data
 
 To allow for tweaking your strategy (**not** the features!), FreqAI will automatically save the predictions during backtesting so that they can be reused for future backtests and live runs using the same `identifier` model. This provides a performance enhancement geared towards enabling **high-level hyperopting** of entry/exit criteria.
 
-An additional directory called `backtesting_predictions`, which contains all the predictions stored in `hdf` format, will be created in the `unique-id` folder.
+An additional directory called `predictions`, which contains all the predictions stored in `hdf` format, will be created in the `unique-id` folder.
 
 To change your **features**, you **must** set a new `identifier` in the config to signal to FreqAI to train new models.
 
 To save the models generated during a particular backtest so that you can start a live deployment from one of them instead of training a new model, you must set `save_backtest_models` to `True` in the config.
 
-### Backtest live collected predictions
-
-FreqAI allow you to reuse live historic predictions through the backtest parameter `--freqai-backtest-live-models`. This can be useful when you want to reuse predictions generated in dry/run for comparison or other study.
-
-The `--timerange` parameter must not be informed, as it will be automatically calculated through the data in the historic predictions file.
-
-
 ### Downloading data to cover the full backtest period
 
 For live/dry deployments, FreqAI will download the necessary data automatically. However, to use backtesting functionality, you need to download the necessary data using `download-data` (details [here](data-download.md#data-downloading)). You need to pay careful attention to understanding how much *additional* data needs to be downloaded to ensure that there is a sufficient amount of training data *before* the start of the backtesting time range. The amount of additional data can be roughly estimated by moving the start date of the time range backwards by `train_period_days` and the `startup_candle_count` (see the [parameter table](freqai-parameter-table.md) for detailed descriptions of these parameters) from the beginning of the desired backtesting time range. 
@@ -120,7 +109,7 @@ In the presented example config, the user will only allow predictions on models
 
 Model training parameters are unique to the selected machine learning library. FreqAI allows you to set any parameter for any library using the `model_training_parameters` dictionary in the config. The example config (found in `config_examples/config_freqai.example.json`) shows some of the example parameters associated with `Catboost` and `LightGBM`, but you can add any parameters available in those libraries or any other machine learning library you choose to implement.
 
-Data split parameters are defined in `data_split_parameters` which can be any parameters associated with scikit-learn's `train_test_split()` function. `train_test_split()` has a parameters called `shuffle` which allows to shuffle the data or keep it unshuffled. This is particularly useful to avoid biasing training with temporally auto-correlated data. More details about these parameters can be found the [scikit-learn website](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html) (external website).
+Data split parameters are defined in `data_split_parameters` which can be any parameters associated with Scikit-learn's `train_test_split()` function. `train_test_split()` has a parameters called `shuffle` which allows to shuffle the data or keep it unshuffled. This is particularly useful to avoid biasing training with temporally auto-correlated data. More details about these parameters can be found the [Scikit-learn website](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html) (external website).
 
 The FreqAI specific parameter `label_period_candles` defines the offset (number of candles into the future) used for the `labels`. In the presented [example config](freqai-configuration.md#setting-up-the-configuration-file), the user is asking for `labels` that are 24 candles in the future.
 
@@ -128,9 +117,6 @@ The FreqAI specific parameter `label_period_candles` defines the offset (number
 
 You can choose to adopt a continual learning scheme by setting `"continual_learning": true` in the config. By enabling `continual_learning`, after training an initial model from scratch, subsequent trainings will start from the final model state of the preceding training. This gives the new model a "memory" of the previous state. By default, this is set to `False` which means that all new models are trained from scratch, without input from previous models.
 
-???+ danger "Continual learning enforces a constant parameter space"
-    Since `continual_learning` means that the model parameter space *cannot* change between trainings, `principal_component_analysis` is automatically disabled when `continual_learning` is enabled. Hint: PCA changes the parameter space and the number of features, learn more about PCA [here](freqai-feature-engineering.md#data-dimensionality-reduction-with-principal-component-analysis).
-
 ## Hyperopt
 
 You can hyperopt using the same command as for [typical Freqtrade hyperopt](hyperopt.md):
@@ -142,7 +128,7 @@ freqtrade hyperopt --hyperopt-loss SharpeHyperOptLoss --strategy FreqaiExampleSt
 `hyperopt` requires you to have the data pre-downloaded in the same fashion as if you were doing [backtesting](#backtesting). In addition, you must consider some restrictions when trying to hyperopt FreqAI strategies:
 
 - The `--analyze-per-epoch` hyperopt parameter is not compatible with FreqAI.
-- It's not possible to hyperopt indicators in the `feature_engineering_*()` and `set_freqai_targets()` functions. This means that you cannot optimize model parameters using hyperopt. Apart from this exception, it is possible to optimize all other [spaces](hyperopt.md#running-hyperopt-with-smaller-search-space).
+- It's not possible to hyperopt indicators in the `populate_any_indicators()` function. This means that you cannot optimize model parameters using hyperopt. Apart from this exception, it is possible to optimize all other [spaces](hyperopt.md#running-hyperopt-with-smaller-search-space).
 - The backtesting instructions also apply to hyperopt.
 
 The best method for combining hyperopt and FreqAI is to focus on hyperopting entry/exit thresholds/criteria. You need to focus on hyperopting parameters that are not used in your features. For example, you should not try to hyperopt rolling window lengths in the feature creation, or any part of the FreqAI config which changes predictions. In order to efficiently hyperopt the FreqAI strategy, FreqAI stores predictions as dataframes and reuses them. Hence the requirement to hyperopt entry/exit thresholds/criteria only.
@@ -156,15 +142,15 @@ dataframe['outlier'] = np.where(dataframe['DI_values'] > self.di_max.value/10, 1
 
 This specific hyperopt would help you understand the appropriate `DI_values` for your particular parameter space.
 
-## Using Tensorboard
+## Setting up a follower
 
-CatBoost models benefit from tracking training metrics via Tensorboard. You can take advantage of the FreqAI integration to track training and evaluation performance across all coins and across all retrainings. Tensorboard is activated via the following command:
+You can indicate to the bot that it should not train models, but instead should look for models trained by a leader with a specific `identifier` by defining:
 
-```bash
+```json
-cd freqtrade
+    "freqai": {
-tensorboard --logdir user_data/models/unique-id
+        "follow_mode": true,
+        "identifier": "example"
+    }
 ```
 
-where `unique-id` is the `identifier` set in the `freqai` configuration file. This command must be run in a separate shell if you wish to view the output in your browser at 127.0.0.1:6060 (6060 is the default port used by Tensorboard).
+In this example, the user has a leader bot with the `"identifier": "example"`. The leader bot is already running or is launched simultaneously with the follower. The follower will load models created by the leader and inference them to obtain predictions instead of training its own models.
-
-![tensorboard](assets/tensorboard.jpg)

docs/freqai.md

@@ -4,10 +4,7 @@
 
 ## Introduction
 
-FreqAI is a software designed to automate a variety of tasks associated with training a predictive machine learning model to generate market forecasts given a set of input signals. In general, FreqAI aims to be a sandbox for easily deploying robust machine learning libraries on real-time data ([details](#freqai-position-in-open-source-machine-learning-landscape)).
+FreqAI is a software designed to automate a variety of tasks associated with training a predictive machine learning model to generate market forecasts given a set of input features.
-
-!!! Note
-    FreqAI is, and always will be, a not-for-profit, open-source project. FreqAI does *not* have a crypto token, FreqAI does *not* sell signals, and FreqAI does not have a domain besides the present [freqtrade documentation](https://www.freqtrade.io/en/latest/freqai/).
 
 Features include:
 
@@ -22,7 +19,7 @@ Features include:
 * **Automatic data download** - Compute timeranges for data downloads and update historic data (in live deployments)
 * **Cleaning of incoming data** - Handle NaNs safely before training and model inferencing
 * **Dimensionality reduction** - Reduce the size of the training data via [Principal Component Analysis](freqai-feature-engineering.md#data-dimensionality-reduction-with-principal-component-analysis)
-* **Deploying bot fleets** - Set one bot to train models while a fleet of [consumers](producer-consumer.md) use signals.
+* **Deploying bot fleets** - Set one bot to train models while a fleet of [follower bots](freqai-running.md#setting-up-a-follower) inference the models and handle trades
 
 ## Quick start
 
@@ -71,32 +68,9 @@ pip install -r requirements-freqai.txt
 !!! Note
     Catboost will not be installed on arm devices (raspberry, Mac M1, ARM based VPS, ...), since it does not provide wheels for this platform.
 
-!!! Note "python 3.11"
-    Some dependencies (Catboost, Torch) currently don't support python 3.11. Freqtrade therefore only supports python 3.10 for these models/dependencies.
-    Tests involving these dependencies are skipped on 3.11.
-
 ### Usage with docker
 
-If you are using docker, a dedicated tag with FreqAI dependencies is available as `:freqai`. As such - you can replace the image line in your docker compose file with `image: freqtradeorg/freqtrade:develop_freqai`. This image contains the regular FreqAI dependencies. Similar to native installs, Catboost will not be available on ARM based devices.
+If you are using docker, a dedicated tag with FreqAI dependencies is available as `:freqai`. As such - you can replace the image line in your docker-compose file with `image: freqtradeorg/freqtrade:develop_freqai`. This image contains the regular FreqAI dependencies. Similar to native installs, Catboost will not be available on ARM based devices.
-
-### FreqAI position in open-source machine learning landscape
-
-Forecasting chaotic time-series based systems, such as equity/cryptocurrency markets, requires a broad set of tools geared toward testing a wide range of hypotheses. Fortunately, a recent maturation of robust machine learning libraries (e.g. `scikit-learn`) has opened up a wide range of research possibilities. Scientists from a diverse range of fields can now easily prototype their studies on an abundance of established machine learning algorithms. Similarly, these user-friendly libraries enable "citzen scientists" to use their basic Python skills for data exploration. However, leveraging these machine learning libraries on historical and live chaotic data sources can be logistically difficult and expensive. Additionally, robust data collection, storage, and handling presents a disparate challenge. [`FreqAI`](#freqai) aims to provide a generalized and extensible open-sourced framework geared toward live deployments of adaptive modeling for market forecasting. The `FreqAI` framework is effectively a sandbox for the rich world of open-source machine learning libraries. Inside the `FreqAI` sandbox, users find they can combine a wide variety of third-party libraries to test creative hypotheses on a free live 24/7 chaotic data source - cryptocurrency exchange data. 
-
-### Citing FreqAI
-
-FreqAI is [published in the Journal of Open Source Software](https://joss.theoj.org/papers/10.21105/joss.04864). If you find FreqAI useful in your research, please use the following citation:
-
-```bibtex
-@article{Caulk2022, 
-    doi = {10.21105/joss.04864},
-    url = {https://doi.org/10.21105/joss.04864},
-    year = {2022}, publisher = {The Open Journal},
-    volume = {7}, number = {80}, pages = {4864},
-    author = {Robert A. Caulk and Elin Törnquist and Matthias Voppichler and Andrew R. Lawless and Ryan McMullan and Wagner Costa Santos and Timothy C. Pogue and Johan van der Vlugt and Stefan P. Gehring and Pascal Schmidt},
-    title = {FreqAI: generalizing adaptive modeling for chaotic time-series market forecasts},
-    journal = {Journal of Open Source Software} } 
-```
 
 ## Common pitfalls
 
@@ -120,8 +94,6 @@ Code review and software architecture brainstorming:
 
 Software development:
 Wagner Costa @wagnercosta
-Emre Suzen @aemr3
-Timothy Pogue @wizrds
 
 Beta testing and bug reporting:
-Stefan Gehring @bloodhunter4rc, @longyu, Andrew Lawless @paranoidandy, Pascal Schmidt @smidelis, Ryan McMullan @smarmau, Juha Nykänen @suikula, Johan van der Vlugt @jooopiert, Richárd Józsa @richardjosza
+Stefan Gehring @bloodhunter4rc, @longyu, Andrew Lawless @paranoidandy, Pascal Schmidt @smidelis, Ryan McMullan @smarmau, Juha Nykänen @suikula, Johan van der Vlugt @jooopiert, Richárd Józsa @richardjosza, Timothy Pogue @wizrds

docs/hyperopt.md

@@ -50,7 +50,7 @@ usage: freqtrade hyperopt [-h] [-v] [--logfile FILE] [-V] [-c PATH] [-d PATH]
                           [--eps] [--dmmp] [--enable-protections]
                           [--dry-run-wallet DRY_RUN_WALLET]
                           [--timeframe-detail TIMEFRAME_DETAIL] [-e INT]
-                          [--spaces {all,buy,sell,roi,stoploss,trailing,protection,trades,default} [{all,buy,sell,roi,stoploss,trailing,protection,trades,default} ...]]
+                          [--spaces {all,buy,sell,roi,stoploss,trailing,protection,default} [{all,buy,sell,roi,stoploss,trailing,protection,default} ...]]
                           [--print-all] [--no-color] [--print-json] [-j JOBS]
                           [--random-state INT] [--min-trades INT]
                           [--hyperopt-loss NAME] [--disable-param-export]
@@ -96,7 +96,7 @@ optional arguments:
                         Specify detail timeframe for backtesting (`1m`, `5m`,
                         `30m`, `1h`, `1d`).
   -e INT, --epochs INT  Specify number of epochs (default: 100).
-  --spaces {all,buy,sell,roi,stoploss,trailing,protection,trades,default} [{all,buy,sell,roi,stoploss,trailing,protection,trades,default} ...]
+  --spaces {all,buy,sell,roi,stoploss,trailing,protection,default} [{all,buy,sell,roi,stoploss,trailing,protection,default} ...]
                         Specify which parameters to hyperopt. Space-separated
                         list.
   --print-all           Print all results, not only the best ones.
@@ -180,7 +180,6 @@ Rarely you may also need to create a [nested class](advanced-hyperopt.md#overrid
 * `generate_roi_table` - for custom ROI optimization (if you need the ranges for the values in the ROI table that differ from default or the number of entries (steps) in the ROI table which differs from the default 4 steps)
 * `stoploss_space` - for custom stoploss optimization (if you need the range for the stoploss parameter in the optimization hyperspace that differs from default)
 * `trailing_space` - for custom trailing stop optimization (if you need the ranges for the trailing stop parameters in the optimization hyperspace that differ from default)
-* `max_open_trades_space` - for custom max_open_trades optimization (if you need the ranges for the max_open_trades parameter in the optimization hyperspace that differ from default)
 
 !!! Tip "Quickly optimize ROI, stoploss and trailing stoploss"
     You can quickly optimize the spaces `roi`, `stoploss` and `trailing` without changing anything in your strategy.
@@ -366,7 +365,7 @@ class MyAwesomeStrategy(IStrategy):
     timeframe = '15m'
     minimal_roi = {
         "0":  0.10
-    }
+    },
     # Define the parameter spaces
     buy_ema_short = IntParameter(3, 50, default=5)
     buy_ema_long = IntParameter(15, 200, default=50)
@@ -401,7 +400,7 @@ class MyAwesomeStrategy(IStrategy):
         return dataframe
 
     def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
-        conditions = []
+          conditions = []
         conditions.append(qtpylib.crossed_above(
                 dataframe[f'ema_long_{self.buy_ema_long.value}'], dataframe[f'ema_short_{self.buy_ema_short.value}']
             ))
@@ -644,7 +643,6 @@ Legal values are:
 * `roi`: just optimize the minimal profit table for your strategy
 * `stoploss`: search for the best stoploss value
 * `trailing`: search for the best trailing stop values
-* `trades`: search for the best max open trades values
 * `protection`: search for the best protection parameters (read the [protections section](#optimizing-protections) on how to properly define these)
 * `default`: `all` except `trailing` and `protection`
 * space-separated list of any of the above values for example `--spaces roi stoploss`
@@ -918,5 +916,5 @@ Once the optimized strategy has been implemented into your strategy, you should
 To achieve same the results (number of trades, their durations, profit, etc.) as during Hyperopt, please use the same configuration and parameters (timerange, timeframe, ...) used for hyperopt `--dmmp`/`--disable-max-market-positions` and `--eps`/`--enable-position-stacking` for Backtesting.
 
 Should results not match, please double-check to make sure you transferred all conditions correctly.
-Pay special care to the stoploss, max_open_trades and trailing stoploss parameters, as these are often set in configuration files, which override changes to the strategy.
+Pay special care to the stoploss (and trailing stoploss) parameters, as these are often set in configuration files, which override changes to the strategy.
-You should also carefully review the log of your backtest to ensure that there were no parameters inadvertently set by the configuration (like `stoploss`, `max_open_trades` or `trailing_stop`).
+You should also carefully review the log of your backtest to ensure that there were no parameters inadvertently set by the configuration (like `stoploss` or `trailing_stop`).

docs/includes/pairlists.md

@@ -23,7 +23,6 @@ You may also use something like `.*DOWN/BTC` or `.*UP/BTC` to exclude leveraged
 * [`StaticPairList`](#static-pair-list) (default, if not configured differently)
 * [`VolumePairList`](#volume-pair-list)
 * [`ProducerPairList`](#producerpairlist)
-* [`RemotePairList`](#remotepairlist)
 * [`AgeFilter`](#agefilter)
 * [`OffsetFilter`](#offsetfilter)
 * [`PerformanceFilter`](#performancefilter)
@@ -174,48 +173,6 @@ You can limit the length of the pairlist with the optional parameter `number_ass
     `ProducerPairList` can also be used multiple times in sequence, combining the pairs from multiple producers.
     Obviously in complex such configurations, the Producer may not provide data for all pairs, so the strategy must be fit for this.
 
-#### RemotePairList
-
-It allows the user to fetch a pairlist from a remote server or a locally stored json file within the freqtrade directory, enabling dynamic updates and customization of the trading pairlist.
-
-The RemotePairList is defined in the pairlists section of the configuration settings. It uses the following configuration options:
-
-```json
-"pairlists": [
-    {
-        "method": "RemotePairList",
-        "pairlist_url": "https://example.com/pairlist",
-        "number_assets": 10,
-        "refresh_period": 1800,
-        "keep_pairlist_on_failure": true,
-        "read_timeout": 60,
-        "bearer_token": "my-bearer-token"
-    }
-]
-```
-
-The `pairlist_url` option specifies the URL of the remote server where the pairlist is located, or the path to a local file (if file:/// is prepended). This allows the user to use either a remote server or a local file as the source for the pairlist.
-
-The user is responsible for providing a server or local file that returns a JSON object with the following structure:
-
-```json
-{
-    "pairs": ["XRP/USDT", "ETH/USDT", "LTC/USDT"],
-    "refresh_period": 1800,
-}
-```
-
-The `pairs` property should contain a list of strings with the trading pairs to be used by the bot. The `refresh_period` property is optional and specifies the number of seconds that the pairlist should be cached before being refreshed.
-
-The optional `keep_pairlist_on_failure` specifies whether the previous received pairlist should be used if the remote server is not reachable or returns an error. The default value is true.
-
-The optional `read_timeout` specifies the maximum amount of time (in seconds) to wait for a response from the remote source, The default value is 60.
-
-The optional `bearer_token` will be included in the requests Authorization Header.
-
-!!! Note
-    In case of a server error the last received pairlist will be kept if `keep_pairlist_on_failure` is set to true, when set to false a empty pairlist is returned.
-
 #### AgeFilter
 
 Removes pairs that have been listed on the exchange for less than `min_days_listed` days (defaults to `10`) or more than `max_days_listed` days (defaults `None` mean infinity).
@@ -311,7 +268,7 @@ This option is disabled by default, and will only apply if set to > 0.
 The `max_value` setting removes pairs where the minimum value change is above a specified value.
 This is useful when an exchange has unbalanced limits. For example, if step-size = 1 (so you can only buy 1, or 2, or 3, but not 1.1 Coins) - and the price is pretty high (like 20\$) as the coin has risen sharply since the last limit adaption.
 As a result of the above, you can only buy for 20\$, or 40\$ - but not for 25\$.
-On exchanges that deduct fees from the receiving currency (e.g. binance) - this can result in high value coins / amounts that are unsellable as the amount is slightly below the limit.
+On exchanges that deduct fees from the receiving currency (e.g. FTX) - this can result in high value coins / amounts that are unsellable as the amount is slightly below the limit.
 
 The `low_price_ratio` setting removes pairs where a raise of 1 price unit (pip) is above the `low_price_ratio` ratio.
 This option is disabled by default, and will only apply if set to > 0.
@@ -329,18 +286,6 @@ Min price precision for SHITCOIN/BTC is 8 decimals. If its price is 0.00000011 -
 
 Shuffles (randomizes) pairs in the pairlist. It can be used for preventing the bot from trading some of the pairs more frequently then others when you want all pairs be treated with the same priority.
 
-By default, ShuffleFilter will shuffle pairs once per candle.
-To shuffle on every iteration, set `"shuffle_frequency"` to `"iteration"` instead of  the default of `"candle"`.
-
-``` json
-    {
-        "method": "ShuffleFilter", 
-        "shuffle_frequency": "candle",
-        "seed": 42
-    }
-
-```
-
 !!! Tip
     You may set the `seed` value for this Pairlist to obtain reproducible results, which can be useful for repeated backtesting sessions. If `seed` is not set, the pairs are shuffled in the non-repeatable random order. ShuffleFilter will automatically detect runmodes and apply the `seed` only for backtesting modes - if a `seed` value is set.
 

docs/includes/protections.md

@@ -149,7 +149,7 @@ The below example assumes a timeframe of 1 hour:
 * Locks each pair after selling for an additional 5 candles (`CooldownPeriod`), giving other pairs a chance to get filled.
 * Stops trading for 4 hours (`4 * 1h candles`) if the last 2 days (`48 * 1h candles`) had 20 trades, which caused a max-drawdown of more than 20%. (`MaxDrawdown`).
 * Stops trading if more than 4 stoploss occur for all pairs within a 1 day (`24 * 1h candles`) limit (`StoplossGuard`).
-* Locks all pairs that had 2 Trades within the last 6 hours (`6 * 1h candles`) with a combined profit ratio of below 0.02 (<2%) (`LowProfitPairs`).
+* Locks all pairs that had 4 Trades within the last 6 hours (`6 * 1h candles`) with a combined profit ratio of below 0.02 (<2%) (`LowProfitPairs`).
 * Locks all pairs for 2 candles that had a profit of below 0.01 (<1%) within the last 24h (`24 * 1h candles`), a minimum of 4 trades.
 
 ``` python

docs/index.md

@@ -1,7 +1,6 @@
 ![freqtrade](assets/freqtrade_poweredby.svg)
 
 [![Freqtrade CI](https://github.com/freqtrade/freqtrade/workflows/Freqtrade%20CI/badge.svg)](https://github.com/freqtrade/freqtrade/actions/)
-[![DOI](https://joss.theoj.org/papers/10.21105/joss.04864/status.svg)](https://doi.org/10.21105/joss.04864)
 [![Coverage Status](https://coveralls.io/repos/github/freqtrade/freqtrade/badge.svg?branch=develop&service=github)](https://coveralls.io/github/freqtrade/freqtrade?branch=develop)
 [![Maintainability](https://api.codeclimate.com/v1/badges/5737e6d668200b7518ff/maintainability)](https://codeclimate.com/github/freqtrade/freqtrade/maintainability)
 
@@ -33,7 +32,7 @@ Freqtrade is a free and open source crypto trading bot written in Python. It is
 - Run: Test your strategy with simulated money (Dry-Run mode) or deploy it with real money (Live-Trade mode).
 - Run using Edge (optional module): The concept is to find the best historical [trade expectancy](edge.md#expectancy) by markets based on variation of the stop-loss and then allow/reject markets to trade. The sizing of the trade is based on a risk of a percentage of your capital.
 - Control/Monitor: Use Telegram or a WebUI (start/stop the bot, show profit/loss, daily summary, current open trades results, etc.).
-- Analyze: Further analysis can be performed on either Backtesting data or Freqtrade trading history (SQL database), including automated standard plots, and methods to load the data into [interactive environments](data-analysis.md).
+- Analyse: Further analysis can be performed on either Backtesting data or Freqtrade trading history (SQL database), including automated standard plots, and methods to load the data into [interactive environments](data-analysis.md).
 
 ## Supported exchange marketplaces
 
@@ -41,6 +40,7 @@ Please read the [exchange specific notes](exchanges.md) to learn about eventual,
 
 - [X] [Binance](https://www.binance.com/)
 - [X] [Bittrex](https://bittrex.com/)
+- [X] [FTX](https://ftx.com/#a=2258149)
 - [X] [Gate.io](https://www.gate.io/ref/6266643)
 - [X] [Huobi](http://huobi.com/)
 - [X] [Kraken](https://kraken.com/)
@@ -51,8 +51,7 @@ Please read the [exchange specific notes](exchanges.md) to learn about eventual,
 
 - [X] [Binance](https://www.binance.com/)
 - [X] [Gate.io](https://www.gate.io/ref/6266643)
-- [X] [OKX](https://okx.com/)
+- [X] [OKX](https://okx.com/).
-- [X] [Bybit](https://bybit.com/)
 
 Please make sure to read the [exchange specific notes](exchanges.md), as well as the [trading with leverage](leverage.md) documentation before diving in.
 

docs/installation.md

@@ -30,12 +30,6 @@ The easiest way to install and run Freqtrade is to clone the bot Github reposito
 !!! Warning "Up-to-date clock"
     The clock on the system running the bot must be accurate, synchronized to a NTP server frequently enough to avoid problems with communication to the exchanges.
 
-!!! Error "Running setup.py install for gym did not run successfully."
-    If you get an error related with gym we suggest you to downgrade setuptools it to version 65.5.0 you can do it with the following command:
-    ```bash
-    pip install setuptools==65.5.0
-    ```
-
 ------
 
 ## Requirements
@@ -290,8 +284,10 @@ cd freqtrade
 
 #### Freqtrade install: Conda Environment
 
+Prepare conda-freqtrade environment, using file `environment.yml`, which exist in main freqtrade directory
+
 ```bash
-conda create --name freqtrade python=3.10
+conda env create -n freqtrade-conda -f environment.yml
 ```
 
 !!! Note "Creating Conda Environment"
@@ -300,9 +296,12 @@ conda create --name freqtrade python=3.10
     ```bash
     # choose your own packages
     conda env create -n [name of the environment] [python version] [packages]
+
+    # point to file with packages
+    conda env create -n [name of the environment] -f [file]
     ```
 
-#### Enter/exit freqtrade environment
+#### Enter/exit freqtrade-conda environment
 
 To check available environments, type
 
@@ -314,7 +313,7 @@ Enter installed environment
 
 ```bash
 # enter conda environment
-conda activate freqtrade
+conda activate freqtrade-conda
 
 # exit conda environment - don't do it now
 conda deactivate
@@ -324,7 +323,6 @@ Install last python dependencies with pip
 
 ```bash
 python3 -m pip install --upgrade pip
-python3 -m pip install -r requirements.txt
 python3 -m pip install -e .
 ```
 
@@ -332,7 +330,7 @@ Patch conda libta-lib (Linux only)
 
 ```bash
 # Ensure that the environment is active!
-conda activate freqtrade
+conda activate freqtrade-conda
 
 cd build_helpers
 bash install_ta-lib.sh ${CONDA_PREFIX} nosudo
@@ -351,8 +349,8 @@ conda env list
 # activate base environment
 conda activate
 
-# activate freqtrade environment
+# activate freqtrade-conda environment
-conda activate freqtrade
+conda activate freqtrade-conda
 
 #deactivate any conda environments
 conda deactivate                              

docs/leverage.md

@@ -67,6 +67,8 @@ You will also have to pick a "margin mode" (explanation below) - with freqtrade
 Freqtrade follows the [ccxt naming conventions for futures](https://docs.ccxt.com/en/latest/manual.html?#perpetual-swap-perpetual-future).
 A futures pair will therefore have the naming of `base/quote:settle` (e.g. `ETH/USDT:USDT`).
 
+Binance is currently still an exception to this naming scheme, where pairs are named `ETH/USDT` also for futures markets, but will be aligned as soon as CCXT is ready.
+
 ### Margin mode
 
 On top of `trading_mode` - you will also have to configure your `margin_mode`.
@@ -90,8 +92,6 @@ One account is used to share collateral between markets (trading pairs). Margin
 "margin_mode": "cross"
 ```
 
-Please read the [exchange specific notes](exchanges.md) for exchanges that support this mode and how they differ.
-
 ## Set leverage to use
 
 Different strategies and risk profiles will require different levels of leverage.

docs/overrides/main.html

@@ -11,6 +11,9 @@
   {% endif %}
   <div class="md-sidebar md-sidebar--primary" data-md-component="sidebar" data-md-type="navigation" {{ hidden }}>
     <div class="md-sidebar__scrollwrap">
+      <div id="widget-wrapper">
+
+      </div>
       <div class="md-sidebar__inner">
         {% include "partials/nav.html" %}
       </div>
@@ -41,4 +44,25 @@
     <script src="https://code.jquery.com/jquery-3.4.1.min.js"
       integrity="sha256-CSXorXvZcTkaix6Yvo6HppcZGetbYMGWSFlBw8HfCJo=" crossorigin="anonymous"></script>
 
+    <!-- Load binance SDK -->
+    <script async defer src="https://public.bnbstatic.com/static/js/broker-sdk/broker-sdk@1.0.0.min.js"></script>
+
+    <script>
+      window.onload = function () {
+        var sidebar = document.getElementById('widget-wrapper')
+        var newDiv = document.createElement("div");
+        newDiv.id = "widget";
+        try {
+          sidebar.prepend(newDiv);
+
+          window.binanceBrokerPortalSdk.initBrokerSDK('#widget', {
+            apiHost: 'https://www.binance.com',
+            brokerId: 'R4BD3S82',
+            slideTime: 4e4,
+          });
+        } catch(err) {
+          console.log(err)
+        }
+      }
+    </script>
 {% endblock %}

docs/producer-consumer.md

@@ -21,7 +21,6 @@ Enable subscribing to an instance by adding the `external_message_consumer` sect
                 "name": "default", // This can be any name you'd like, default is "default"
                 "host": "127.0.0.1", // The host from your producer's api_server config
                 "port": 8080, // The port from your producer's api_server config
-                "secure": false, // Use a secure websockets connection, default false
                 "ws_token": "sercet_Ws_t0ken" // The ws_token from your producer's api_server config
             }
         ],
@@ -42,14 +41,13 @@ Enable subscribing to an instance by adding the `external_message_consumer` sect
 | `producers` | **Required.** List of producers <br> **Datatype:** Array.
 | `producers.name` | **Required.** Name of this producer. This name must be used in calls to `get_producer_pairs()` and `get_producer_df()` if more than one producer is used.<br> **Datatype:** string
 | `producers.host` | **Required.** The hostname or IP address from your producer.<br> **Datatype:** string
-| `producers.port` | **Required.** The port matching the above host.<br>*Defaults to `8080`.*<br> **Datatype:** Integer
+| `producers.port` | **Required.** The port matching the above host.<br> **Datatype:** string
-| `producers.secure` | **Optional.**  Use ssl in websockets connection. Default False.<br> **Datatype:** string
 | `producers.ws_token` | **Required.**  `ws_token` as configured on the producer.<br> **Datatype:** string
 | | **Optional settings**
 | `wait_timeout` | Timeout until we ping again if no message is received. <br>*Defaults to `300`.*<br> **Datatype:** Integer - in seconds.
-| `ping_timeout` | Ping timeout <br>*Defaults to `10`.*<br> **Datatype:** Integer - in seconds.
+| `wait_timeout` | Ping timeout <br>*Defaults to `10`.*<br> **Datatype:** Integer - in seconds.
 | `sleep_time` | Sleep time before retrying to connect.<br>*Defaults to `10`.*<br> **Datatype:** Integer - in seconds.
-| `remove_entry_exit_signals` | Remove signal columns from the dataframe (set them to 0) on dataframe receipt.<br>*Defaults to `False`.*<br> **Datatype:** Boolean.
+| `remove_entry_exit_signals` | Remove signal columns from the dataframe (set them to 0) on dataframe receipt.<br>*Defaults to `10`.*<br> **Datatype:** Integer - in seconds.
 | `message_size_limit` | Size limit per message<br>*Defaults to `8`.*<br> **Datatype:** Integer - Megabytes.
 
 Instead of (or as well as) calculating indicators in `populate_indicators()` the follower instance listens on the connection to a producer instance's messages (or multiple producer instances in advanced configurations) and requests the producer's most recently analyzed dataframes for each pair in the active whitelist.

docs/requirements-docs.txt

@@ -1,6 +1,6 @@
 markdown==3.3.7
-mkdocs==1.4.2
+mkdocs==1.4.0
-mkdocs-material==9.1.6
+mkdocs-material==8.5.6
 mdx_truly_sane_lists==1.3
-pymdown-extensions==9.11
+pymdown-extensions==9.6
 jinja2==3.1.2

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.
 
@@ -160,7 +163,7 @@ python3 scripts/rest_client.py --config rest_config.json <command> [optional par
 | `strategy <strategy>` | Get specific Strategy content. **Alpha**
 | `available_pairs` | List available backtest data. **Alpha**
 | `version` | Show version.
-| `sysinfo` | Show information about the system load.
+| `sysinfo` | Show informations about the system load.
 | `health` | Show bot health (last bot loop).
 
 !!! Warning "Alpha status"
@@ -189,11 +192,6 @@ blacklist
 
         :param add: List of coins to add (example: "BNB/BTC")
 
-cancel_open_order
-	Cancel open order for trade.
-
-        :param trade_id: Cancels open orders for this trade.
-
 count
 	Return the amount of open trades.
 
@@ -276,6 +274,7 @@ reload_config
 	Reload configuration.
 
 show_config
+
         Returns part of the configuration, relevant for trading operations.
 
 start
@@ -321,7 +320,6 @@ version
 whitelist
 	Show the current whitelist.
 
-
 ```
 
 ### Message WebSocket
@@ -391,44 +389,6 @@ Now anytime those types of RPC messages are sent in the bot, you will receive th
 }
 ```
 
-#### Reverse Proxy setup
-
-When using [Nginx](https://nginx.org/en/docs/), the following configuration is required for WebSockets to work (Note this configuration is incomplete, it's missing some information and can not be used as is):
-
-Please make sure to replace `<freqtrade_listen_ip>` (and the subsequent port) with the IP and Port matching your configuration/setup.
-
-```
-http {
-    map $http_upgrade $connection_upgrade {
-        default upgrade;
-        '' close;
-    }
-
-    #...
-
-    server {
-        #...
-
-        location / {
-            proxy_http_version 1.1;
-            proxy_pass http://<freqtrade_listen_ip>:8080;
-            proxy_set_header Upgrade $http_upgrade;
-            proxy_set_header Connection $connection_upgrade;
-            proxy_set_header Host $host;
-        }
-    }
-}
-```
-
-To properly configure your reverse proxy (securely), please consult it's documentation for proxying websockets.
-
-- **Traefik**: Traefik supports websockets out of the box, see the [documentation](https://doc.traefik.io/traefik/)
-- **Caddy**: Caddy v2 supports websockets out of the box, see the [documentation](https://caddyserver.com/docs/v2-upgrade#proxy)
-
-!!! Tip "SSL certificates"
-    You can use tools like certbot to setup ssl certificates to access your bot's UI through encrypted connection by using any fo the above reverse proxies.
-    While this will protect your data in transit, we do not recommend to run the freqtrade API outside of your private network (VPN, SSH tunnel).
-
 ### OpenAPI interface
 
 To enable the builtin openAPI interface (Swagger UI), specify `"enable_openapi": true` in the api_server configuration.

docs/sql_cheatsheet.md

@@ -13,12 +13,12 @@ Feel free to use a visual Database editor like SqliteBrowser if you feel more co
 sudo apt-get install sqlite3
 ```
 
-### Using sqlite3 via docker
+### Using sqlite3 via docker-compose
 
 The freqtrade docker image does contain sqlite3, so you can edit the database without having to install anything on the host system.
 
 ``` bash
-docker compose exec freqtrade /bin/bash
+docker-compose exec freqtrade /bin/bash
 sqlite3 <database-file>.sqlite
 ```
 

docs/stoploss.md

@@ -23,22 +23,10 @@ These modes can be configured with these values:
     'stoploss_on_exchange_limit_ratio': 0.99
 ```
 
-Stoploss on exchange is only supported for the following exchanges, and not all exchanges support both stop-limit and stop-market.
+!!! Note
-The Order-type will be ignored if only one mode is available.
+    Stoploss on exchange is only supported for Binance (stop-loss-limit), Huobi (stop-limit), Kraken (stop-loss-market, stop-loss-limit), FTX (stop limit and stop-market) Gateio (stop-limit), and Kucoin (stop-limit and stop-market) as of now.  
-
+    <ins>Do not set too low/tight stoploss value if using stop loss on exchange!</ins>  
-| Exchange | stop-loss type |
+    If set to low/tight then you have greater risk of missing fill on the order and stoploss will not work.
-|----------|-------------|
-| Binance  | limit |
-| Binance Futures  | market, limit |
-| Huobi    | limit |
-| kraken   | market, limit |
-| Gate     | limit |
-| Okx      | limit |
-| Kucoin   | stop-limit, stop-market|
-
-!!! Note "Tight stoploss"
-    <ins>Do not set too low/tight stoploss value when using stop loss on exchange!</ins>  
-    If set to low/tight you will have greater risk of missing fill on the order and stoploss will not work.
 
 ### stoploss_on_exchange and stoploss_on_exchange_limit_ratio
 
@@ -64,18 +52,6 @@ The bot cannot do these every 5 seconds (at each iteration), otherwise it would
 So this parameter will tell the bot how often it should update the stoploss order. The default value is 60 (1 minute).
 This same logic will reapply a stoploss order on the exchange should you cancel it accidentally.
 
-### stoploss_price_type
-
-!!! Warning "Only applies to futures"
-    `stoploss_price_type` only applies to futures markets (on exchanges where it's available).
-    Freqtrade will perform a validation of this setting on startup, failing to start if an invalid setting for your exchange has been selected.
-    Supported price types are gonna differs between each exchanges. Please check with your exchange on which price types it supports.
-
-Stoploss on exchange on futures markets can trigger on different price types.
-The naming for these prices in exchange terminology often varies, but is usually something around "last" (or "contract price" ), "mark" and "index".
-
-Acceptable values for this setting are `"last"`, `"mark"` and `"index"` - which freqtrade will transfer automatically to the corresponding API type, and place the [stoploss on exchange](#stoploss_on_exchange-and-stoploss_on_exchange_limit_ratio) order correspondingly.
-
 ### force_exit
 
 `force_exit` is an optional value, which defaults to the same value as `exit` and is used when sending a `/forceexit` command from Telegram or from the Rest API.
@@ -111,7 +87,7 @@ At this stage the bot contains the following stoploss support modes:
 2. Trailing stop loss.
 3. Trailing stop loss, custom positive loss.
 4. Trailing stop loss only once the trade has reached a certain offset.
-5. [Custom stoploss function](strategy-callbacks.md#custom-stoploss)
+5. [Custom stoploss function](strategy-advanced.md#custom-stoploss)
 
 ### Static Stop Loss
 

docs/strategy-advanced.md

@@ -80,7 +80,7 @@ class AwesomeStrategy(IStrategy):
 ## Enter Tag
 
 When your strategy has multiple buy signals, you can name the signal that triggered.
-Then you can access your buy signal on `custom_exit`
+Then you can access you buy signal on `custom_exit`
 
 ```python
 def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:

docs/strategy-callbacks.md

@@ -51,8 +51,7 @@ During hyperopt, this runs only once at startup.
 
 ## Bot loop start
 
-A simple callback which is called once at the start of every bot throttling iteration in dry/live mode (roughly every 5
+A simple callback which is called once at the start of every bot throttling iteration (roughly every 5 seconds, unless configured differently).
-seconds, unless configured differently) or once per candle in backtest/hyperopt mode.
 This can be used to perform calculations which are pair independent (apply to all pairs), loading of external data, etc.
 
 ``` python
@@ -62,12 +61,11 @@ class AwesomeStrategy(IStrategy):
 
     # ... populate_* methods
 
-    def bot_loop_start(self, current_time: datetime, **kwargs) -> None:
+    def bot_loop_start(self, **kwargs) -> None:
         """
         Called at the start of the bot iteration (one loop).
         Might be used to perform pair-independent tasks
         (e.g. gather some remote resource for comparison)
-        :param current_time: datetime object, containing the current datetime
         :param **kwargs: Ensure to keep this here so updates to this won't break your strategy.
         """
         if self.config['runmode'].value in ('live', 'dry_run'):
@@ -161,7 +159,6 @@ The stoploss price can only ever move upwards - if the stoploss value returned f
 
 The method must return a stoploss value (float / number) as a percentage of the current price.
 E.g. If the `current_rate` is 200 USD, then returning `0.02` will set the stoploss price 2% lower, at 196 USD.
-During backtesting, `current_rate` (and `current_profit`) are provided against the candle's high (or low for short trades) - while the resulting stoploss is evaluated against the candle's low (or high for short trades).
 
 The absolute value of the return value is used (the sign is ignored), so returning `0.05` or `-0.05` have the same result, a stoploss 5% below the current price.
 
@@ -318,11 +315,11 @@ class AwesomeStrategy(IStrategy):
 
         # evaluate highest to lowest, so that highest possible stop is used
         if current_profit > 0.40:
-            return stoploss_from_open(0.25, current_profit, is_short=trade.is_short, leverage=trade.leverage)
+            return stoploss_from_open(0.25, current_profit, is_short=trade.is_short)
         elif current_profit > 0.25:
-            return stoploss_from_open(0.15, current_profit, is_short=trade.is_short, leverage=trade.leverage)
+            return stoploss_from_open(0.15, current_profit, is_short=trade.is_short)
         elif current_profit > 0.20:
-            return stoploss_from_open(0.07, current_profit, is_short=trade.is_short, leverage=trade.leverage)
+            return stoploss_from_open(0.07, current_profit, is_short=trade.is_short)
 
         # return maximum stoploss value, keeping current stoploss price unchanged
         return 1
@@ -661,7 +658,6 @@ Position adjustments will always be applied in the direction of the trade, so a
 
 !!! Warning "Backtesting"
     During backtesting this callback is called for each candle in `timeframe` or `timeframe_detail`, so run-time performance will be affected.
-    This can also cause deviating results between live and backtesting, since backtesting can adjust the trade only once per candle, whereas live could adjust the trade multiple times per candle.
 
 ``` python
 from freqtrade.persistence import Trade
@@ -776,7 +772,7 @@ class DigDeeperStrategy(IStrategy):
     * Sell 100@10\$ -> Avg price: 8.5\$, realized profit 150\$, 17.65%
     * Buy 150@11\$ -> Avg price: 10\$, realized profit 150\$, 17.65%
     * Sell 100@12\$ -> Avg price: 10\$, total realized profit 350\$, 20%
-    * Sell 150@14\$ -> Avg price: 10\$, total realized profit 950\$, 40%  <- *This will be the last "Exit" message*
+    * Sell 150@14\$ -> Avg price: 10\$, total realized profit 950\$, 40%
 
     The total profit for this trade was 950$ on a 3350$ investment (`100@8$ + 100@9$ + 150@11$`). As such - the final relative profit is 28.35% (`950 / 3350`).
 
@@ -830,7 +826,7 @@ class AwesomeStrategy(IStrategy):
 
         """
         # Limit orders to use and follow SMA200 as price target for the first 10 minutes since entry trigger for BTC/USDT pair.
-        if pair == 'BTC/USDT' and entry_tag == 'long_sma200' and side == 'long' and (current_time - timedelta(minutes=10)) > trade.open_date_utc:
+        if pair == 'BTC/USDT' and entry_tag == 'long_sma200' and side == 'long' and (current_time - timedelta(minutes=10) > trade.open_date_utc:
             # just cancel the order if it has been filled more than half of the amount
             if order.filled > order.remaining:
                 return None

docs/strategy-customization.md

@@ -363,9 +363,9 @@ class AwesomeStrategy(IStrategy):
     timeframe = "1d"
     timeframe_mins = timeframe_to_minutes(timeframe)
     minimal_roi = {
-        "0": 0.05,                      # 5% for the first 3 candles
+        "0": 0.05,                             # 5% for the first 3 candles
-        str(timeframe_mins * 3): 0.02,  # 2% after 3 candles
+        str(timeframe_mins * 3)): 0.02,  # 2% after 3 candles
-        str(timeframe_mins * 6): 0.01,  # 1% After 6 candles
+        str(timeframe_mins * 6)): 0.01,  # 1% After 6 candles
     }
 ```
 
@@ -446,17 +446,15 @@ A full sample can be found [in the DataProvider section](#complete-data-provider
 
 ??? Note "Alternative candle types"
     Informative_pairs can also provide a 3rd tuple element defining the candle type explicitly.
-    Availability of alternative candle-types will depend on the trading-mode and the exchange. 
+    Availability of alternative candle-types will depend on the trading-mode and the exchange. Details about this can be found in the exchange documentation.
-    In general, spot pairs cannot be used in futures markets, and futures candles can't be used as informative pairs for spot bots.
-    Details about this may vary, if they do, this can be found in the exchange documentation.
 
     ``` python
     def informative_pairs(self):
         return [
-            ("ETH/USDT", "5m", ""),   # Uses default candletype, depends on trading_mode (recommended)
+            ("ETH/USDT", "5m", ""),   # Uses default candletype, depends on trading_mode 
-            ("ETH/USDT", "5m", "spot"),   # Forces usage of spot candles (only valid for bots running on spot markets).
+            ("ETH/USDT", "5m", "spot"),   # Forces usage of spot candles
-            ("BTC/TUSD", "15m", "futures"),  # Uses futures candles (only bots with `trading_mode=futures`)
+            ("BTC/TUSD", "15m", "futures"),  # Uses futures candles
-            ("BTC/TUSD", "15m", "mark"),  # Uses mark candles (only bots with `trading_mode=futures`)
+            ("BTC/TUSD", "15m", "mark"),  # Uses mark candles
         ]
     ```
 ***
@@ -657,13 +655,13 @@ This is where calling `self.dp.current_whitelist()` comes in handy.
 # fetch live / historical candle (OHLCV) data for the first informative pair
 inf_pair, inf_timeframe = self.informative_pairs()[0]
 informative = self.dp.get_pair_dataframe(pair=inf_pair,
-                                         timeframe=inf_timeframe)
+                                            timeframe=inf_timeframe)
 ```
 
 !!! Warning "Warning about backtesting"
-    In backtesting, `dp.get_pair_dataframe()` behavior differs depending on where it's called.
+    Be careful when using dataprovider in backtesting. `historic_ohlcv()` (and `get_pair_dataframe()`
-    Within `populate_*()` methods, `dp.get_pair_dataframe()` returns the full timerange. Please make sure to not "look into the future" to avoid surprises when running in dry/live mode.
+    for the backtesting runmode) provides the full time-range in one go,
-    Within [callbacks](strategy-callbacks.md), you'll get the full timerange up to the current (simulated) candle.
+    so please be aware of it and make sure to not "look into the future" to avoid surprises when running in dry/live mode.
 
 ### *get_analyzed_dataframe(pair, timeframe)*
 
@@ -672,13 +670,13 @@ It can also be used in specific callbacks to get the signal that caused the acti
 
 ``` python
 # fetch current dataframe
-dataframe, last_updated = self.dp.get_analyzed_dataframe(pair=metadata['pair'],
+if self.dp.runmode.value in ('live', 'dry_run'):
-                                                         timeframe=self.timeframe)
+    dataframe, last_updated = self.dp.get_analyzed_dataframe(pair=metadata['pair'],
+                                                                timeframe=self.timeframe)
 ```
 
 !!! Note "No data available"
     Returns an empty dataframe if the requested pair was not cached.
-    You can check for this with `if dataframe.empty:` and handle this case accordingly.
     This should not happen when using whitelisted pairs.
 
 ### *orderbook(pair, maximum)*
@@ -725,7 +723,7 @@ if self.dp.runmode.value in ('live', 'dry_run'):
 
 !!! Warning
     Although the ticker data structure is a part of the ccxt Unified Interface, the values returned by this method can
-    vary for different exchanges. For instance, many exchanges do not return `vwap` values, some exchanges
+    vary for different exchanges. For instance, many exchanges do not return `vwap` values, the FTX exchange
     does not always fills in the `last` field (so it can be None), etc. So you need to carefully verify the ticker
     data returned from the exchange and add appropriate error handling / defaults.
 
@@ -881,7 +879,7 @@ All columns of the informative dataframe will be available on the returning data
 
 ### *stoploss_from_open()*
 
-Stoploss values returned from `custom_stoploss` must specify a percentage relative to `current_rate`, but sometimes you may want to specify a stoploss relative to the entry point instead. `stoploss_from_open()` is a helper function to calculate a stoploss value that can be returned from `custom_stoploss` which will be equivalent to the desired trade profit above the entry point.
+Stoploss values returned from `custom_stoploss` must specify a percentage relative to `current_rate`, but sometimes you may want to specify a stoploss relative to the open price instead. `stoploss_from_open()` is a helper function to calculate a stoploss value that can be returned from `custom_stoploss` which will be equivalent to the desired percentage above the open price.
 
 ??? Example "Returning a stoploss relative to the open price from the custom stoploss function"
 
@@ -889,8 +887,6 @@ Stoploss values returned from `custom_stoploss` must specify a percentage relati
 
     If we want a stop price at 7% above the open price we can call `stoploss_from_open(0.07, current_profit, False)` which will return `0.1157024793`.  11.57% below $121 is $107, which is the same as 7% above $100.
 
-    This function will consider leverage - so at 10x leverage, the actual stoploss would be 0.7% above $100 (0.7% * 10x = 7%).
-
 
     ``` python
 
@@ -909,7 +905,7 @@ Stoploss values returned from `custom_stoploss` must specify a percentage relati
 
             # once the profit has risen above 10%, keep the stoploss at 7% above the open price
             if current_profit > 0.10:
-                return stoploss_from_open(0.07, current_profit, is_short=trade.is_short, leverage=trade.leverage)
+                return stoploss_from_open(0.07, current_profit, is_short=trade.is_short)
 
             return 1
 
@@ -956,14 +952,12 @@ In some situations it may be confusing to deal with stops relative to current ra
 
 ## Additional data (Wallets)
 
-The strategy provides access to the `wallets` object. This contains the current balances on the exchange.
+The strategy provides access to the `Wallets` object. This contains the current balances on the exchange.
 
-!!! Note "Backtesting / Hyperopt"
+!!! Note
-    Wallets behaves differently depending on the function it's called.
+    Wallets is not available during backtesting / hyperopt.
-    Within `populate_*()` methods, it'll return the full wallet as configured.
-    Within [callbacks](strategy-callbacks.md), you'll get the wallet state corresponding to the actual simulated wallet at that point in the simulation process.
 
-Please always check if `wallets` is available to avoid failures during backtesting.
+Please always check if `Wallets` is available to avoid failures during backtesting.
 
 ``` python
 if self.wallets:
@@ -993,18 +987,38 @@ from freqtrade.persistence import Trade
 The following example queries for the current pair and trades from today, however other filters can easily be added.
 
 ``` python
-trades = Trade.get_trades_proxy(pair=metadata['pair'],
+if self.config['runmode'].value in ('live', 'dry_run'):
-                                open_date=datetime.now(timezone.utc) - timedelta(days=1),
+    trades = Trade.get_trades([Trade.pair == metadata['pair'],
-                                is_open=False,
+                               Trade.open_date > datetime.utcnow() - timedelta(days=1),
-            ]).order_by(Trade.close_date).all()
+                               Trade.is_open.is_(False),
-# Summarize profit for this pair.
+                ]).order_by(Trade.close_date).all()
-curdayprofit = sum(trade.close_profit for trade in trades)
+    # Summarize profit for this pair.
+    curdayprofit = sum(trade.close_profit for trade in trades)
 ```
 
-For a full list of available methods, please consult the [Trade object](trade-object.md) documentation.
+Get amount of stake_currency currently invested in Trades:
+
+``` python
+if self.config['runmode'].value in ('live', 'dry_run'):
+    total_stakes = Trade.total_open_trades_stakes()
+```
+
+Retrieve performance per pair.
+Returns a List of dicts per pair.
+
+``` python
+if self.config['runmode'].value in ('live', 'dry_run'):
+    performance = Trade.get_overall_performance()
+```
+
+Sample return value: ETH/BTC had 5 trades, with a total profit of 1.5% (ratio of 0.015).
+
+``` json
+{"pair": "ETH/BTC", "profit": 0.015, "count": 5}
+```
 
 !!! Warning
-    Trade history is not available in `populate_*` methods during backtesting or hyperopt, and will result in empty results.
+    Trade history is not available during backtesting or hyperopt.
 
 ## Prevent trades from happening for a specific pair
 
@@ -1040,10 +1054,11 @@ from datetime import timedelta, datetime, timezone
 
 # Within populate indicators (or populate_buy):
 if self.config['runmode'].value in ('live', 'dry_run'):
-    # fetch closed trades for the last 2 days
+   # fetch closed trades for the last 2 days
-    trades = Trade.get_trades_proxy(
+    trades = Trade.get_trades([Trade.pair == metadata['pair'],
-        pair=metadata['pair'], is_open=False, 
+                               Trade.open_date > datetime.utcnow() - timedelta(days=2),
-        open_date=datetime.now(timezone.utc) - timedelta(days=2))
+                               Trade.is_open.is_(False),
+                ]).all()
     # Analyze the conditions you'd like to lock the pair .... will probably be different for every strategy
     sumprofit = sum(trade.close_profit for trade in trades)
     if sumprofit < 0:

docs/strategy_analysis_example.md

@@ -2,37 +2,12 @@
 
 Debugging a strategy can be time-consuming. Freqtrade offers helper functions to visualize raw data.
 The following assumes you work with SampleStrategy, data for 5m timeframe from Binance and have downloaded them into the data directory in the default location.
-Please follow the [documentation](https://www.freqtrade.io/en/stable/data-download/) for more details.
 
 ## Setup
 
-### Change Working directory to repository root
-
 
 ```python
-import os
 from pathlib import Path
-
-# Change directory
-# Modify this cell to insure that the output shows the correct path.
-# Define all paths relative to the project root shown in the cell output
-project_root = "somedir/freqtrade"
-i=0
-try:
-    os.chdirdir(project_root)
-    assert Path('LICENSE').is_file()
-except:
-    while i<4 and (not Path('LICENSE').is_file()):
-        os.chdir(Path(Path.cwd(), '../'))
-        i+=1
-    project_root = Path.cwd()
-print(Path.cwd())
-```
-
-### Configure Freqtrade environment
-
-
-```python
 from freqtrade.configuration import Configuration
 
 # Customize these according to your needs.
@@ -40,14 +15,14 @@ from freqtrade.configuration import Configuration
 # Initialize empty configuration object
 config = Configuration.from_files([])
 # Optionally (recommended), use existing configuration file
-# config = Configuration.from_files(["user_data/config.json"])
+# config = Configuration.from_files(["config.json"])
 
 # Define some constants
 config["timeframe"] = "5m"
 # Name of the strategy class
 config["strategy"] = "SampleStrategy"
 # Location of the data
-data_location = config["datadir"]
+data_location = config['datadir']
 # Pair to analyze - Only use one pair here
 pair = "BTC/USDT"
 ```
@@ -61,12 +36,12 @@ from freqtrade.enums import CandleType
 candles = load_pair_history(datadir=data_location,
                             timeframe=config["timeframe"],
                             pair=pair,
-                            data_format = "json",  # Make sure to update this to your data
+                            data_format = "hdf5",
                             candle_type=CandleType.SPOT,
                             )
 
 # Confirm success
-print(f"Loaded {len(candles)} rows of data for {pair} from {data_location}")
+print("Loaded " + str(len(candles)) + f" rows of data for {pair} from {data_location}")
 candles.head()
 ```
 
@@ -80,7 +55,6 @@ from freqtrade.resolvers import StrategyResolver
 from freqtrade.data.dataprovider import DataProvider
 strategy = StrategyResolver.load_strategy(config)
 strategy.dp = DataProvider(config, None, None)
-strategy.ft_bot_start()
 
 # Generate buy/sell signals using strategy
 df = strategy.analyze_ticker(candles, {'pair': pair})
@@ -258,7 +232,7 @@ graph = generate_candlestick_graph(pair=pair,
 # Show graph inline
 # graph.show()
 
-# Render graph in a separate window
+# Render graph in a seperate window
 graph.show(renderer="browser")
 
 ```

docs/strategy_migration.md

@@ -43,25 +43,19 @@ Note : `forcesell`, `forcebuy`, `emergencysell` are changed to `force_exit`, `fo
   * `order_time_in_force` buy -> entry, sell -> exit.
   * `order_types` buy -> entry, sell -> exit.
   * `unfilledtimeout` buy -> entry, sell -> exit.
-  * `ignore_buying_expired_candle_after` -> moved to root level instead of "ask_strategy/exit_pricing"
 * Terminology changes
   * Sell reasons changed to reflect the new naming of "exit" instead of sells. Be careful in your strategy if you're using `exit_reason` checks and eventually update your strategy.
     * `sell_signal` -> `exit_signal`
     * `custom_sell` -> `custom_exit`
     * `force_sell` -> `force_exit`
     * `emergency_sell` -> `emergency_exit`
-  * Order pricing
-    * `bid_strategy` -> `entry_pricing`
-    * `ask_strategy` -> `exit_pricing`
-    * `ask_last_balance` -> `price_last_balance`
-    * `bid_last_balance` -> `price_last_balance`
   * Webhook terminology changed from "sell" to "exit", and from "buy" to entry
-    * `webhookbuy` -> `entry`
+    * `webhookbuy` -> `webhookentry`
-    * `webhookbuyfill` -> `entry_fill`
+    * `webhookbuyfill` -> `webhookentryfill`
-    * `webhookbuycancel` -> `entry_cancel`
+    * `webhookbuycancel` -> `webhookentrycancel`
-    * `webhooksell` -> `exit`
+    * `webhooksell` -> `webhookexit`
-    * `webhooksellfill` -> `exit_fill`
+    * `webhooksellfill` -> `webhookexitfill`
-    * `webhooksellcancel` -> `exit_cancel`
+    * `webhooksellcancel` -> `webhookexitcancel`
   * Telegram notification settings
     * `buy` -> `entry`
     * `buy_fill` -> `entry_fill`
@@ -449,7 +443,6 @@ Please refer to the [pricing documentation](configuration.md#prices-used-for-ord
         "use_order_book": true,
         "order_book_top": 1,
         "bid_last_balance": 0.0
-        "ignore_buying_expired_candle_after": 120
     }
 }
 ```
@@ -473,258 +466,6 @@ after:
         "use_order_book": true,
         "order_book_top": 1,
         "price_last_balance": 0.0
-    },
+    }
-    "ignore_buying_expired_candle_after": 120
 }
 ```
-
-## FreqAI strategy
-
-The `populate_any_indicators()` method has been split into `feature_engineering_expand_all()`, `feature_engineering_expand_basic()`, `feature_engineering_standard()` and`set_freqai_targets()`.
-
-For each new function, the pair (and timeframe where necessary) will be automatically added to the column.
-As such, the definition of features becomes much simpler with the new logic.
-
-For a full explanation of each method, please go to the corresponding [freqAI documentation page](freqai-feature-engineering.md#defining-the-features)
-
-``` python linenums="1" hl_lines="12-37 39-42 63-65 67-75"
-
-def populate_any_indicators(
-        self, pair, df, tf, informative=None, set_generalized_indicators=False
-    ):
-
-        if informative is None:
-            informative = self.dp.get_pair_dataframe(pair, tf)
-
-        # first loop is automatically duplicating indicators for time periods
-        for t in self.freqai_info["feature_parameters"]["indicator_periods_candles"]:
-
-            t = int(t)
-            informative[f"%-{pair}rsi-period_{t}"] = ta.RSI(informative, timeperiod=t)
-            informative[f"%-{pair}mfi-period_{t}"] = ta.MFI(informative, timeperiod=t)
-            informative[f"%-{pair}adx-period_{t}"] = ta.ADX(informative, timeperiod=t)
-            informative[f"%-{pair}sma-period_{t}"] = ta.SMA(informative, timeperiod=t)
-            informative[f"%-{pair}ema-period_{t}"] = ta.EMA(informative, timeperiod=t)
-
-            bollinger = qtpylib.bollinger_bands(
-                qtpylib.typical_price(informative), window=t, stds=2.2
-            )
-            informative[f"{pair}bb_lowerband-period_{t}"] = bollinger["lower"]
-            informative[f"{pair}bb_middleband-period_{t}"] = bollinger["mid"]
-            informative[f"{pair}bb_upperband-period_{t}"] = bollinger["upper"]
-
-            informative[f"%-{pair}bb_width-period_{t}"] = (
-                informative[f"{pair}bb_upperband-period_{t}"]
-                - informative[f"{pair}bb_lowerband-period_{t}"]
-            ) / informative[f"{pair}bb_middleband-period_{t}"]
-            informative[f"%-{pair}close-bb_lower-period_{t}"] = (
-                informative["close"] / informative[f"{pair}bb_lowerband-period_{t}"]
-            )
-
-            informative[f"%-{pair}roc-period_{t}"] = ta.ROC(informative, timeperiod=t)
-
-            informative[f"%-{pair}relative_volume-period_{t}"] = (
-                informative["volume"] / informative["volume"].rolling(t).mean()
-            ) # (1)
-
-        informative[f"%-{pair}pct-change"] = informative["close"].pct_change()
-        informative[f"%-{pair}raw_volume"] = informative["volume"]
-        informative[f"%-{pair}raw_price"] = informative["close"]
-        # (2)
-
-        indicators = [col for col in informative if col.startswith("%")]
-        # This loop duplicates and shifts all indicators to add a sense of recency to data
-        for n in range(self.freqai_info["feature_parameters"]["include_shifted_candles"] + 1):
-            if n == 0:
-                continue
-            informative_shift = informative[indicators].shift(n)
-            informative_shift = informative_shift.add_suffix("_shift-" + str(n))
-            informative = pd.concat((informative, informative_shift), axis=1)
-
-        df = merge_informative_pair(df, informative, self.config["timeframe"], tf, ffill=True)
-        skip_columns = [
-            (s + "_" + tf) for s in ["date", "open", "high", "low", "close", "volume"]
-        ]
-        df = df.drop(columns=skip_columns)
-
-        # Add generalized indicators here (because in live, it will call this
-        # function to populate indicators during training). Notice how we ensure not to
-        # add them multiple times
-        if set_generalized_indicators:
-            df["%-day_of_week"] = (df["date"].dt.dayofweek + 1) / 7
-            df["%-hour_of_day"] = (df["date"].dt.hour + 1) / 25
-            # (3)
-
-            # user adds targets here by prepending them with &- (see convention below)
-            df["&-s_close"] = (
-                df["close"]
-                .shift(-self.freqai_info["feature_parameters"]["label_period_candles"])
-                .rolling(self.freqai_info["feature_parameters"]["label_period_candles"])
-                .mean()
-                / df["close"]
-                - 1
-            )  # (4)
-
-        return df
-```
-
-1. Features - Move to `feature_engineering_expand_all`
-2. Basic features, not expanded across `include_periods_candles` - move to`feature_engineering_expand_basic()`.
-3. Standard features which should not be expanded - move to `feature_engineering_standard()`.
-4. Targets - Move this part to `set_freqai_targets()`.
-
-### freqai - feature engineering expand all
-
-Features will now expand automatically. As such, the expansion loops, as well as the `{pair}` / `{timeframe}` parts will need to be removed.
-
-``` python linenums="1"
-    def feature_engineering_expand_all(self, dataframe, period, **kwargs):
-        """
-        *Only functional with FreqAI enabled strategies*
-        This function will automatically expand the defined features on the config defined
-        `indicator_periods_candles`, `include_timeframes`, `include_shifted_candles`, and
-        `include_corr_pairs`. In other words, a single feature defined in this function
-        will automatically expand to a total of
-        `indicator_periods_candles` * `include_timeframes` * `include_shifted_candles` *
-        `include_corr_pairs` numbers of features added to the model.
-
-        All features must be prepended with `%` to be recognized by FreqAI internals.
-
-        More details on how these config defined parameters accelerate feature engineering
-        in the documentation at:
-
-        https://www.freqtrade.io/en/latest/freqai-parameter-table/#feature-parameters
-
-        https://www.freqtrade.io/en/latest/freqai-feature-engineering/#defining-the-features
-
-        :param df: strategy dataframe which will receive the features
-        :param period: period of the indicator - usage example:
-        dataframe["%-ema-period"] = ta.EMA(dataframe, timeperiod=period)
-        """
-
-        dataframe["%-rsi-period"] = ta.RSI(dataframe, timeperiod=period)
-        dataframe["%-mfi-period"] = ta.MFI(dataframe, timeperiod=period)
-        dataframe["%-adx-period"] = ta.ADX(dataframe, timeperiod=period)
-        dataframe["%-sma-period"] = ta.SMA(dataframe, timeperiod=period)
-        dataframe["%-ema-period"] = ta.EMA(dataframe, timeperiod=period)
-
-        bollinger = qtpylib.bollinger_bands(
-            qtpylib.typical_price(dataframe), window=period, stds=2.2
-        )
-        dataframe["bb_lowerband-period"] = bollinger["lower"]
-        dataframe["bb_middleband-period"] = bollinger["mid"]
-        dataframe["bb_upperband-period"] = bollinger["upper"]
-
-        dataframe["%-bb_width-period"] = (
-            dataframe["bb_upperband-period"]
-            - dataframe["bb_lowerband-period"]
-        ) / dataframe["bb_middleband-period"]
-        dataframe["%-close-bb_lower-period"] = (
-            dataframe["close"] / dataframe["bb_lowerband-period"]
-        )
-
-        dataframe["%-roc-period"] = ta.ROC(dataframe, timeperiod=period)
-
-        dataframe["%-relative_volume-period"] = (
-            dataframe["volume"] / dataframe["volume"].rolling(period).mean()
-        )
-
-        return dataframe
-
-```
-
-### Freqai - feature engineering basic
-
-Basic features. Make sure to remove the `{pair}` part from your features.
-
-``` python linenums="1"
-    def feature_engineering_expand_basic(self, dataframe, **kwargs):
-        """
-        *Only functional with FreqAI enabled strategies*
-        This function will automatically expand the defined features on the config defined
-        `include_timeframes`, `include_shifted_candles`, and `include_corr_pairs`.
-        In other words, a single feature defined in this function
-        will automatically expand to a total of
-        `include_timeframes` * `include_shifted_candles` * `include_corr_pairs`
-        numbers of features added to the model.
-
-        Features defined here will *not* be automatically duplicated on user defined
-        `indicator_periods_candles`
-
-        All features must be prepended with `%` to be recognized by FreqAI internals.
-
-        More details on how these config defined parameters accelerate feature engineering
-        in the documentation at:
-
-        https://www.freqtrade.io/en/latest/freqai-parameter-table/#feature-parameters
-
-        https://www.freqtrade.io/en/latest/freqai-feature-engineering/#defining-the-features
-
-        :param df: strategy dataframe which will receive the features
-        dataframe["%-pct-change"] = dataframe["close"].pct_change()
-        dataframe["%-ema-200"] = ta.EMA(dataframe, timeperiod=200)
-        """
-        dataframe["%-pct-change"] = dataframe["close"].pct_change()
-        dataframe["%-raw_volume"] = dataframe["volume"]
-        dataframe["%-raw_price"] = dataframe["close"]
-        return dataframe
-```
-
-### FreqAI - feature engineering standard
-
-``` python linenums="1"
-    def feature_engineering_standard(self, dataframe, **kwargs):
-        """
-        *Only functional with FreqAI enabled strategies*
-        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 created by all other
-        freqai_feature_engineering_* functions.
-
-        This function is a good place to do custom exotic feature extractions (e.g. tsfresh).
-        This function is a good place for any feature that should not be auto-expanded upon
-        (e.g. day of the week).
-
-        All features must be prepended with `%` to be recognized by FreqAI internals.
-
-        More details about feature engineering available:
-
-        https://www.freqtrade.io/en/latest/freqai-feature-engineering
-
-        :param df: strategy dataframe which will receive the features
-        usage example: dataframe["%-day_of_week"] = (dataframe["date"].dt.dayofweek + 1) / 7
-        """
-        dataframe["%-day_of_week"] = dataframe["date"].dt.dayofweek
-        dataframe["%-hour_of_day"] = dataframe["date"].dt.hour
-        return dataframe
-```
-
-### FreqAI - set Targets
-
-Targets now get their own, dedicated method.
-
-``` python linenums="1"
-    def set_freqai_targets(self, dataframe, **kwargs):
-        """
-        *Only functional with FreqAI enabled strategies*
-        Required function to set the targets for the model.
-        All targets must be prepended with `&` to be recognized by the FreqAI internals.
-
-        More details about feature engineering available:
-
-        https://www.freqtrade.io/en/latest/freqai-feature-engineering
-
-        :param df: strategy dataframe which will receive the targets
-        usage example: dataframe["&-target"] = dataframe["close"].shift(-1) / dataframe["close"]
-        """
-        dataframe["&-s_close"] = (
-            dataframe["close"]
-            .shift(-self.freqai_info["feature_parameters"]["label_period_candles"])
-            .rolling(self.freqai_info["feature_parameters"]["label_period_candles"])
-            .mean()
-            / dataframe["close"]
-            - 1
-            )
-
-        return dataframe
-```

docs/stylesheets/ft.extra.css

@@ -11,3 +11,18 @@
 .rst-versions .rst-other-versions {
     color: white;
 }
+
+
+#widget-wrapper {
+    height: calc(220px * 0.5625 + 18px);
+    width: 220px;
+    margin: 0 auto 16px auto;
+    border-style: solid;
+    border-color: var(--md-code-bg-color);
+    border-width: 1px;
+    border-radius: 5px;
+}
+
+@media screen and (max-width: calc(76.25em - 1px)) {
+    #widget-wrapper { display: none; }
+}

docs/telegram-usage.md

@@ -77,7 +77,6 @@ Example configuration showing the different settings:
     "enabled": true,
     "token": "your_telegram_token",
     "chat_id": "your_telegram_chat_id",
-    "allow_custom_messages": true,
     "notification_settings": {
         "status": "silent",
         "warning": "on",
@@ -116,7 +115,6 @@ Example configuration showing the different settings:
 `show_candle` - show candle values as part of entry/exit messages. Only possible values are `"ohlc"` or `"off"`.
 
 `balance_dust_level` will define what the `/balance` command takes as "dust" - Currencies with a balance below this will be shown.
-`allow_custom_messages` completely disable strategy messages.
 `reload` allows you to disable reload-buttons on selected messages.
 
 ## Create a custom keyboard (command shortcut buttons)
@@ -152,7 +150,7 @@ You can create your own keyboard in `config.json`:
 !!! Note "Supported Commands"
     Only the following commands are allowed. Command arguments are not supported!
 
-    `/start`, `/stop`, `/status`, `/status table`, `/trades`, `/profit`, `/performance`, `/daily`, `/stats`, `/count`, `/locks`, `/balance`, `/stopentry`, `/reload_config`, `/show_config`, `/logs`, `/whitelist`, `/blacklist`, `/edge`, `/help`, `/version`, `/marketdir`
+    `/start`, `/stop`, `/status`, `/status table`, `/trades`, `/profit`, `/performance`, `/daily`, `/stats`, `/count`, `/locks`, `/balance`, `/stopentry`, `/reload_config`, `/show_config`, `/logs`, `/whitelist`, `/blacklist`, `/edge`, `/help`, `/version`
 
 ## Telegram commands
 
@@ -162,34 +160,26 @@ official commands. You can ask at any moment for help with `/help`.
 
 |  Command | Description |
 |----------|-------------|
-| **System commands**
 | `/start` | Starts the trader
 | `/stop` | Stops the trader
 | `/stopbuy | /stopentry` | Stops the trader from opening new trades. Gracefully closes open trades according to their rules.
 | `/reload_config` | Reloads the configuration file
 | `/show_config` | Shows part of the current configuration with relevant settings to operation
 | `/logs [limit]` | Show last log messages.
-| `/help` | Show help message
-| `/version` | Show version
-| **Status** |
 | `/status` | Lists all open trades
 | `/status <trade_id>` | Lists one or more specific trade. Separate multiple <trade_id> with a blank space.
 | `/status table` | List all open trades in a table format. Pending buy orders are marked with an asterisk (*) Pending sell orders are marked with a double asterisk (**)
 | `/trades [limit]` | List all recently closed trades in a table format.
+| `/delete <trade_id>` | Delete a specific trade from the Database. Tries to close open orders. Requires manual handling of this trade on the exchange.
 | `/count` | Displays number of trades used and available
 | `/locks` | Show currently locked pairs.
 | `/unlock <pair or lock_id>` | Remove the lock for this pair (or for this lock id).
-| `/marketdir [long | short | even | none]` | Updates the user managed variable that represents the current market direction. If no direction is provided, the currently set direction will be displayed.
+| `/profit [<n>]` | Display a summary of your profit/loss from close trades and some stats about your performance, over the last n days (all trades by default)
-| **Modify Trade states** |
 | `/forceexit <trade_id> | /fx <tradeid>` | Instantly exits the given trade  (Ignoring `minimum_roi`).
 | `/forceexit all | /fx all` | Instantly exits all open trades (Ignoring `minimum_roi`).
 | `/fx` | alias for `/forceexit`
 | `/forcelong <pair> [rate]` | Instantly buys the given pair. Rate is optional and only applies to limit orders. (`force_entry_enable` must be set to True)
 | `/forceshort <pair> [rate]` | Instantly shorts the given pair. Rate is optional and only applies to limit orders. This will only work on non-spot markets. (`force_entry_enable` must be set to True)
-| `/delete <trade_id>` | Delete a specific trade from the Database. Tries to close open orders. Requires manual handling of this trade on the exchange.
-| `/cancel_open_order <trade_id> | /coo <trade_id>` | Cancel an open order for a trade.
-| **Metrics** |
-| `/profit [<n>]` | Display a summary of your profit/loss from close trades and some stats about your performance, over the last n days (all trades by default)
 | `/performance` | Show performance of each finished trade grouped by pair
 | `/balance` | Show account balance per currency
 | `/daily <n>` | Shows profit or loss per day, over the last n days (n defaults to 7)
@@ -201,7 +191,8 @@ official commands. You can ask at any moment for help with `/help`.
 | `/whitelist [sorted] [baseonly]` | Show the current whitelist. Optionally display in alphabetical order and/or with just the base currency of each pairing.
 | `/blacklist [pair]` | Show the current blacklist, or adds a pair to the blacklist.
 | `/edge` | Show validated pairs by Edge if it is enabled.
-
+| `/help` | Show help message
+| `/version` | Show version
 
 ## Telegram commands in action
 
@@ -243,7 +234,7 @@ Enter Tag is configurable via Strategy.
 > **Enter Tag:** Awesome Long Signal
 > **Open Rate:** `0.00007489`
 > **Current Rate:** `0.00007489`
-> **Unrealized Profit:** `12.95%`
+> **Current Profit:** `12.95%`
 > **Stoploss:** `0.00007389 (-0.02%)`
 
 ### /status table
@@ -279,7 +270,6 @@ Return a summary of your profit/loss and performance.
 >   ∙ `33.095 EUR`
 >
 > **Total Trade Count:** `138`
-> **Bot started:** `2022-07-11 18:40:44`
 > **First Trade opened:** `3 days ago`
 > **Latest Trade opened:** `2 minutes ago`
 > **Avg. Duration:** `2:33:45`
@@ -293,7 +283,6 @@ The relative profit of `15.2 Σ%` is be based on the starting capital - so in th
 Starting capital is either taken from the `available_capital` setting, or calculated by using current wallet size - profits.
 Profit Factor is calculated as gross profits / gross losses - and should serve as an overall metric for the strategy.
 Max drawdown corresponds to the backtesting metric `Absolute Drawdown (Account)` - calculated as `(Absolute Drawdown) / (DrawdownHigh + startingBalance)`.
-Bot started date will refer to the date the bot was first started. For older bots, this will default to the first trade's open date.
 
 ### /forceexit <trade_id>
 
@@ -419,27 +408,3 @@ ARDR/ETH   0.366667      0.143059       -0.01
 ### /version
 
 > **Version:** `0.14.3`
-
-### /marketdir
-
-If a market direction is provided the command updates the user managed variable that represents the current market direction.
-This variable is not set to any valid market direction on bot startup and must be set by the user. The example below is for `/marketdir long`:
-
-```
-Successfully updated marketdirection from none to long.
-```
-
-If no market direction is provided the command outputs the currently set market directions. The example below is for `/marketdir`:
-
-```
-Currently set marketdirection: even
-```
-
-You can use the market direction in your strategy via `self.market_direction`.
-
-!!! Warning "Bot restarts"
-    Please note that the market direction is not persisted, and will be reset after a bot restart/reload.
-
-!!! Danger "Backtesting"
-    As this value/variable is intended to be changed manually in dry/live trading.
-    Strategies using `market_direction` will probably not produce reliable, reproducible results (changes to this variable will not be reflected for backtesting). Use at your own risk.

docs/trade-object.md

@@ -1,148 +0,0 @@
-# Trade Object
-
-## Trade
-
-A position freqtrade enters is stored in a `Trade` object - which is persisted to the database.
-It's a core concept of freqtrade - and something you'll come across in many sections of the documentation, which will most likely point you to this location.
-
-It will be passed to the strategy in many [strategy callbacks](strategy-callbacks.md). The object passed to the strategy cannot be modified directly. Indirect modifications may occur based on callback results.
-
-## Trade - Available attributes
-
-The following attributes / properties are available for each individual trade - and can be used with `trade.<property>` (e.g. `trade.pair`).
-
-|  Attribute | DataType | Description |
-|------------|-------------|-------------|
-`pair`| string | Pair of this trade
-`is_open`| boolean | Is the trade currently open, or has it been concluded
-`open_rate`| float | Rate this trade was entered at (Avg. entry rate in case of trade-adjustments)
-`close_rate`| float | Close rate - only set when is_open = False
-`stake_amount`| float | Amount in Stake (or Quote) currency.
-`amount`| float | Amount in Asset / Base currency that is currently owned.
-`open_date`| datetime | Timestamp when trade was opened **use `open_date_utc` instead**
-`open_date_utc`| datetime | Timestamp when trade was opened - in UTC
-`close_date`| datetime | Timestamp when trade was closed **use `close_date_utc` instead**
-`close_date_utc`| datetime | Timestamp when trade was closed - in UTC
-`close_profit`| float | Relative profit at the time of trade closure. `0.01` == 1%
-`close_profit_abs`| float | Absolute profit (in stake currency) at the time of trade closure.
-`leverage` | float | Leverage used for this trade - defaults to 1.0 in spot markets.
-`enter_tag`| string | Tag provided on entry via the `enter_tag` column in the dataframe
-`is_short` | boolean | True for short trades, False otherwise
-`orders` | Order[] | List of order objects attached to this trade (includes both filled and cancelled orders)
-`date_last_filled_utc` | datetime | Time of the last filled order
-`entry_side` | "buy" / "sell" | Order Side the trade was entered
-`exit_side` | "buy" / "sell" | Order Side that will result in a trade exit / position reduction.
-`trade_direction` | "long" / "short" | Trade direction in text - long or short.
-`nr_of_successful_entries` | int | Number of successful (filled) entry orders
-`nr_of_successful_exits` | int | Number of successful (filled) exit orders
-
-## Class methods
-
-The following are class methods - which return generic information, and usually result in an explicit query against the database.
-They can be used as `Trade.<method>` - e.g. `open_trades = Trade.get_open_trade_count()`
-
-!!! Warning "Backtesting/hyperopt"
-    Most methods will work in both backtesting / hyperopt and live/dry modes.
-    During backtesting, it's limited to usage in [strategy callbacks](strategy-callbacks.md). Usage in `populate_*()` methods is not supported and will result in wrong results.
-
-### get_trades_proxy
-
-When your strategy needs some information on existing (open or close) trades - it's best to use `Trade.get_trades_proxy()`.
-
-Usage:
-
-``` python
-from freqtrade.persistence import Trade
-from datetime import timedelta
-
-# ...
-trade_hist = Trade.get_trades_proxy(pair='ETH/USDT', is_open=False, open_date=current_date - timedelta(days=2))
-
-```
-
-`get_trades_proxy()` supports the following keyword arguments. All arguments are optional - calling `get_trades_proxy()` without arguments will return a list of all trades in the database.
-
-* `pair` e.g. `pair='ETH/USDT'`
-* `is_open` e.g. `is_open=False`
-* `open_date` e.g. `open_date=current_date - timedelta(days=2)`
-* `close_date` e.g. `close_date=current_date - timedelta(days=5)`
-
-### get_open_trade_count
-
-Get the number of currently open trades
-
-``` python
-from freqtrade.persistence import Trade
-# ...
-open_trades = Trade.get_open_trade_count()
-```
-
-### get_total_closed_profit
-
-Retrieve the total profit the bot has generated so far.
-Aggregates `close_profit_abs` for all closed trades.
-
-``` python
-from freqtrade.persistence import Trade
-
-# ...
-profit = Trade.get_total_closed_profit()
-```
-
-### total_open_trades_stakes
-
-Retrieve the total stake_amount that's currently in trades.
-
-``` python
-from freqtrade.persistence import Trade
-
-# ...
-profit = Trade.total_open_trades_stakes()
-```
-
-### get_overall_performance
-
-Retrieve the overall performance - similar to the `/performance` telegram command.
-
-``` python
-from freqtrade.persistence import Trade
-
-# ...
-if self.config['runmode'].value in ('live', 'dry_run'):
-    performance = Trade.get_overall_performance()
-```
-
-Sample return value: ETH/BTC had 5 trades, with a total profit of 1.5% (ratio of 0.015).
-
-``` json
-{"pair": "ETH/BTC", "profit": 0.015, "count": 5}
-```
-
-## Order Object
-
-An `Order` object represents an order on the exchange (or a simulated order in dry-run mode).
-An `Order` object will always be tied to it's corresponding [`Trade`](#trade-object), and only really makes sense in the context of a trade.
-
-### Order - Available attributes
-
-an Order object is typically attached to a trade.
-Most properties here can be None as they are dependant on the exchange response.
-
-|  Attribute | DataType | Description |
-|------------|-------------|-------------|
-`trade` | Trade | Trade object this order is attached to
-`ft_pair` | string | Pair this order is for
-`ft_is_open` | boolean | is the order filled?
-`order_type` | string | Order type as defined on the exchange - usually market, limit or stoploss
-`status` | string | Status as defined by ccxt. Usually open, closed, expired or canceled
-`side` | string | Buy or Sell
-`price` | float | Price the order was placed at
-`average` | float | Average price the order filled at
-`amount` | float | Amount in base currency
-`filled` | float | Filled amount (in base currency)
-`remaining` | float | Remaining amount
-`cost` | float | Cost of the order - usually average * filled
-`order_date` | datetime | Order creation date **use `order_date_utc` instead**
-`order_date_utc` | datetime | Order creation date (in UTC)
-`order_fill_date` | datetime |  Order fill date **use `order_fill_utc` instead**
-`order_fill_date_utc` | datetime | Order fill date

docs/updating.md

@@ -6,14 +6,14 @@ To update your freqtrade installation, please use one of the below methods, corr
     Breaking changes / changed behavior will be documented in the changelog that is posted alongside every release.
     For the develop branch, please follow PR's to avoid being surprised by changes.
 
-## docker
+## docker-compose
 
 !!! Note "Legacy installations using the `master` image"
     We're switching from master to stable for the release Images - please adjust your docker-file and replace `freqtradeorg/freqtrade:master` with `freqtradeorg/freqtrade:stable`
 
 ``` bash
-docker compose pull
+docker-compose pull
-docker compose up -d
+docker-compose up -d
 ```
 
 ## Installation via setup script

docs/utils.md

@@ -169,43 +169,6 @@ Example: Search dedicated strategy path.
 freqtrade list-strategies --strategy-path ~/.freqtrade/strategies/
 ```
 
-## List freqAI models
-
-Use the `list-freqaimodels` subcommand to see all freqAI models available.
-
-This subcommand is useful for finding problems in your environment with loading freqAI models: modules with models that contain errors and failed to load are printed in red (LOAD FAILED), while models with duplicate names are printed in yellow (DUPLICATE NAME).
-
-```
-usage: freqtrade list-freqaimodels [-h] [-v] [--logfile FILE] [-V] [-c PATH]
-                                   [-d PATH] [--userdir PATH]
-                                   [--freqaimodel-path PATH] [-1] [--no-color]
-
-optional arguments:
-  -h, --help            show this help message and exit
-  --freqaimodel-path PATH
-                        Specify additional lookup path for freqaimodels.
-  -1, --one-column      Print output in one column.
-  --no-color            Disable colorization of hyperopt results. May be
-                        useful if you are redirecting output to a file.
-
-Common arguments:
-  -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
-  --logfile FILE        Log to the file specified. Special values are:
-                        'syslog', 'journald'. See the documentation for more
-                        details.
-  -V, --version         show program's version number and exit
-  -c PATH, --config PATH
-                        Specify configuration file (default:
-                        `userdir/config.json` or `config.json` whichever
-                        exists). Multiple --config options may be used. Can be
-                        set to `-` to read config from stdin.
-  -d PATH, --datadir PATH, --data-dir PATH
-                        Path to directory with historical backtesting data.
-  --userdir PATH, --user-data-dir PATH
-                        Path to userdata directory.
-
-```
-
 ## List Exchanges
 
 Use the `list-exchanges` subcommand to see the exchanges available for the bot.
@@ -263,6 +226,7 @@ equos            True     missing opt: fetchTicker, fetchTickers
 eterbase         True
 fcoin            True     missing opt: fetchMyTrades, fetchTickers
 fcoinjp          True     missing opt: fetchMyTrades, fetchTickers
+ftx              True
 gateio           True
 gemini           True
 gopax            True
@@ -368,6 +332,7 @@ fcoin               True     missing opt: fetchMyTrades, fetchTickers
 fcoinjp             True     missing opt: fetchMyTrades, fetchTickers
 flowbtc             False    missing: fetchOrder, fetchOHLCV
 foxbit              False    missing: fetchOrder, fetchOHLCV
+ftx                 True
 gateio              True
 gemini              True
 gopax               True
@@ -652,7 +617,7 @@ Common arguments:
 
 You can also use webserver mode via docker.
 Starting a one-off container requires the configuration of the port explicitly, as ports are not exposed by default.
-You can use `docker compose run --rm -p 127.0.0.1:8080:8080 freqtrade webserver` to start a one-off container that'll be removed once you stop it. This assumes that port 8080 is still available and no other bot is running on that port.
+You can use `docker-compose run --rm -p 127.0.0.1:8080:8080 freqtrade webserver` to start a one-off container that'll be removed once you stop it. This assumes that port 8080 is still available and no other bot is running on that port.
 
 Alternatively, you can reconfigure the docker-compose file to have the command updated:
 
@@ -662,7 +627,7 @@ Alternatively, you can reconfigure the docker-compose file to have the command u
       --config /freqtrade/user_data/config.json
 ```
 
-You can now use `docker compose up` to start the webserver.
+You can now use `docker-compose up` to start the webserver.
 This assumes that the configuration has a webserver enabled and configured for docker (listening port = `0.0.0.0`).
 
 !!! Tip
@@ -722,7 +687,6 @@ usage: freqtrade backtesting-analysis [-h] [-v] [--logfile FILE] [-V]
                                       [--enter-reason-list ENTER_REASON_LIST [ENTER_REASON_LIST ...]]
                                       [--exit-reason-list EXIT_REASON_LIST [EXIT_REASON_LIST ...]]
                                       [--indicator-list INDICATOR_LIST [INDICATOR_LIST ...]]
-                                      [--timerange YYYYMMDD-[YYYYMMDD]]
 
 optional arguments:
   -h, --help            show this help message and exit
@@ -745,10 +709,6 @@ optional arguments:
   --indicator-list INDICATOR_LIST [INDICATOR_LIST ...]
                         Comma separated list of indicators to analyse. e.g.
                         'close,rsi,bb_lowerband,profit_abs'
-  --timerange YYYYMMDD-[YYYYMMDD]
-                        Timerange to filter trades for analysis, 
-                        start inclusive, end exclusive. e.g.
-                        20220101-20220201
 
 Common arguments:
   -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
@@ -955,47 +915,3 @@ Print trades with id 2 and 3 as json
 ``` bash
 freqtrade show-trades --db-url sqlite:///tradesv3.sqlite --trade-ids 2 3 --print-json
 ```
-
-### Strategy-Updater
-
-Updates listed strategies or all strategies within the strategies folder to be v3 compliant.
-If the command runs without --strategy-list then all strategies inside the strategies folder will be converted.
-Your original strategy will remain available in the `user_data/strategies_orig_updater/` directory.
-
-!!! Warning "Conversion results"
-    Strategy updater will work on a "best effort" approach. Please do your due diligence and verify the results of the conversion.
-    We also recommend to run a python formatter (e.g. `black`) to format results in a sane manner.
-
-```
-usage: freqtrade strategy-updater [-h] [-v] [--logfile FILE] [-V] [-c PATH]
-                                  [-d PATH] [--userdir PATH]
-                                  [--strategy-list STRATEGY_LIST [STRATEGY_LIST ...]]
-
-options:
-  -h, --help            show this help message and exit
-  --strategy-list STRATEGY_LIST [STRATEGY_LIST ...]
-                        Provide a space-separated list of strategies to
-                        backtest. Please note that timeframe needs to be set
-                        either in config or via command line. When using this
-                        together with `--export trades`, the strategy-name is
-                        injected into the filename (so `backtest-data.json`
-                        becomes `backtest-data-SampleStrategy.json`
-
-Common arguments:
-  -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
-  --logfile FILE, --log-file FILE
-                        Log to the file specified. Special values are:
-                        'syslog', 'journald'. See the documentation for more
-                        details.
-  -V, --version         show program's version number and exit
-  -c PATH, --config PATH
-                        Specify configuration file (default:
-                        `userdir/config.json` or `config.json` whichever
-                        exists). Multiple --config options may be used. Can be
-                        set to `-` to read config from stdin.
-  -d PATH, --datadir PATH, --data-dir PATH
-                        Path to directory with historical backtesting data.
-  --userdir PATH, --user-data-dir PATH
-                        Path to userdata directory.
-
-```

docs/webhook-config.md

@@ -10,37 +10,37 @@ Sample configuration (tested using IFTTT).
   "webhook": {
         "enabled": true,
         "url": "https://maker.ifttt.com/trigger/<YOUREVENT>/with/key/<YOURKEY>/",
-        "entry": {
+        "webhookentry": {
             "value1": "Buying {pair}",
             "value2": "limit {limit:8f}",
             "value3": "{stake_amount:8f} {stake_currency}"
         },
-        "entry_cancel": {
+        "webhookentrycancel": {
             "value1": "Cancelling Open Buy Order for {pair}",
             "value2": "limit {limit:8f}",
             "value3": "{stake_amount:8f} {stake_currency}"
         },
-         "entry_fill": {
+         "webhookentryfill": {
             "value1": "Buy Order for {pair} filled",
             "value2": "at {open_rate:8f}",
             "value3": ""
         },
-        "exit": {
+        "webhookexit": {
             "value1": "Exiting {pair}",
             "value2": "limit {limit:8f}",
             "value3": "profit: {profit_amount:8f} {stake_currency} ({profit_ratio})"
         },
-        "exit_cancel": {
+        "webhookexitcancel": {
             "value1": "Cancelling Open Exit Order for {pair}",
             "value2": "limit {limit:8f}",
             "value3": "profit: {profit_amount:8f} {stake_currency} ({profit_ratio})"
         },
-        "exit_fill": {
+        "webhookexitfill": {
             "value1": "Exit Order for {pair} filled",
             "value2": "at {close_rate:8f}.",
             "value3": ""
         },
-        "status": {
+        "webhookstatus": {
             "value1": "Status: {status}",
             "value2": "",
             "value3": ""
@@ -57,7 +57,7 @@ You can set the POST body format to Form-Encoded (default), JSON-Encoded, or raw
         "enabled": true,
         "url": "https://<YOURSUBDOMAIN>.cloud.mattermost.com/hooks/<YOURHOOK>",
         "format": "json",
-        "status": {
+        "webhookstatus": {
             "text": "Status: {status}"
         }
     },
@@ -88,30 +88,17 @@ Optional parameters are available to enable automatic retries for webhook messag
         "url": "https://<YOURHOOKURL>",
         "retries": 3,
         "retry_delay": 0.2,
-        "status": {
+        "webhookstatus": {
             "status": "Status: {status}"
         }
     },
 ```
 
-Custom messages can be sent to Webhook endpoints via the `self.dp.send_msg()` function from within the strategy. To enable this, set the `allow_custom_messages` option to `true`:
-
-```json
-  "webhook": {
-        "enabled": true,
-        "url": "https://<YOURHOOKURL>",
-        "allow_custom_messages": true,
-        "strategy_msg": {
-            "status": "StrategyMessage: {msg}"
-        }
-    },
-```
-
 Different payloads can be configured for different events. Not all fields are necessary, but you should configure at least one of the dicts, otherwise the webhook will never be called.
 
-### Entry
+### Webhookentry
 
-The fields in `webhook.entry` are filled when the bot executes a long/short. Parameters are filled using string.format.
+The fields in `webhook.webhookentry` are filled when the bot executes a long/short. Parameters are filled using string.format.
 Possible parameters are:
 
 * `trade_id`
@@ -131,9 +118,9 @@ Possible parameters are:
 * `current_rate`
 * `enter_tag`
 
-### Entry cancel
+### Webhookentrycancel
 
-The fields in `webhook.entry_cancel` are filled when the bot cancels a long/short order. Parameters are filled using string.format.
+The fields in `webhook.webhookentrycancel` are filled when the bot cancels a long/short order. Parameters are filled using string.format.
 Possible parameters are:
 
 * `trade_id`
@@ -152,9 +139,9 @@ Possible parameters are:
 * `current_rate`
 * `enter_tag`
 
-### Entry fill
+### Webhookentryfill
 
-The fields in `webhook.entry_fill` are filled when the bot filled a long/short order. Parameters are filled using string.format.
+The fields in `webhook.webhookentryfill` are filled when the bot filled a long/short order. Parameters are filled using string.format.
 Possible parameters are:
 
 * `trade_id`
@@ -173,9 +160,9 @@ Possible parameters are:
 * `current_rate`
 * `enter_tag`
 
-### Exit
+### Webhookexit
 
-The fields in `webhook.exit` are filled when the bot exits a trade. Parameters are filled using string.format.
+The fields in `webhook.webhookexit` are filled when the bot exits a trade. Parameters are filled using string.format.
 Possible parameters are:
 
 * `trade_id`
@@ -197,9 +184,9 @@ Possible parameters are:
 * `open_date`
 * `close_date`
 
-### Exit fill
+### Webhookexitfill
 
-The fields in `webhook.exit_fill` are filled when the bot fills a exit order (closes a Trade). Parameters are filled using string.format.
+The fields in `webhook.webhookexitfill` are filled when the bot fills a exit order (closes a Trade). Parameters are filled using string.format.
 Possible parameters are:
 
 * `trade_id`
@@ -222,9 +209,9 @@ Possible parameters are:
 * `open_date`
 * `close_date`
 
-### Exit cancel
+### Webhookexitcancel
 
-The fields in `webhook.exit_cancel` are filled when the bot cancels a exit order. Parameters are filled using string.format.
+The fields in `webhook.webhookexitcancel` are filled when the bot cancels a exit order. Parameters are filled using string.format.
 Possible parameters are:
 
 * `trade_id`
@@ -247,9 +234,9 @@ Possible parameters are:
 * `open_date`
 * `close_date`
 
-### Status
+### Webhookstatus
 
-The fields in `webhook.status` are used for regular status messages (Started / Stopped / ...). Parameters are filled using string.format.
+The fields in `webhook.webhookstatus` are used for regular status messages (Started / Stopped / ...). Parameters are filled using string.format.
 
 The only possible value here is `{status}`.
 
@@ -293,6 +280,7 @@ You can configure this as follows:
 }
 ```
 
+
 The above represents the default (`exit_fill` and `entry_fill` are optional and will default to the above configuration) - modifications are obviously possible.
 
 Available fields correspond to the fields for webhooks and are documented in the corresponding webhook sections.
@@ -300,13 +288,3 @@ Available fields correspond to the fields for webhooks and are documented in the
 The notifications will look as follows by default.
 
 ![discord-notification](assets/discord_notification.png)
-
-Custom messages can be sent from a strategy to Discord endpoints via the dataprovider.send_msg() function. To enable this, set the `allow_custom_messages` option to `true`:
-
-```json
-  "discord": {
-        "enabled": true,
-        "webhook_url": "https://discord.com/api/webhooks/<Your webhook URL ...>",
-        "allow_custom_messages": true,
-    },
-```

docs/windows_installation.md

@@ -3,16 +3,15 @@
 We **strongly** recommend that Windows users use [Docker](docker_quickstart.md) as this will work much easier and smoother (also more secure).
 
 If that is not possible, try using the Windows Linux subsystem (WSL) - for which the Ubuntu instructions should work.
-Otherwise, please follow the instructions below.
+Otherwise, try the instructions below.
 
 ## Install freqtrade manually
 
-!!! Note "64bit Python version"
+!!! Note
-    Please make sure to use 64bit Windows and 64bit Python to avoid problems with backtesting or hyperopt due to the memory constraints 32bit applications have under Windows.
+    Make sure to use 64bit Windows and 64bit Python to avoid problems with backtesting or hyperopt due to the memory constraints 32bit applications have under Windows.
-    32bit python versions are no longer supported under Windows.
 
 !!! Hint
-    Using the [Anaconda Distribution](https://www.anaconda.com/distribution/) under Windows can greatly help with installation problems. Check out the [Anaconda installation section](installation.md#installation-with-conda) in the documentation for more information.
+    Using the [Anaconda Distribution](https://www.anaconda.com/distribution/) under Windows can greatly help with installation problems. Check out the [Anaconda installation section](installation.md#Anaconda) in this document for more information.
 
 ### 1. Clone the git repository
 
@@ -26,7 +25,7 @@ Install ta-lib according to the [ta-lib documentation](https://github.com/mrjbq7
 
 As compiling from source on windows has heavy dependencies (requires a partial visual studio installation), there is also a repository of unofficial pre-compiled windows Wheels [here](https://www.lfd.uci.edu/~gohlke/pythonlibs/#ta-lib), which need to be downloaded and installed using `pip install TA_Lib-0.4.25-cp38-cp38-win_amd64.whl` (make sure to use the version matching your python version).
 
-Freqtrade provides these dependencies for the latest 3 Python versions (3.8, 3.9, 3.10 and 3.11) and for 64bit Windows.
+Freqtrade provides these dependencies for the latest 3 Python versions (3.8, 3.9 and 3.10) and for 64bit Windows.
 Other versions must be downloaded from the above link.
 
 ``` powershell

environment.yml

@@ -0,0 +1,75 @@
+name: freqtrade
+channels:
+  - conda-forge
+# - defaults
+dependencies:
+# 1/4 req main
+    - python>=3.8,<=3.10
+    - numpy
+    - pandas
+    - pip
+
+    - py-find-1st
+    - aiohttp
+    - SQLAlchemy
+    - python-telegram-bot
+    - arrow
+    - cachetools
+    - requests
+    - urllib3
+    - jsonschema
+    - TA-Lib
+    - tabulate
+    - jinja2
+    - blosc
+    - sdnotify
+    - fastapi
+    - uvicorn
+    - pyjwt
+    - aiofiles
+    - psutil
+    - colorama
+    - questionary
+    - prompt-toolkit
+    - schedule
+    - python-dateutil
+    - joblib
+    - pyarrow
+
+
+    # ============================
+    # 2/4 req dev
+
+    - coveralls
+    - flake8
+    - mypy
+    - pytest
+    - pytest-asyncio
+    - pytest-cov
+    - pytest-mock
+    - isort
+    - nbconvert
+
+    # ============================
+    # 3/4 req hyperopt
+
+    - scipy
+    - scikit-learn
+    - filelock
+    - scikit-optimize
+    - progressbar2
+    # ============================
+    # 4/4 req plot
+
+    - plotly
+    - jupyter
+
+    - pip:
+        - pycoingecko
+        # - py_find_1st
+        - tables
+        - pytest-random-order
+        - ccxt
+        - flake8-tidy-imports
+        - -e .
+    # - python-rapidjso

freqtrade/__init__.py

@@ -1,22 +1,21 @@
 """ Freqtrade bot """
-__version__ = '2023.4.dev'
+__version__ = '2022.10.dev'
 
 if 'dev' in __version__:
-    from pathlib import Path
     try:
         import subprocess
-        freqtrade_basedir = Path(__file__).parent
 
         __version__ = __version__ + '-' + subprocess.check_output(
             ['git', 'log', '--format="%h"', '-n 1'],
-            stderr=subprocess.DEVNULL, cwd=freqtrade_basedir).decode("utf-8").rstrip().strip('"')
+            stderr=subprocess.DEVNULL).decode("utf-8").rstrip().strip('"')
 
     except Exception:  # pragma: no cover
         # git not available, ignore
         try:
             # Try Fallback to freqtrade_commit file (created by CI while building docker image)
+            from pathlib import Path
             versionfile = Path('./freqtrade_commit')
             if versionfile.is_file():
-                __version__ = f"docker-{__version__}-{versionfile.read_text()[:8]}"
+                __version__ = f"docker-{versionfile.read_text()[:8]}"
         except Exception:
             pass

freqtrade/commands/__init__.py

@@ -15,13 +15,12 @@ from freqtrade.commands.db_commands import start_convert_db
 from freqtrade.commands.deploy_commands import (start_create_userdir, start_install_ui,
                                                 start_new_strategy)
 from freqtrade.commands.hyperopt_commands import start_hyperopt_list, start_hyperopt_show
-from freqtrade.commands.list_commands import (start_list_exchanges, start_list_freqAI_models,
+from freqtrade.commands.list_commands import (start_list_exchanges, start_list_markets,
-                                              start_list_markets, start_list_strategies,
+                                              start_list_strategies, start_list_timeframes,
-                                              start_list_timeframes, start_show_trades)
+                                              start_show_trades)
 from freqtrade.commands.optimize_commands import (start_backtesting, start_backtesting_show,
                                                   start_edge, start_hyperopt)
 from freqtrade.commands.pairlist_commands import start_test_pairlist
 from freqtrade.commands.plot_commands import start_plot_dataframe, start_plot_profit
-from freqtrade.commands.strategy_utils_commands import start_strategy_update
 from freqtrade.commands.trade_commands import start_trading
 from freqtrade.commands.webserver_commands import start_webserver

freqtrade/commands/analyze_commands.py

@@ -40,8 +40,8 @@ def setup_analyze_configuration(args: Dict[str, Any], method: RunMode) -> Dict[s
 
         if (not Path(signals_file).exists()):
             raise OperationalException(
-                f"Cannot find latest backtest signals file: {signals_file}."
+                (f"Cannot find latest backtest signals file: {signals_file}."
-                "Run backtesting with `--export signals`."
+                  "Run backtesting with `--export signals`.")
             )
 
     return config
@@ -60,4 +60,10 @@ def start_analysis_entries_exits(args: Dict[str, Any]) -> None:
 
     logger.info('Starting freqtrade in analysis mode')
 
-    process_entry_exit_reasons(config)
+    process_entry_exit_reasons(config['exportfilename'],
+                               config['exchange']['pair_whitelist'],
+                               config['analysis_groups'],
+                               config['enter_reason_list'],
+                               config['exit_reason_list'],
+                               config['indicator_list']
+                               )

freqtrade/commands/arguments.py

@@ -25,8 +25,7 @@ ARGS_COMMON_OPTIMIZE = ["timeframe", "timerange", "dataformat_ohlcv",
 ARGS_BACKTEST = ARGS_COMMON_OPTIMIZE + ["position_stacking", "use_max_market_positions",
                                         "enable_protections", "dry_run_wallet", "timeframe_detail",
                                         "strategy_list", "export", "exportfilename",
-                                        "backtest_breakdown", "backtest_cache",
+                                        "backtest_breakdown", "backtest_cache"]
-                                        "freqai_backtest_live_models"]
 
 ARGS_HYPEROPT = ARGS_COMMON_OPTIMIZE + ["hyperopt", "hyperopt_path",
                                         "position_stacking", "use_max_market_positions",
@@ -42,8 +41,6 @@ ARGS_EDGE = ARGS_COMMON_OPTIMIZE + ["stoploss_range"]
 ARGS_LIST_STRATEGIES = ["strategy_path", "print_one_column", "print_colorized",
                         "recursive_strategy_search"]
 
-ARGS_LIST_FREQAIMODELS = ["freqaimodel_path", "print_one_column", "print_colorized"]
-
 ARGS_LIST_HYPEROPTS = ["hyperopt_path", "print_one_column", "print_colorized"]
 
 ARGS_BACKTEST_SHOW = ["exportfilename", "backtest_show_pair_list"]
@@ -106,18 +103,15 @@ ARGS_HYPEROPT_SHOW = ["hyperopt_list_best", "hyperopt_list_profitable", "hyperop
                       "disableparamexport", "backtest_breakdown"]
 
 ARGS_ANALYZE_ENTRIES_EXITS = ["exportfilename", "analysis_groups", "enter_reason_list",
-                              "exit_reason_list", "indicator_list", "timerange"]
+                              "exit_reason_list", "indicator_list"]
 
 NO_CONF_REQURIED = ["convert-data", "convert-trade-data", "download-data", "list-timeframes",
-                    "list-markets", "list-pairs", "list-strategies", "list-freqaimodels",
+                    "list-markets", "list-pairs", "list-strategies", "list-data",
-                    "list-data", "hyperopt-list", "hyperopt-show", "backtest-filter",
+                    "hyperopt-list", "hyperopt-show", "backtest-filter",
-                    "plot-dataframe", "plot-profit", "show-trades", "trades-to-ohlcv",
+                    "plot-dataframe", "plot-profit", "show-trades", "trades-to-ohlcv"]
-                    "strategy-updater"]
 
 NO_CONF_ALLOWED = ["create-userdir", "list-exchanges", "new-strategy"]
 
-ARGS_STRATEGY_UTILS = ["strategy_list", "strategy_path", "recursive_strategy_search"]
-
 
 class Arguments:
     """
@@ -198,10 +192,9 @@ class Arguments:
                                         start_create_userdir, start_download_data, start_edge,
                                         start_hyperopt, start_hyperopt_list, start_hyperopt_show,
                                         start_install_ui, start_list_data, start_list_exchanges,
-                                        start_list_freqAI_models, start_list_markets,
+                                        start_list_markets, start_list_strategies,
-                                        start_list_strategies, start_list_timeframes,
+                                        start_list_timeframes, start_new_config, start_new_strategy,
-                                        start_new_config, start_new_strategy, start_plot_dataframe,
+                                        start_plot_dataframe, start_plot_profit, start_show_trades,
-                                        start_plot_profit, start_show_trades, start_strategy_update,
                                         start_test_pairlist, start_trading, start_webserver)
 
         subparsers = self.parser.add_subparsers(dest='command',
@@ -369,15 +362,6 @@ class Arguments:
         list_strategies_cmd.set_defaults(func=start_list_strategies)
         self._build_args(optionlist=ARGS_LIST_STRATEGIES, parser=list_strategies_cmd)
 
-        # Add list-freqAI Models subcommand
-        list_freqaimodels_cmd = subparsers.add_parser(
-            'list-freqaimodels',
-            help='Print available freqAI models.',
-            parents=[_common_parser],
-        )
-        list_freqaimodels_cmd.set_defaults(func=start_list_freqAI_models)
-        self._build_args(optionlist=ARGS_LIST_FREQAIMODELS, parser=list_freqaimodels_cmd)
-
         # Add list-timeframes subcommand
         list_timeframes_cmd = subparsers.add_parser(
             'list-timeframes',
@@ -443,11 +427,3 @@ class Arguments:
                                               parents=[_common_parser])
         webserver_cmd.set_defaults(func=start_webserver)
         self._build_args(optionlist=ARGS_WEBSERVER, parser=webserver_cmd)
-
-        # Add strategy_updater subcommand
-        strategy_updater_cmd = subparsers.add_parser('strategy-updater',
-                                                     help='updates outdated strategy'
-                                                          'files to the current version',
-                                                     parents=[_common_parser])
-        strategy_updater_cmd.set_defaults(func=start_strategy_update)
-        self._build_args(optionlist=ARGS_STRATEGY_UTILS, parser=strategy_updater_cmd)

freqtrade/commands/build_config_commands.py

@@ -108,7 +108,8 @@ def ask_user_config() -> Dict[str, Any]:
                 "binance",
                 "binanceus",
                 "bittrex",
-                "gate",
+                "ftx",
+                "gateio",
                 "huobi",
                 "kraken",
                 "kucoin",
@@ -123,7 +124,7 @@ def ask_user_config() -> Dict[str, Any]:
             "message": "Do you want to trade Perpetual Swaps (perpetual futures)?",
             "default": False,
             "filter": lambda val: 'futures' if val else 'spot',
-            "when": lambda x: x["exchange_name"] in ['binance', 'gate', 'okx'],
+            "when": lambda x: x["exchange_name"] in ['binance', 'gateio', 'okx'],
         },
         {
             "type": "autocomplete",

freqtrade/commands/cli_options.py

@@ -49,7 +49,7 @@ AVAILABLE_CLI_OPTIONS = {
         default=0,
     ),
     "logfile": Arg(
-        '--logfile', '--log-file',
+        '--logfile',
         help="Log to the file specified. Special values are: 'syslog', 'journald'. "
              "See the documentation for more details.",
         metavar='FILE',
@@ -251,8 +251,7 @@ AVAILABLE_CLI_OPTIONS = {
     "spaces": Arg(
         '--spaces',
         help='Specify which parameters to hyperopt. Space-separated list.',
-        choices=['all', 'buy', 'sell', 'roi', 'stoploss',
+        choices=['all', 'buy', 'sell', 'roi', 'stoploss', 'trailing', 'protection', 'default'],
-                 'trailing', 'protection', 'trades', 'default'],
         nargs='+',
         default='default',
     ),
@@ -633,11 +632,10 @@ AVAILABLE_CLI_OPTIONS = {
               "1: by enter_tag, "
               "2: by enter_tag and exit_tag, "
               "3: by pair and enter_tag, "
-              "4: by pair, enter_ and exit_tag (this can get quite large), "
+              "4: by pair, enter_ and exit_tag (this can get quite large)"),
-              "5: by exit_tag"),
         nargs='+',
         default=['0', '1', '2'],
-        choices=['0', '1', '2', '3', '4', '5'],
+        choices=['0', '1', '2', '3', '4'],
     ),
     "enter_reason_list": Arg(
         "--enter-reason-list",
@@ -670,9 +668,4 @@ AVAILABLE_CLI_OPTIONS = {
         help='Specify additional lookup path for freqaimodels.',
         metavar='PATH',
     ),
-    "freqai_backtest_live_models": Arg(
-        '--freqai-backtest-live-models',
-        help='Run backtest with ready models.',
-        action='store_true'
-    ),
 }

freqtrade/commands/data_commands.py

@@ -5,7 +5,7 @@ from datetime import datetime, timedelta
 from typing import Any, Dict, List
 
 from freqtrade.configuration import TimeRange, setup_utils_configuration
-from freqtrade.constants import DATETIME_PRINT_FORMAT, Config
+from freqtrade.constants import DATETIME_PRINT_FORMAT
 from freqtrade.data.converter import convert_ohlcv_format, convert_trades_format
 from freqtrade.data.history import (convert_trades_to_ohlcv, refresh_backtest_ohlcv_data,
                                     refresh_backtest_trades_data)
@@ -14,30 +14,20 @@ from freqtrade.exceptions import OperationalException
 from freqtrade.exchange import market_is_active, timeframe_to_minutes
 from freqtrade.plugins.pairlist.pairlist_helpers import dynamic_expand_pairlist, expand_pairlist
 from freqtrade.resolvers import ExchangeResolver
-from freqtrade.util.binance_mig import migrate_binance_futures_data
 
 
 logger = logging.getLogger(__name__)
 
 
-def _data_download_sanity(config: Config) -> None:
-    if 'days' in config and 'timerange' in config:
-        raise OperationalException("--days and --timerange are mutually exclusive. "
-                                   "You can only specify one or the other.")
-
-    if 'pairs' not in config:
-        raise OperationalException(
-            "Downloading data requires a list of pairs. "
-            "Please check the documentation on how to configure this.")
-
-
 def start_download_data(args: Dict[str, Any]) -> None:
     """
     Download data (former download_backtest_data.py script)
     """
     config = setup_utils_configuration(args, RunMode.UTIL_EXCHANGE)
 
-    _data_download_sanity(config)
+    if 'days' in config and 'timerange' in config:
+        raise OperationalException("--days and --timerange are mutually exclusive. "
+                                   "You can only specify one or the other.")
     timerange = TimeRange()
     if 'days' in config:
         time_since = (datetime.now() - timedelta(days=config['days'])).strftime("%Y%m%d")
@@ -49,6 +39,11 @@ def start_download_data(args: Dict[str, Any]) -> None:
     # Remove stake-currency to skip checks which are not relevant for datadownload
     config['stake_currency'] = ''
 
+    if 'pairs' not in config:
+        raise OperationalException(
+            "Downloading data requires a list of pairs. "
+            "Please check the documentation on how to configure this.")
+
     pairs_not_available: List[str] = []
 
     # Init exchange
@@ -91,7 +86,6 @@ def start_download_data(args: Dict[str, Any]) -> None:
                     "Please use `--dl-trades` instead for this exchange "
                     "(will unfortunately take a long time)."
                     )
-            migrate_binance_futures_data(config)
             pairs_not_available = refresh_backtest_ohlcv_data(
                 exchange, pairs=expanded_pairs, timeframes=config['timeframes'],
                 datadir=config['datadir'], timerange=timerange,
@@ -151,7 +145,6 @@ def start_convert_data(args: Dict[str, Any], ohlcv: bool = True) -> None:
     """
     config = setup_utils_configuration(args, RunMode.UTIL_NO_EXCHANGE)
     if ohlcv:
-        migrate_binance_futures_data(config)
         candle_types = [CandleType.from_string(ct) for ct in config.get('candle_types', ['spot'])]
         for candle_type in candle_types:
             convert_ohlcv_format(config,
@@ -204,14 +197,11 @@ def start_list_data(args: Dict[str, Any]) -> None:
             pair, timeframe, candle_type,
             *dhc.ohlcv_data_min_max(pair, timeframe, candle_type)
         ) for pair, timeframe, candle_type in paircombs]
-
         print(tabulate([
             (pair, timeframe, candle_type,
                 start.strftime(DATETIME_PRINT_FORMAT),
                 end.strftime(DATETIME_PRINT_FORMAT))
-            for pair, timeframe, candle_type, start, end in sorted(
+            for pair, timeframe, candle_type, start, end in paircombs1
-                paircombs1,
-                key=lambda x: (x[0], timeframe_to_minutes(x[1]), x[2]))
             ],
             headers=("Pair", "Timeframe", "Type", 'From', 'To'),
             tablefmt='psql', stralign='right'))

freqtrade/commands/db_commands.py

@@ -1,7 +1,7 @@
 import logging
 from typing import Any, Dict
 
-from sqlalchemy import func, select
+from sqlalchemy import func
 
 from freqtrade.configuration.config_setup import setup_utils_configuration
 from freqtrade.enums import RunMode
@@ -20,7 +20,7 @@ def start_convert_db(args: Dict[str, Any]) -> None:
     config = setup_utils_configuration(args, RunMode.UTIL_NO_EXCHANGE)
 
     init_db(config['db_url'])
-    session_target = Trade.session
+    session_target = Trade._session
     init_db(config['db_url_from'])
     logger.info("Starting db migration.")
 
@@ -36,16 +36,16 @@ def start_convert_db(args: Dict[str, Any]) -> None:
 
     session_target.commit()
 
-    for pairlock in PairLock.get_all_locks():
+    for pairlock in PairLock.query:
         pairlock_count += 1
         make_transient(pairlock)
         session_target.add(pairlock)
     session_target.commit()
 
     # Update sequences
-    max_trade_id = session_target.scalar(select(func.max(Trade.id)))
+    max_trade_id = session_target.query(func.max(Trade.id)).scalar()
-    max_order_id = session_target.scalar(select(func.max(Order.id)))
+    max_order_id = session_target.query(func.max(Order.id)).scalar()
-    max_pairlock_id = session_target.scalar(select(func.max(PairLock.id)))
+    max_pairlock_id = session_target.query(func.max(PairLock.id)).scalar()
 
     set_sequence_ids(session_target.get_bind(),
                      trade_id=max_trade_id,

freqtrade/commands/list_commands.py

@@ -1,6 +1,7 @@
 import csv
 import logging
 import sys
+from pathlib import Path
 from typing import Any, Dict, List
 
 import rapidjson
@@ -9,6 +10,7 @@ from colorama import init as colorama_init
 from tabulate import tabulate
 
 from freqtrade.configuration import setup_utils_configuration
+from freqtrade.constants import USERPATH_STRATEGIES
 from freqtrade.enums import RunMode
 from freqtrade.exceptions import OperationalException
 from freqtrade.exchange import market_is_active, validate_exchanges
@@ -39,7 +41,7 @@ def start_list_exchanges(args: Dict[str, Any]) -> None:
         print(tabulate(exchanges, headers=['Exchange name', 'Valid', 'reason']))
 
 
-def _print_objs_tabular(objs: List, print_colorized: bool) -> None:
+def _print_objs_tabular(objs: List, print_colorized: bool, base_dir: Path) -> None:
     if print_colorized:
         colorama_init(autoreset=True)
         red = Fore.RED
@@ -53,7 +55,7 @@ def _print_objs_tabular(objs: List, print_colorized: bool) -> None:
     names = [s['name'] for s in objs]
     objs_to_print = [{
         'name': s['name'] if s['name'] else "--",
-        'location': s['location_rel'],
+        'location': s['location'].relative_to(base_dir),
         'status': (red + "LOAD FAILED" + reset if s['class'] is None
                    else "OK" if names.count(s['name']) == 1
                    else yellow + "DUPLICATE NAME" + reset)
@@ -74,8 +76,9 @@ def start_list_strategies(args: Dict[str, Any]) -> None:
     """
     config = setup_utils_configuration(args, RunMode.UTIL_NO_EXCHANGE)
 
+    directory = Path(config.get('strategy_path', config['user_data_dir'] / USERPATH_STRATEGIES))
     strategy_objs = StrategyResolver.search_all_objects(
-        config, not args['print_one_column'], config.get('recursive_strategy_search', False))
+        directory, not args['print_one_column'], config.get('recursive_strategy_search', False))
     # Sort alphabetically
     strategy_objs = sorted(strategy_objs, key=lambda x: x['name'])
     for obj in strategy_objs:
@@ -87,22 +90,7 @@ def start_list_strategies(args: Dict[str, Any]) -> None:
     if args['print_one_column']:
         print('\n'.join([s['name'] for s in strategy_objs]))
     else:
-        _print_objs_tabular(strategy_objs, config.get('print_colorized', False))
+        _print_objs_tabular(strategy_objs, config.get('print_colorized', False), directory)
-
-
-def start_list_freqAI_models(args: Dict[str, Any]) -> None:
-    """
-    Print files with FreqAI models custom classes available in the directory
-    """
-    config = setup_utils_configuration(args, RunMode.UTIL_NO_EXCHANGE)
-    from freqtrade.resolvers.freqaimodel_resolver import FreqaiModelResolver
-    model_objs = FreqaiModelResolver.search_all_objects(config, not args['print_one_column'])
-    # Sort alphabetically
-    model_objs = sorted(model_objs, key=lambda x: x['name'])
-    if args['print_one_column']:
-        print('\n'.join([s['name'] for s in model_objs]))
-    else:
-        _print_objs_tabular(model_objs, config.get('print_colorized', False))
 
 
 def start_list_timeframes(args: Dict[str, Any]) -> None:

freqtrade/commands/strategy_utils_commands.py

@@ -1,55 +0,0 @@
-import logging
-import sys
-import time
-from pathlib import Path
-from typing import Any, Dict
-
-from freqtrade.configuration import setup_utils_configuration
-from freqtrade.enums import RunMode
-from freqtrade.resolvers import StrategyResolver
-from freqtrade.strategy.strategyupdater import StrategyUpdater
-
-
-logger = logging.getLogger(__name__)
-
-
-def start_strategy_update(args: Dict[str, Any]) -> None:
-    """
-    Start the strategy updating script
-    :param args: Cli args from Arguments()
-    :return: None
-    """
-
-    if sys.version_info == (3, 8):  # pragma: no cover
-        sys.exit("Freqtrade strategy updater requires Python version >= 3.9")
-
-    config = setup_utils_configuration(args, RunMode.UTIL_NO_EXCHANGE)
-
-    strategy_objs = StrategyResolver.search_all_objects(
-        config, enum_failed=False, recursive=config.get('recursive_strategy_search', False))
-
-    filtered_strategy_objs = []
-    if args['strategy_list']:
-        filtered_strategy_objs = [
-            strategy_obj for strategy_obj in strategy_objs
-            if strategy_obj['name'] in args['strategy_list']
-        ]
-
-    else:
-        # Use all available entries.
-        filtered_strategy_objs = strategy_objs
-
-    processed_locations = set()
-    for strategy_obj in filtered_strategy_objs:
-        if strategy_obj['location'] not in processed_locations:
-            processed_locations.add(strategy_obj['location'])
-            start_conversion(strategy_obj, config)
-
-
-def start_conversion(strategy_obj, config):
-    print(f"Conversion of {Path(strategy_obj['location']).name} started.")
-    instance_strategy_updater = StrategyUpdater()
-    start = time.perf_counter()
-    instance_strategy_updater.start(config, strategy_obj)
-    elapsed = time.perf_counter() - start
-    print(f"Conversion of {Path(strategy_obj['location']).name} took {elapsed:.1f} seconds.")

freqtrade/commands/trade_commands.py

@@ -1,5 +1,4 @@
 import logging
-import signal
 from typing import Any, Dict
 
 
@@ -13,20 +12,15 @@ def start_trading(args: Dict[str, Any]) -> int:
     # Import here to avoid loading worker module when it's not used
     from freqtrade.worker import Worker
 
-    def term_handler(signum, frame):
-        # Raise KeyboardInterrupt - so we can handle it in the same way as Ctrl-C
-        raise KeyboardInterrupt()
-
     # Create and run worker
     worker = None
     try:
-        signal.signal(signal.SIGTERM, term_handler)
         worker = Worker(args)
         worker.run()
     except Exception as e:
         logger.error(str(e))
         logger.exception("Fatal exception!")
-    except (KeyboardInterrupt):
+    except KeyboardInterrupt:
         logger.info('SIGINT received, aborting ...')
     finally:
         if worker:

freqtrade/configuration/config_validation.py

@@ -27,7 +27,10 @@ def _extend_validator(validator_class):
             if 'default' in subschema:
                 instance.setdefault(prop, subschema['default'])
 
-        yield from validate_properties(validator, properties, instance, schema)
+        for error in validate_properties(
+            validator, properties, instance, schema,
+        ):
+            yield error
 
     return validators.extend(
         validator_class, {'properties': set_defaults}
@@ -83,8 +86,6 @@ def validate_config_consistency(conf: Dict[str, Any], preliminary: bool = False)
     _validate_unlimited_amount(conf)
     _validate_ask_orderbook(conf)
     _validate_freqai_hyperopt(conf)
-    _validate_freqai_backtest(conf)
-    _validate_freqai_include_timeframes(conf)
     _validate_consumers(conf)
     validate_migrated_strategy_settings(conf)
 
@@ -333,53 +334,6 @@ def _validate_freqai_hyperopt(conf: Dict[str, Any]) -> None:
             'Using analyze-per-epoch parameter is not supported with a FreqAI strategy.')
 
 
-def _validate_freqai_include_timeframes(conf: Dict[str, Any]) -> None:
-    freqai_enabled = conf.get('freqai', {}).get('enabled', False)
-    if freqai_enabled:
-        main_tf = conf.get('timeframe', '5m')
-        freqai_include_timeframes = conf.get('freqai', {}).get('feature_parameters', {}
-                                                               ).get('include_timeframes', [])
-
-        from freqtrade.exchange import timeframe_to_seconds
-        main_tf_s = timeframe_to_seconds(main_tf)
-        offending_lines = []
-        for tf in freqai_include_timeframes:
-            tf_s = timeframe_to_seconds(tf)
-            if tf_s < main_tf_s:
-                offending_lines.append(tf)
-        if offending_lines:
-            raise OperationalException(
-                f"Main timeframe of {main_tf} must be smaller or equal to FreqAI "
-                f"`include_timeframes`.Offending include-timeframes: {', '.join(offending_lines)}")
-
-        # Ensure that the base timeframe is included in the include_timeframes list
-        if main_tf not in freqai_include_timeframes:
-            feature_parameters = conf.get('freqai', {}).get('feature_parameters', {})
-            include_timeframes = [main_tf] + freqai_include_timeframes
-            conf.get('freqai', {}).get('feature_parameters', {}) \
-                .update({**feature_parameters, 'include_timeframes': include_timeframes})
-
-
-def _validate_freqai_backtest(conf: Dict[str, Any]) -> None:
-    if conf.get('runmode', RunMode.OTHER) == RunMode.BACKTEST:
-        freqai_enabled = conf.get('freqai', {}).get('enabled', False)
-        timerange = conf.get('timerange')
-        freqai_backtest_live_models = conf.get('freqai_backtest_live_models', False)
-        if freqai_backtest_live_models and freqai_enabled and timerange:
-            raise OperationalException(
-                'Using timerange parameter is not supported with '
-                '--freqai-backtest-live-models parameter.')
-
-        if freqai_backtest_live_models and not freqai_enabled:
-            raise OperationalException(
-                'Using --freqai-backtest-live-models parameter is only '
-                'supported with a FreqAI strategy.')
-
-        if freqai_enabled and not freqai_backtest_live_models and not timerange:
-            raise OperationalException(
-                'Please pass --timerange if you intend to use FreqAI for backtesting.')
-
-
 def _validate_consumers(conf: Dict[str, Any]) -> None:
     emc_conf = conf.get('external_message_consumer', {})
     if emc_conf.get('enabled', False):

freqtrade/configuration/configuration.py

@@ -28,7 +28,7 @@ class Configuration:
     Reuse this class for the bot, backtesting, hyperopt and every script that required configuration
     """
 
-    def __init__(self, args: Dict[str, Any], runmode: Optional[RunMode] = None) -> None:
+    def __init__(self, args: Dict[str, Any], runmode: RunMode = None) -> None:
         self.args = args
         self.config: Optional[Config] = None
         self.runmode = runmode
@@ -279,9 +279,6 @@ class Configuration:
         self._args_to_config(config, argname='disableparamexport',
                              logstring='Parameter --disableparamexport detected: {} ...')
 
-        self._args_to_config(config, argname='freqai_backtest_live_models',
-                             logstring='Parameter --freqai-backtest-live-models detected ...')
-
         # Edge section:
         if 'stoploss_range' in self.args and self.args["stoploss_range"]:
             txt_range = eval(self.args["stoploss_range"])
@@ -462,9 +459,6 @@ class Configuration:
         self._args_to_config(config, argname='indicator_list',
                              logstring='Analysis indicator list: {}')
 
-        self._args_to_config(config, argname='timerange',
-                             logstring='Filter trades by timerange: {}')
-
     def _process_runmode(self, config: Config) -> None:
 
         self._args_to_config(config, argname='dry_run',

freqtrade/configuration/directory_operations.py

@@ -3,8 +3,7 @@ import shutil
 from pathlib import Path
 from typing import Optional
 
-from freqtrade.constants import (USER_DATA_FILES, USERPATH_FREQAIMODELS, USERPATH_HYPEROPTS,
+from freqtrade.constants import USER_DATA_FILES, Config
-                                 USERPATH_NOTEBOOKS, USERPATH_STRATEGIES, Config)
 from freqtrade.exceptions import OperationalException
 
 
@@ -50,8 +49,8 @@ def create_userdata_dir(directory: str, create_dir: bool = False) -> Path:
     :param create_dir: Create directory if it does not exist.
     :return: Path object containing the directory
     """
-    sub_dirs = ["backtest_results", "data", USERPATH_HYPEROPTS, "hyperopt_results", "logs",
+    sub_dirs = ["backtest_results", "data", "hyperopts", "hyperopt_results", "logs",
-                USERPATH_NOTEBOOKS, "plot", USERPATH_STRATEGIES, USERPATH_FREQAIMODELS]
+                "notebooks", "plot", "strategies", ]
     folder = Path(directory)
     chown_user_directory(folder)
     if not folder.is_dir():

freqtrade/configuration/environment_vars.py

@@ -32,7 +32,7 @@ def flat_vars_to_nested_dict(env_dict: Dict[str, Any], prefix: str) -> Dict[str,
     :param prefix: Prefix to consider (usually FREQTRADE__)
     :return: Nested dict based on available and relevant variables.
     """
-    no_convert = ['CHAT_ID', 'PASSWORD']
+    no_convert = ['CHAT_ID']
     relevant_vars: Dict[str, Any] = {}
 
     for env_var, val in sorted(env_dict.items()):

freqtrade/configuration/load_config.py

@@ -6,7 +6,7 @@ import re
 import sys
 from copy import deepcopy
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List
 
 import rapidjson
 
@@ -58,7 +58,7 @@ def load_config_file(path: str) -> Dict[str, Any]:
     """
     try:
         # Read config from stdin if requested in the options
-        with Path(path).open() if path != '-' else sys.stdin as file:
+        with open(path) if path != '-' else sys.stdin as file:
             config = rapidjson.load(file, parse_mode=CONFIG_PARSE_MODE)
     except FileNotFoundError:
         raise OperationalException(
@@ -75,8 +75,7 @@ def load_config_file(path: str) -> Dict[str, Any]:
     return config
 
 
-def load_from_files(
+def load_from_files(files: List[str], base_path: Path = None, level: int = 0) -> Dict[str, Any]:
-        files: List[str], base_path: Optional[Path] = None, level: int = 0) -> Dict[str, Any]:
     """
     Recursively load configuration files if specified.
     Sub-files are assumed to be relative to the initial config.

freqtrade/configuration/timerange.py

@@ -3,12 +3,11 @@ This module contains the argument manager class
 """
 import logging
 import re
-from datetime import datetime, timezone
+from datetime import datetime
 from typing import Optional
 
 import arrow
 
-from freqtrade.constants import DATETIME_PRINT_FORMAT
 from freqtrade.exceptions import OperationalException
 
 
@@ -30,52 +29,6 @@ class TimeRange:
         self.startts: int = startts
         self.stopts: int = stopts
 
-    @property
-    def startdt(self) -> Optional[datetime]:
-        if self.startts:
-            return datetime.fromtimestamp(self.startts, tz=timezone.utc)
-        return None
-
-    @property
-    def stopdt(self) -> Optional[datetime]:
-        if self.stopts:
-            return datetime.fromtimestamp(self.stopts, tz=timezone.utc)
-        return None
-
-    @property
-    def timerange_str(self) -> str:
-        """
-        Returns a string representation of the timerange as used by parse_timerange.
-        Follows the format yyyymmdd-yyyymmdd - leaving out the parts that are not set.
-        """
-        start = ''
-        stop = ''
-        if startdt := self.startdt:
-            start = startdt.strftime('%Y%m%d')
-        if stopdt := self.stopdt:
-            stop = stopdt.strftime('%Y%m%d')
-        return f"{start}-{stop}"
-
-    @property
-    def start_fmt(self) -> str:
-        """
-        Returns a string representation of the start date
-        """
-        val = 'unbounded'
-        if (startdt := self.startdt) is not None:
-            val = startdt.strftime(DATETIME_PRINT_FORMAT)
-        return val
-
-    @property
-    def stop_fmt(self) -> str:
-        """
-        Returns a string representation of the stop date
-        """
-        val = 'unbounded'
-        if (stopdt := self.stopdt) is not None:
-            val = stopdt.strftime(DATETIME_PRINT_FORMAT)
-        return val
-
     def __eq__(self, other):
         """Override the default Equals behavior"""
         return (self.starttype == other.starttype and self.stoptype == other.stoptype
@@ -116,7 +69,7 @@ class TimeRange:
         :param text: value from --timerange
         :return: Start and End range period
         """
-        if not text:
+        if text is None:
             return TimeRange(None, None, 0, 0)
         syntax = [(r'^-(\d{8})$', (None, 'date')),
                   (r'^(\d{8})-$', ('date', None)),

freqtrade/constants.py

@@ -5,7 +5,7 @@ bot constants
 """
 from typing import Any, Dict, List, Literal, Tuple
 
-from freqtrade.enums import CandleType, PriceType, RPCMessageType
+from freqtrade.enums import CandleType
 
 
 DEFAULT_CONFIG = 'config.json'
@@ -25,21 +25,19 @@ PRICING_SIDES = ['ask', 'bid', 'same', 'other']
 ORDERTYPE_POSSIBILITIES = ['limit', 'market']
 _ORDERTIF_POSSIBILITIES = ['GTC', 'FOK', 'IOC', 'PO']
 ORDERTIF_POSSIBILITIES = _ORDERTIF_POSSIBILITIES + [t.lower() for t in _ORDERTIF_POSSIBILITIES]
-STOPLOSS_PRICE_TYPES = [p for p in PriceType]
 HYPEROPT_LOSS_BUILTIN = ['ShortTradeDurHyperOptLoss', 'OnlyProfitHyperOptLoss',
                          'SharpeHyperOptLoss', 'SharpeHyperOptLossDaily',
                          'SortinoHyperOptLoss', 'SortinoHyperOptLossDaily',
                          'CalmarHyperOptLoss',
                          'MaxDrawDownHyperOptLoss', 'MaxDrawDownRelativeHyperOptLoss',
                          'ProfitDrawDownHyperOptLoss']
-AVAILABLE_PAIRLISTS = ['StaticPairList', 'VolumePairList', 'ProducerPairList', 'RemotePairList',
+AVAILABLE_PAIRLISTS = ['StaticPairList', 'VolumePairList', 'ProducerPairList',
                        'AgeFilter', 'OffsetFilter', 'PerformanceFilter',
                        'PrecisionFilter', 'PriceFilter', 'RangeStabilityFilter',
                        'ShuffleFilter', 'SpreadFilter', 'VolatilityFilter']
-AVAILABLE_PROTECTIONS = ['CooldownPeriod',
+AVAILABLE_PROTECTIONS = ['CooldownPeriod', 'LowProfitPairs', 'MaxDrawdown', 'StoplossGuard']
-                         'LowProfitPairs', 'MaxDrawdown', 'StoplossGuard']
+AVAILABLE_DATAHANDLERS_TRADES = ['json', 'jsongz', 'hdf5']
-AVAILABLE_DATAHANDLERS_TRADES = ['json', 'jsongz', 'hdf5', 'feather']
+AVAILABLE_DATAHANDLERS = AVAILABLE_DATAHANDLERS_TRADES + ['feather', 'parquet']
-AVAILABLE_DATAHANDLERS = AVAILABLE_DATAHANDLERS_TRADES + ['parquet']
 BACKTEST_BREAKDOWNS = ['day', 'week', 'month']
 BACKTEST_CACHE_AGE = ['none', 'day', 'week', 'month']
 BACKTEST_CACHE_DEFAULT = 'day'
@@ -63,8 +61,6 @@ USERPATH_FREQAIMODELS = 'freqaimodels'
 
 TELEGRAM_SETTING_OPTIONS = ['on', 'off', 'silent']
 WEBHOOK_FORMAT_OPTIONS = ['form', 'json', 'raw']
-FULL_DATAFRAME_THRESHOLD = 100
-CUSTOM_TAG_MAX_LENGTH = 255
 
 ENV_VAR_PREFIX = 'FREQTRADE__'
 
@@ -163,7 +159,6 @@ CONF_SCHEMA = {
         'ignore_buying_expired_candle_after': {'type': 'number'},
         'trading_mode': {'type': 'string', 'enum': TRADING_MODES},
         'margin_mode': {'type': 'string', 'enum': MARGIN_MODES},
-        'reduce_df_footprint': {'type': 'boolean', 'default': False},
         'liquidation_buffer': {'type': 'number', 'minimum': 0.0, 'maximum': 0.99},
         'backtest_breakdown': {
             'type': 'array',
@@ -232,7 +227,6 @@ CONF_SCHEMA = {
                     'default': 'market'},
                 'stoploss': {'type': 'string', 'enum': ORDERTYPE_POSSIBILITIES},
                 'stoploss_on_exchange': {'type': 'boolean'},
-                'stoploss_price_type': {'type': 'string', 'enum': STOPLOSS_PRICE_TYPES},
                 'stoploss_on_exchange_interval': {'type': 'number'},
                 'stoploss_on_exchange_limit_ratio': {'type': 'number', 'minimum': 0.0,
                                                      'maximum': 1.0}
@@ -288,7 +282,6 @@ CONF_SCHEMA = {
                 'enabled': {'type': 'boolean'},
                 'token': {'type': 'string'},
                 'chat_id': {'type': 'string'},
-                'allow_custom_messages': {'type': 'boolean', 'default': True},
                 'balance_dust_level': {'type': 'number', 'minimum': 0.0},
                 'notification_settings': {
                     'type': 'object',
@@ -351,8 +344,6 @@ CONF_SCHEMA = {
                 'format': {'type': 'string', 'enum': WEBHOOK_FORMAT_OPTIONS, 'default': 'form'},
                 'retries': {'type': 'integer', 'minimum': 0},
                 'retry_delay': {'type': 'number', 'minimum': 0},
-                **dict([(x, {'type': 'object'}) for x in RPCMessageType]),
-                # Below -> Deprecated
                 'webhookentry': {'type': 'object'},
                 'webhookentrycancel': {'type': 'object'},
                 'webhookentryfill': {'type': 'object'},
@@ -517,7 +508,6 @@ CONF_SCHEMA = {
                                 'minimum': 0,
                                 'maximum': 65535
                             },
-                            'secure': {'type': 'boolean', 'default': False},
                             'ws_token': {'type': 'string'},
                         },
                         'required': ['name', 'host', 'ws_token']
@@ -547,9 +537,7 @@ CONF_SCHEMA = {
             "properties": {
                 "enabled": {"type": "boolean", "default": False},
                 "keras": {"type": "boolean", "default": False},
-                "write_metrics_to_disk": {"type": "boolean", "default": False},
+                "conv_width": {"type": "integer", "default": 2},
-                "purge_old_models": {"type": ["boolean", "number"], "default": 2},
-                "conv_width": {"type": "integer", "default": 1},
                 "train_period_days": {"type": "integer", "default": 0},
                 "backtest_period_days": {"type": "number", "default": 7},
                 "identifier": {"type": "string", "default": "example"},
@@ -570,9 +558,7 @@ CONF_SCHEMA = {
                                            "shuffle": {"type": "boolean", "default": False},
                                            "nu": {"type": "number", "default": 0.1}
                                            },
-                                       },
+                                       }
-                        "shuffle_after_split": {"type": "boolean", "default": False},
-                        "buffer_train_data_candles": {"type": "integer", "default": 0}
                     },
                     "required": ["include_timeframes", "include_corr_pairlist", ]
                 },
@@ -587,28 +573,6 @@ CONF_SCHEMA = {
                 "model_training_parameters": {
                     "type": "object"
                 },
-                "rl_config": {
-                    "type": "object",
-                    "properties": {
-                        "drop_ohlc_from_features": {"type": "boolean", "default": False},
-                        "train_cycles": {"type": "integer"},
-                        "max_trade_duration_candles": {"type": "integer"},
-                        "add_state_info": {"type": "boolean", "default": False},
-                        "max_training_drawdown_pct": {"type": "number", "default": 0.02},
-                        "cpu_count": {"type": "integer", "default": 1},
-                        "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},
-                        "model_reward_parameters": {
-                            "type": "object",
-                            "properties": {
-                                "rr": {"type": "number", "default": 1},
-                                "profit_aim": {"type": "number", "default": 0.025}
-                            }
-                        }
-                    },
-                },
             },
             "required": [
                 "enabled",
@@ -616,8 +580,9 @@ CONF_SCHEMA = {
                 "backtest_period_days",
                 "identifier",
                 "feature_parameters",
-                "data_split_parameters"
+                "data_split_parameters",
-            ]
+                "model_training_parameters"
+                ]
         },
     },
 }
@@ -643,6 +608,7 @@ SCHEMA_TRADE_REQUIRED = [
 
 SCHEMA_BACKTEST_REQUIRED = [
     'exchange',
+    'max_open_trades',
     'stake_currency',
     'stake_amount',
     'dry_run_wallet',
@@ -652,7 +618,6 @@ SCHEMA_BACKTEST_REQUIRED = [
 SCHEMA_BACKTEST_REQUIRED_FINAL = SCHEMA_BACKTEST_REQUIRED + [
     'stoploss',
     'minimal_roi',
-    'max_open_trades'
 ]
 
 SCHEMA_MINIMAL_REQUIRED = [
@@ -685,8 +650,5 @@ LongShort = Literal['long', 'short']
 EntryExit = Literal['entry', 'exit']
 BuySell = Literal['buy', 'sell']
 MakerTaker = Literal['maker', 'taker']
-BidAsk = Literal['bid', 'ask']
-OBLiteral = Literal['asks', 'bids']
 
 Config = Dict[str, Any]
-IntOrInf = float

freqtrade/data/btanalysis.py

@@ -10,7 +10,7 @@ from typing import Any, Dict, List, Optional, Union
 import numpy as np
 import pandas as pd
 
-from freqtrade.constants import LAST_BT_RESULT_FN, IntOrInf
+from freqtrade.constants import LAST_BT_RESULT_FN
 from freqtrade.exceptions import OperationalException
 from freqtrade.misc import json_load
 from freqtrade.optimize.backtest_caching import get_backtest_metadata_filename
@@ -20,13 +20,13 @@ from freqtrade.persistence import LocalTrade, Trade, init_db
 logger = logging.getLogger(__name__)
 
 # Newest format
-BT_DATA_COLUMNS = ['pair', 'stake_amount', 'max_stake_amount', 'amount',
+BT_DATA_COLUMNS = ['pair', 'stake_amount', 'amount', 'open_date', 'close_date',
-                   'open_date', 'close_date', 'open_rate', 'close_rate',
+                   'open_rate', 'close_rate',
                    'fee_open', 'fee_close', 'trade_duration',
                    'profit_ratio', 'profit_abs', 'exit_reason',
                    'initial_stop_loss_abs', 'initial_stop_loss_ratio', 'stop_loss_abs',
                    'stop_loss_ratio', 'min_rate', 'max_rate', 'is_open', 'enter_tag',
-                   'leverage', 'is_short', 'open_timestamp', 'close_timestamp', 'orders'
+                   'is_short', 'open_timestamp', 'close_timestamp', 'orders'
                    ]
 
 
@@ -90,8 +90,7 @@ def get_latest_hyperopt_filename(directory: Union[Path, str]) -> str:
         return 'hyperopt_results.pickle'
 
 
-def get_latest_hyperopt_file(
+def get_latest_hyperopt_file(directory: Union[Path, str], predef_filename: str = None) -> Path:
-        directory: Union[Path, str], predef_filename: Optional[str] = None) -> Path:
     """
     Get latest hyperopt export based on '.last_result.json'.
     :param directory: Directory to search for last result
@@ -194,7 +193,7 @@ def get_backtest_resultlist(dirname: Path):
 
 
 def find_existing_backtest_stats(dirname: Union[Path, str], run_ids: Dict[str, str],
-                                 min_backtest_date: Optional[datetime] = None) -> Dict[str, Any]:
+                                 min_backtest_date: datetime = None) -> Dict[str, Any]:
     """
     Find existing backtest stats that match specified run IDs and load them.
     :param dirname: pathlib.Path object, or string pointing to the file.
@@ -242,27 +241,6 @@ def find_existing_backtest_stats(dirname: Union[Path, str], run_ids: Dict[str, s
     return results
 
 
-def _load_backtest_data_df_compatibility(df: pd.DataFrame) -> pd.DataFrame:
-    """
-    Compatibility support for older backtest data.
-    """
-    df['open_date'] = pd.to_datetime(df['open_date'], utc=True)
-    df['close_date'] = pd.to_datetime(df['close_date'], utc=True)
-    # Compatibility support for pre short Columns
-    if 'is_short' not in df.columns:
-        df['is_short'] = False
-    if 'leverage' not in df.columns:
-        df['leverage'] = 1.0
-    if 'enter_tag' not in df.columns:
-        df['enter_tag'] = df['buy_tag']
-        df = df.drop(['buy_tag'], axis=1)
-    if 'max_stake_amount' not in df.columns:
-        df['max_stake_amount'] = df['stake_amount']
-    if 'orders' not in df.columns:
-        df['orders'] = None
-    return df
-
-
 def load_backtest_data(filename: Union[Path, str], strategy: Optional[str] = None) -> pd.DataFrame:
     """
     Load backtest data file.
@@ -291,7 +269,22 @@ def load_backtest_data(filename: Union[Path, str], strategy: Optional[str] = Non
         data = data['strategy'][strategy]['trades']
         df = pd.DataFrame(data)
         if not df.empty:
-            df = _load_backtest_data_df_compatibility(df)
+            df['open_date'] = pd.to_datetime(df['open_date'],
+                                             utc=True,
+                                             infer_datetime_format=True
+                                             )
+            df['close_date'] = pd.to_datetime(df['close_date'],
+                                              utc=True,
+                                              infer_datetime_format=True
+                                              )
+            # Compatibility support for pre short Columns
+            if 'is_short' not in df.columns:
+                df['is_short'] = 0
+            if 'enter_tag' not in df.columns:
+                df['enter_tag'] = df['buy_tag']
+                df = df.drop(['buy_tag'], axis=1)
+            if 'orders' not in df.columns:
+                df['orders'] = None
 
     else:
         # old format - only with lists.
@@ -327,7 +320,7 @@ def analyze_trade_parallelism(results: pd.DataFrame, timeframe: str) -> pd.DataF
 
 
 def evaluate_result_multi(results: pd.DataFrame, timeframe: str,
-                          max_open_trades: IntOrInf) -> pd.DataFrame:
+                          max_open_trades: int) -> pd.DataFrame:
     """
     Find overlapping trades by expanding each trade once per period it was open
     and then counting overlaps
@@ -340,7 +333,7 @@ def evaluate_result_multi(results: pd.DataFrame, timeframe: str,
     return df_final[df_final['open_trades'] > max_open_trades]
 
 
-def trade_list_to_dataframe(trades: Union[List[Trade], List[LocalTrade]]) -> pd.DataFrame:
+def trade_list_to_dataframe(trades: List[LocalTrade]) -> pd.DataFrame:
     """
     Convert list of Trade objects to pandas Dataframe
     :param trades: List of trade objects
@@ -367,7 +360,7 @@ def load_trades_from_db(db_url: str, strategy: Optional[str] = None) -> pd.DataF
     filters = []
     if strategy:
         filters.append(Trade.strategy == strategy)
-    trades = trade_list_to_dataframe(list(Trade.get_trades(filters).all()))
+    trades = trade_list_to_dataframe(Trade.get_trades(filters).all())
 
     return trades
 

freqtrade/data/converter.py

@@ -3,10 +3,10 @@ Functions to convert data from one format to another
 """
 import itertools
 import logging
+from datetime import datetime, timezone
 from operator import itemgetter
 from typing import Dict, List
 
-import numpy as np
 import pandas as pd
 from pandas import DataFrame, to_datetime
 
@@ -34,7 +34,7 @@ def ohlcv_to_dataframe(ohlcv: list, timeframe: str, pair: str, *,
     cols = DEFAULT_DATAFRAME_COLUMNS
     df = DataFrame(ohlcv, columns=cols)
 
-    df['date'] = to_datetime(df['date'], unit='ms', utc=True)
+    df['date'] = to_datetime(df['date'], unit='ms', utc=True, infer_datetime_format=True)
 
     # Some exchanges return int values for Volume and even for OHLC.
     # Convert them since TA-LIB indicators used in the strategy assume floats
@@ -137,9 +137,11 @@ def trim_dataframe(df: DataFrame, timerange, df_date_col: str = 'date',
         df = df.iloc[startup_candles:, :]
     else:
         if timerange.starttype == 'date':
-            df = df.loc[df[df_date_col] >= timerange.startdt, :]
+            start = datetime.fromtimestamp(timerange.startts, tz=timezone.utc)
+            df = df.loc[df[df_date_col] >= start, :]
     if timerange.stoptype == 'date':
-        df = df.loc[df[df_date_col] <= timerange.stopdt, :]
+        stop = datetime.fromtimestamp(timerange.stopts, tz=timezone.utc)
+        df = df.loc[df[df_date_col] <= stop, :]
     return df
 
 
@@ -311,29 +313,3 @@ def convert_ohlcv_format(
                 if erase and convert_from != convert_to:
                     logger.info(f"Deleting source data for {pair} / {timeframe}")
                     src.ohlcv_purge(pair=pair, timeframe=timeframe, candle_type=candle_type)
-
-
-def reduce_dataframe_footprint(df: DataFrame) -> DataFrame:
-    """
-    Ensure all values are float32 in the incoming dataframe.
-    :param df: Dataframe to be converted to float/int 32s
-    :return: Dataframe converted to float/int 32s
-    """
-
-    logger.debug(f"Memory usage of dataframe is "
-                 f"{df.memory_usage().sum() / 1024**2:.2f} MB")
-
-    df_dtypes = df.dtypes
-    for column, dtype in df_dtypes.items():
-        if column in ['open', 'high', 'low', 'close', 'volume']:
-            continue
-        if dtype == np.float64:
-            df_dtypes[column] = np.float32
-        elif dtype == np.int64:
-            df_dtypes[column] = np.int32
-    df = df.astype(df_dtypes)
-
-    logger.debug(f"Memory usage after optimization is: "
-                 f"{df.memory_usage().sum() / 1024**2:.2f} MB")
-
-    return df