Merge pull request #4004 from freqtrade/new_release

New release 2020.11

.devcontainer/Dockerfile

@@ -0,0 +1,18 @@
+FROM freqtradeorg/freqtrade:develop
+
+# Install dependencies
+COPY requirements-dev.txt /freqtrade/
+RUN apt-get update \
+    && apt-get -y install git sudo vim \
+    && apt-get clean \
+    && pip install autopep8 -r docs/requirements-docs.txt -r requirements-dev.txt --no-cache-dir \
+    && useradd -u 1000 -U -m ftuser \
+    && mkdir -p /home/ftuser/.vscode-server /home/ftuser/.vscode-server-insiders /home/ftuser/commandhistory \
+    && echo "export PROMPT_COMMAND='history -a'" >> /home/ftuser/.bashrc \
+    && echo "export HISTFILE=~/commandhistory/.bash_history" >> /home/ftuser/.bashrc \
+    && chown ftuser: -R /home/ftuser/
+
+USER ftuser
+
+# Empty the ENTRYPOINT to allow all commands
+ENTRYPOINT []

.devcontainer/devcontainer.json

@@ -0,0 +1,44 @@
+{
+    "name": "freqtrade Develop",
+
+    "dockerComposeFile": [
+        "docker-compose.yml"
+    ],
+
+    "service": "ft_vscode",
+
+    "workspaceFolder": "/freqtrade/",
+
+    "settings": {
+        "terminal.integrated.shell.linux": "/bin/bash",
+        "editor.insertSpaces": true,
+        "files.trimTrailingWhitespace": true,
+        "[markdown]": {
+            "files.trimTrailingWhitespace": false,
+        },
+        "python.pythonPath": "/usr/local/bin/python",
+    },
+
+    // Add the IDs of extensions you want installed when the container is created.
+    "extensions": [
+        "ms-python.python",
+        "ms-python.vscode-pylance",
+        "davidanson.vscode-markdownlint",
+        "ms-azuretools.vscode-docker",
+    ],
+
+    // Use 'forwardPorts' to make a list of ports inside the container available locally.
+    // "forwardPorts": [],
+
+    // Uncomment the next line if you want start specific services in your Docker Compose config.
+    // "runServices": [],
+
+    // Uncomment the next line if you want to keep your containers running after VS Code shuts down.
+    // "shutdownAction": "none",
+
+    // Uncomment the next line to run commands after the container is created - for example installing curl.
+    // "postCreateCommand": "sudo apt-get update && apt-get install -y git",
+
+    // Uncomment to connect as a non-root user if you've added one. See https://aka.ms/vscode-remote/containers/non-root.
+    "remoteUser": "ftuser"
+}

.devcontainer/docker-compose.yml

@@ -0,0 +1,24 @@
+---
+version: '3'
+services:
+  ft_vscode:
+    build:
+      context: ..
+      dockerfile: ".devcontainer/Dockerfile"
+    volumes:
+      # Allow git usage within container
+      - "${HOME}/.ssh:/home/ftuser/.ssh:ro"
+      - "${HOME}/.gitconfig:/home/ftuser/.gitconfig:ro"
+      - ..:/freqtrade:cached
+      # Persist bash-history
+      - freqtrade-vscode-server:/home/ftuser/.vscode-server
+      - freqtrade-bashhistory:/home/ftuser/commandhistory
+    # Expose API port
+    ports:
+      - "127.0.0.1:8080:8080"
+    command: /bin/sh -c "while sleep 1000; do :; done"
+
+
+volumes:
+  freqtrade-vscode-server:
+  freqtrade-bashhistory:

.dockerignore

@@ -13,3 +13,4 @@ CONTRIBUTING.md
 MANIFEST.in
 README.md
 freqtrade.service
+user_data

.github/workflows/ci.yml

@@ -4,11 +4,11 @@ on:
   push:
     branches:
       - master
+      - stable
       - develop
-      - github_actions_tests
     tags:
-    release:
-      types: [published]
+  release:
+    types: [published]
   pull_request:
   schedule:
     - cron:  '0 5 * * 4'
@@ -19,14 +19,14 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ ubuntu-18.04, macos-latest ]
+        os: [ ubuntu-18.04, ubuntu-20.04, macos-latest ]
         python-version: [3.7, 3.8]
 
     steps:
     - uses: actions/checkout@v2
 
     - name: Set up Python
-      uses: actions/setup-python@v1
+      uses: actions/setup-python@v2
       with:
         python-version: ${{ matrix.python-version }}
 
@@ -70,7 +70,7 @@ jobs:
         pytest --random-order --cov=freqtrade --cov-config=.coveragerc
 
     - name: Coveralls
-      if: (startsWith(matrix.os, 'ubuntu') && matrix.python-version == '3.8')
+      if: (startsWith(matrix.os, 'ubuntu-20') && matrix.python-version == '3.8')
       env:
         # Coveralls token. Not used as secret due to github not providing secrets to forked repositories
         COVERALLS_REPO_TOKEN: 6D1m0xupS3FgutfuGao8keFf9Hc0FpIXu
@@ -88,12 +88,16 @@ jobs:
       run: |
         cp config.json.example config.json
         freqtrade create-userdir --userdir user_data
-        freqtrade hyperopt --datadir tests/testdata -e 5 --strategy SampleStrategy --hyperopt SampleHyperOpt --print-all
+        freqtrade hyperopt --datadir tests/testdata -e 5 --strategy SampleStrategy --hyperopt SampleHyperOpt --hyperopt-loss SharpeHyperOptLossDaily --print-all
 
     - name: Flake8
       run: |
         flake8
 
+    - name: Sort imports (isort)
+      run: |
+        isort --check .
+
     - name: Mypy
       run: |
         mypy freqtrade scripts
@@ -121,7 +125,7 @@ jobs:
     - uses: actions/checkout@v2
 
     - name: Set up Python
-      uses: actions/setup-python@v1
+      uses: actions/setup-python@v2
       with:
         python-version: ${{ matrix.python-version }}
 
@@ -150,7 +154,7 @@ jobs:
       run: |
         cp config.json.example config.json
         freqtrade create-userdir --userdir user_data
-        freqtrade hyperopt --datadir tests/testdata -e 5 --strategy SampleStrategy --hyperopt SampleHyperOpt --print-all
+        freqtrade hyperopt --datadir tests/testdata -e 5 --strategy SampleStrategy --hyperopt SampleHyperOpt --hyperopt-loss SharpeHyperOptLossDaily --print-all
 
     - name: Flake8
       run: |
@@ -172,7 +176,7 @@ jobs:
         url: ${{ secrets.SLACK_WEBHOOK }}
 
   docs_check:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
     steps:
     - uses: actions/checkout@v2
 
@@ -180,6 +184,17 @@ jobs:
       run: |
         ./tests/test_docs.sh
 
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.8
+
+    - name: Documentation build
+      run: |
+        pip install -r docs/requirements-docs.txt
+        pip install mkdocs
+        mkdocs build
+
     - name: Slack Notification
       uses: homoluctus/slatify@v1.8.0
       if: failure() && ( github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork == false)
@@ -190,18 +205,18 @@ jobs:
         url: ${{ secrets.SLACK_WEBHOOK }}
 
   cleanup-prior-runs:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
     steps:
     - name: Cleanup previous runs on this branch
       uses: rokroskar/workflow-run-cleanup-action@v0.2.2
-      if: "!startsWith(github.ref, 'refs/tags/') && github.ref != 'refs/heads/master' && github.repository == 'freqtrade/freqtrade'"
+      if: "!startsWith(github.ref, 'refs/tags/') && github.ref != 'refs/heads/stable' && github.repository == 'freqtrade/freqtrade'"
       env:
         GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
 
   # Notify on slack only once - when CI completes (and after deploy) in case it's successfull
   notify-complete:
     needs: [ build, build_windows, docs_check ]
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
     steps:
     - name: Slack Notification
       uses: homoluctus/slatify@v1.8.0
@@ -214,19 +229,19 @@ jobs:
 
   deploy:
     needs: [ build, build_windows, docs_check ]
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04
     if: (github.event_name == 'push' || github.event_name == 'schedule' || github.event_name == 'release') && github.repository == 'freqtrade/freqtrade'
     steps:
     - uses: actions/checkout@v2
 
     - name: Set up Python
-      uses: actions/setup-python@v1
+      uses: actions/setup-python@v2
       with:
         python-version: 3.8
 
     - name: Extract branch name
       shell: bash
-      run: echo "##[set-output name=branch;]$(echo ${GITHUB_REF#refs/heads/})"
+      run: echo "##[set-output name=branch;]$(echo ${GITHUB_REF##*/})"
       id: extract_branch
 
     - name: Build distribution
@@ -236,7 +251,7 @@ jobs:
 
     - name: Publish to PyPI (Test)
       uses: pypa/gh-action-pypi-publish@master
-      if: (steps.extract_branch.outputs.branch == 'master' || github.event_name == 'release')
+      if: (github.event_name == 'release')
       with:
         user: __token__
         password: ${{ secrets.pypi_test_password }}
@@ -244,7 +259,7 @@ jobs:
 
     - name: Publish to PyPI
       uses: pypa/gh-action-pypi-publish@master
-      if: (steps.extract_branch.outputs.branch == 'master' || github.event_name == 'release')
+      if: (github.event_name == 'release')
       with:
         user: __token__
         password: ${{ secrets.pypi_password }}

.github/workflows/docker_update_readme.yml

@@ -2,7 +2,7 @@ name: Update Docker Hub Description
 on:
   push:
     branches:
-    - master
+    - stable
 
 jobs:
   dockerHubDescription:

.travis.yml

@@ -33,7 +33,7 @@ jobs:
     - script:
       - cp config.json.example config.json
       - freqtrade create-userdir --userdir user_data
-      - freqtrade hyperopt --datadir tests/testdata -e 5 --strategy SampleStrategy --hyperopt SampleHyperOpt
+      - freqtrade hyperopt --datadir tests/testdata -e 5 --strategy SampleStrategy --hyperopt SampleHyperOpt --hyperopt-loss SharpeHyperOptLossDaily
       name: hyperopt
     - script: flake8
       name: flake8

CONTRIBUTING.md

@@ -8,17 +8,17 @@ Issues labeled [good first issue](https://github.com/freqtrade/freqtrade/labels/
 
 Few pointers for contributions:
 
-- Create your PR against the `develop` branch, not `master`.
-- New features need to contain unit tests and must be PEP8 conformant (max-line-length = 100).
+- Create your PR against the `develop` branch, not `stable`.
+- New features need to contain unit tests, must conform to PEP8 (max-line-length = 100) and should be documented with the introduction PR.
+- PR's can be declared as `[WIP]` - which signify Work in Progress Pull Requests (which are not finished).
 
-If you are unsure, discuss the feature on our [Slack](https://join.slack.com/t/highfrequencybot/shared_invite/enQtNjU5ODcwNjI1MDU3LTU1MTgxMjkzNmYxNWE1MDEzYzQ3YmU4N2MwZjUyNjJjODRkMDVkNjg4YTAyZGYzYzlhOTZiMTE4ZjQ4YzM0OGE)
-or in a [issue](https://github.com/freqtrade/freqtrade/issues) before a PR.
+If you are unsure, discuss the feature on our [discord server](https://discord.gg/MA9v74M), on [Slack](https://join.slack.com/t/highfrequencybot/shared_invite/zt-jaut7r4m-Y17k4x5mcQES9a9swKuxbg) or in a [issue](https://github.com/freqtrade/freqtrade/issues) before a PR.
 
 ## Getting started
 
 Best start by reading the [documentation](https://www.freqtrade.io/) to get a feel for what is possible with the bot, or head straight to the [Developer-documentation](https://www.freqtrade.io/en/latest/developer/) (WIP) which should help you getting started.
 
-## Before sending the PR:
+## Before sending the PR
 
 ### 1. Run unit tests
 
@@ -64,6 +64,14 @@ Guide for installing them is [here](http://flake8.pycqa.org/en/latest/user/using
 mypy freqtrade
 ```
 
+### 4. Ensure all imports are correct
+
+#### Run isort
+
+``` bash
+isort .
+```
+
 ## (Core)-Committer Guide
 
 ### Process: Pull Requests
@@ -114,6 +122,6 @@ Contributors may be given commit privileges. Preference will be given to those w
 1. Access to resources for cross-platform development and testing.
 1. Time to devote to the project regularly.
 
-Being a Committer does not grant write permission on `develop` or `master` for security reasons (Users trust Freqtrade with their Exchange API keys).
+Being a Committer does not grant write permission on `develop` or `stable` for security reasons (Users trust Freqtrade with their Exchange API keys).
 
 After being Committer for some time, a Committer may be named Core Committer and given full repository access.

Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.8.5-slim-buster
+FROM python:3.8.6-slim-buster
 
 RUN apt-get update \
     && apt-get -y install curl build-essential libssl-dev sqlite3 \
@@ -16,13 +16,14 @@ RUN cd /tmp && /tmp/install_ta-lib.sh && rm -r /tmp/*ta-lib*
 ENV LD_LIBRARY_PATH /usr/local/lib
 
 # Install dependencies
-COPY requirements.txt requirements-common.txt requirements-hyperopt.txt /freqtrade/
+COPY requirements.txt requirements-hyperopt.txt /freqtrade/
 RUN pip install numpy --no-cache-dir \
   && pip install -r requirements-hyperopt.txt --no-cache-dir
 
 # Install and execute
 COPY . /freqtrade/
-RUN pip install -e . --no-cache-dir
+RUN pip install -e . --no-cache-dir \
+  && mkdir /freqtrade/user_data/
 ENTRYPOINT ["freqtrade"]
 # Default to trade mode
 CMD [ "trade" ]

Dockerfile.armhf

@@ -17,7 +17,7 @@ RUN cd /tmp && /tmp/install_ta-lib.sh && rm -r /tmp/*ta-lib*
 ENV LD_LIBRARY_PATH /usr/local/lib
 
 # Install dependencies
-COPY requirements.txt requirements-common.txt /freqtrade/
+COPY requirements.txt /freqtrade/
 RUN pip install numpy --no-cache-dir \
   && pip install -r requirements.txt --no-cache-dir
 

README.md

@@ -55,9 +55,8 @@ Please find the complete documentation on our [website](https://www.freqtrade.io
 Freqtrade provides a Linux/macOS script to install all dependencies and help you to configure the bot.
 
 ```bash
-git clone git@github.com:freqtrade/freqtrade.git
+git clone -b develop https://github.com/freqtrade/freqtrade.git 
 cd freqtrade
-git checkout develop
 ./setup.sh --install
 ```
 
@@ -111,34 +110,35 @@ optional arguments:
 
 Telegram is not mandatory. However, this is a great way to control your bot. More details and the full command list on our [documentation](https://www.freqtrade.io/en/latest/telegram-usage/)
 
-- `/start`: Starts the trader
-- `/stop`: Stops the trader
-- `/status [table]`: Lists all open trades
-- `/count`: Displays number of open trades
+- `/start`: Starts the trader.
+- `/stop`: Stops the trader.
+- `/stopbuy`: Stop entering new trades.
+- `/status [table]`: Lists all open trades.
 - `/profit`: Lists cumulative profit from all finished trades
 - `/forcesell <trade_id>|all`: Instantly sells the given trade (Ignoring `minimum_roi`).
 - `/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
-- `/help`: Show help message
-- `/version`: Show version
+- `/balance`: Show account balance per currency.
+- `/daily <n>`: Shows profit or loss per day, over the last n days.
+- `/help`: Show help message.
+- `/version`: Show version.
 
 ## Development branches
 
 The project is currently setup in two main branches:
 
-- `develop` - This branch has often new features, but might also cause breaking changes.
-- `master` - This branch contains the latest stable release. The bot 'should' be stable on this branch, and is generally well tested.
+- `develop` - This branch has often new features, but might also contain breaking changes. We try hard to keep this branch as stable as possible.
+- `stable` - This branch contains the latest stable release. This branch is generally well tested.
 - `feat/*` - These are feature branches, which are being worked on heavily. Please don't use these unless you want to test a specific feature.
 
 ## Support
 
-### Help / Slack
+### Help / Discord / Slack
 
-For any questions not covered by the documentation or for further
-information about the bot, we encourage you to join our slack channel.
+For any questions not covered by the documentation or for further information about the bot, or to simply engage with like-minded individuals, we encourage you to join our slack channel.
 
-- [Click here to join Slack channel](https://join.slack.com/t/highfrequencybot/shared_invite/enQtNjU5ODcwNjI1MDU3LTU1MTgxMjkzNmYxNWE1MDEzYzQ3YmU4N2MwZjUyNjJjODRkMDVkNjg4YTAyZGYzYzlhOTZiMTE4ZjQ4YzM0OGE).
+Please check out our [discord server](https://discord.gg/MA9v74M).
+
+You can also join our [Slack channel](https://join.slack.com/t/highfrequencybot/shared_invite/zt-jaut7r4m-Y17k4x5mcQES9a9swKuxbg).
 
 ### [Bugs / Issues](https://github.com/freqtrade/freqtrade/issues?q=is%3Aissue)
 
@@ -166,18 +166,18 @@ Please read our
 [Contributing document](https://github.com/freqtrade/freqtrade/blob/develop/CONTRIBUTING.md)
 to understand the requirements before sending your pull-requests.
 
-Coding is not a neccessity to contribute - maybe start with improving our documentation?
+Coding is not a necessity to contribute - maybe start with improving our documentation?
 Issues labeled [good first issue](https://github.com/freqtrade/freqtrade/labels/good%20first%20issue) can be good first contributions, and will help get you familiar with the codebase.
 
-**Note** before starting any major new feature work, *please open an issue describing what you are planning to do* or talk to us on [Slack](https://join.slack.com/t/highfrequencybot/shared_invite/enQtNjU5ODcwNjI1MDU3LTU1MTgxMjkzNmYxNWE1MDEzYzQ3YmU4N2MwZjUyNjJjODRkMDVkNjg4YTAyZGYzYzlhOTZiMTE4ZjQ4YzM0OGE). This will ensure that interested parties can give valuable feedback on the feature, and let others know that you are working on it.
+**Note** before starting any major new feature work, *please open an issue describing what you are planning to do* or talk to us on [discord](https://discord.gg/MA9v74M) or [Slack](https://join.slack.com/t/highfrequencybot/shared_invite/zt-jaut7r4m-Y17k4x5mcQES9a9swKuxbg). This will ensure that interested parties can give valuable feedback on the feature, and let others know that you are working on it.
 
-**Important:** Always create your PR against the `develop` branch, not `master`.
+**Important:** Always create your PR against the `develop` branch, not `stable`.
 
 ## Requirements
 
-### Uptodate clock
+### Up-to-date clock
 
-The clock must be accurate, syncronized to a NTP server very frequently to avoid problems with communication to the exchanges.
+The clock must be accurate, synchronized to a NTP server very frequently to avoid problems with communication to the exchanges.
 
 ### Min hardware required
 

build_helpers/install_windows.ps1

@@ -7,10 +7,10 @@ python -m pip install --upgrade pip
 $pyv = python -c "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')"
 
 if ($pyv -eq '3.7') {
-    pip install build_helpers\TA_Lib-0.4.18-cp37-cp37m-win_amd64.whl
+    pip install build_helpers\TA_Lib-0.4.19-cp37-cp37m-win_amd64.whl
 }
 if ($pyv -eq '3.8') {
-    pip install build_helpers\TA_Lib-0.4.18-cp38-cp38-win_amd64.whl
+    pip install build_helpers\TA_Lib-0.4.19-cp38-cp38-win_amd64.whl
 }
 
 pip install -r requirements-dev.txt

build_helpers/publish_docker.sh

@@ -2,6 +2,7 @@
 
 # Replace / with _ to create a valid tag
 TAG=$(echo "${BRANCH_NAME}" | sed -e "s/\//_/g")
+TAG_PLOT=${TAG}_plot
 echo "Running for ${TAG}"
 
 # Add commit and commit_message to docker container
@@ -16,6 +17,12 @@ else
     docker pull ${IMAGE_NAME}:${TAG}
     docker build --cache-from ${IMAGE_NAME}:${TAG} -t freqtrade:${TAG} .
 fi
+# Tag image for upload and next build step
+docker tag freqtrade:$TAG ${IMAGE_NAME}:$TAG
+
+docker build --cache-from freqtrade:${TAG} --build-arg sourceimage=${TAG} -t freqtrade:${TAG_PLOT} -f docker/Dockerfile.plot .
+
+docker tag freqtrade:$TAG_PLOT ${IMAGE_NAME}:$TAG_PLOT
 
 if [ $? -ne 0 ]; then
     echo "failed building image"
@@ -30,8 +37,6 @@ if [ $? -ne 0 ]; then
     return 1
 fi
 
-# Tag image for upload
-docker tag freqtrade:$TAG ${IMAGE_NAME}:$TAG
 if [ $? -ne 0 ]; then
     echo "failed tagging image"
     return 1

config.json.example

@@ -5,16 +5,15 @@
     "tradable_balance_ratio": 0.99,
     "fiat_display_currency": "USD",
     "timeframe": "5m",
-    "dry_run": false,
+    "dry_run": true,
     "cancel_open_orders_on_exit": false,
-    "trailing_stop": false,
     "unfilledtimeout": {
         "buy": 10,
         "sell": 30
     },
     "bid_strategy": {
-        "ask_last_balance": 0.0,
         "use_order_book": false,
+        "ask_last_balance": 0.0,
         "order_book_top": 1,
         "check_depth_of_market": {
             "enabled": false,

config_binance.json.example

@@ -7,7 +7,6 @@
     "timeframe": "5m",
     "dry_run": true,
     "cancel_open_orders_on_exit": false,
-    "trailing_stop": false,
     "unfilledtimeout": {
         "buy": 10,
         "sell": 30

config_full.json.example

@@ -7,7 +7,7 @@
     "amount_reserve_percent": 0.05,
     "amend_last_stake_amount": false,
     "last_stake_amount_min_ratio": 0.5,
-    "dry_run": false,
+    "dry_run": true,
     "cancel_open_orders_on_exit": false,
     "timeframe": "5m",
     "trailing_stop": false,
@@ -67,7 +67,13 @@
         {"method": "AgeFilter", "min_days_listed": 10},
         {"method": "PrecisionFilter"},
         {"method": "PriceFilter", "low_price_ratio": 0.01, "min_price": 0.00000010},
-        {"method": "SpreadFilter", "max_spread_ratio": 0.005}
+        {"method": "SpreadFilter", "max_spread_ratio": 0.005},
+        {
+            "method": "RangeStabilityFilter",
+            "lookback_days": 10,
+            "min_rate_of_change": 0.01,
+            "refresh_period": 1440
+        }
     ],
     "exchange": {
         "name": "bittrex",
@@ -116,7 +122,16 @@
     "telegram": {
         "enabled": true,
         "token": "your_telegram_token",
-        "chat_id": "your_telegram_chat_id"
+        "chat_id": "your_telegram_chat_id",
+        "notification_settings": {
+            "status": "on",
+            "warning": "on",
+            "startup": "on",
+            "buy": "on",
+            "sell": "on",
+            "buy_cancel": "on",
+            "sell_cancel": "on"
+        }
     },
     "api_server": {
         "enabled": false,

config_kraken.json.example

@@ -7,7 +7,6 @@
     "timeframe": "5m",
     "dry_run": true,
     "cancel_open_orders_on_exit": false,
-    "trailing_stop": false,
     "unfilledtimeout": {
         "buy": 10,
         "sell": 30
@@ -28,12 +27,11 @@
         "use_sell_signal": true,
         "sell_profit_only": false,
         "ignore_roi_if_buy_signal": false
-
     },
     "exchange": {
         "name": "kraken",
-        "key": "",
-        "secret": "",
+        "key": "your_exchange_key",
+        "secret": "your_exchange_key",
         "ccxt_config": {"enableRateLimit": true},
         "ccxt_async_config": {
             "enableRateLimit": true,

docker-compose.develop.yml

@@ -1,20 +0,0 @@
----
-version: '3'
-services:
-  freqtrade_develop:
-    build:
-      context: .
-      dockerfile: "./Dockerfile.develop"
-    volumes:
-      - ".:/freqtrade"
-    entrypoint:
-      - "freqtrade"
-
-  freqtrade_bash:
-    build:
-      context: .
-      dockerfile: "./Dockerfile.develop"
-    volumes:
-      - ".:/freqtrade"
-    entrypoint:
-      - "/bin/bash"

docker-compose.yml

@@ -2,8 +2,10 @@
 version: '3'
 services:
   freqtrade:
-    image: freqtradeorg/freqtrade:master
+    image: freqtradeorg/freqtrade:stable
     # image: freqtradeorg/freqtrade:develop
+    # Use plotting image
+    # image: freqtradeorg/freqtrade:develop_plot
     # Build step - only needed when additional dependencies are needed
     # build:
     #   context: .

docker/Dockerfile.develop

@@ -2,6 +2,7 @@ FROM freqtradeorg/freqtrade:develop
 
 # Install dependencies
 COPY requirements-dev.txt /freqtrade/
+
 RUN pip install numpy --no-cache-dir \
   && pip install -r requirements-dev.txt --no-cache-dir
 

docker/Dockerfile.jupyter

@@ -0,0 +1,7 @@
+FROM freqtradeorg/freqtrade:develop_plot
+
+
+RUN pip install jupyterlab --no-cache-dir
+
+# Empty the ENTRYPOINT to allow all commands
+ENTRYPOINT []

docker/Dockerfile.plot

@@ -0,0 +1,7 @@
+ARG sourceimage=develop
+FROM freqtradeorg/freqtrade:${sourceimage}
+
+# Install dependencies
+COPY requirements-plot.txt /freqtrade/
+
+RUN pip install -r requirements-plot.txt --no-cache-dir

docker/docker-compose-jupyter.yml

@@ -0,0 +1,16 @@
+---
+version: '3'
+services:
+  ft_jupyterlab:
+    build:
+      context: ..
+      dockerfile: docker/Dockerfile.jupyter
+    restart: unless-stopped
+    container_name: freqtrade
+    ports:
+      - "127.0.0.1:8888:8888"
+    volumes:
+      - "./user_data:/freqtrade/user_data"
+    # Default command used when running `docker compose up`
+    command: >
+      jupyter lab --port=8888 --ip 0.0.0.0 --allow-root

docs/advanced-hyperopt.md

@@ -27,9 +27,9 @@ class MyAwesomeHyperOpt2(MyAwesomeHyperOpt):
 and then quickly switch between hyperopt classes, running optimization process with hyperopt class you need in each particular case:
 
 ```
-$ freqtrade hyperopt --hyperopt MyAwesomeHyperOpt ...
+$ freqtrade hyperopt --hyperopt MyAwesomeHyperOpt --hyperopt-loss SharpeHyperOptLossDaily --strategy MyAwesomeStrategy ...
 or
-$ freqtrade hyperopt --hyperopt MyAwesomeHyperOpt2 ...
+$ freqtrade hyperopt --hyperopt MyAwesomeHyperOpt2 --hyperopt-loss SharpeHyperOptLossDaily --strategy MyAwesomeStrategy ...
 ```
 
 ## Creating and using a custom loss function

docs/backtesting.md

@@ -162,6 +162,8 @@ A backtesting result will look like that:
 |-----------------------+---------------------|
 | Backtesting from      | 2019-01-01 00:00:00 |
 | Backtesting to        | 2019-05-01 00:00:00 |
+| Max open trades       | 3                   |
+|                       |                     |
 | Total trades          | 429                 |
 | First trade           | 2019-01-01 18:30:00 |
 | First trade Pair      | EOS/USDT            |
@@ -233,6 +235,8 @@ It contains some useful key metrics about performance of your strategy on backte
 |-----------------------+---------------------|
 | Backtesting from      | 2019-01-01 00:00:00 |
 | Backtesting to        | 2019-05-01 00:00:00 |
+| Max open trades       | 3                   |
+|                       |                     |
 | Total trades          | 429                 |
 | First trade           | 2019-01-01 18:30:00 |
 | First trade Pair      | EOS/USDT            |
@@ -251,16 +255,17 @@ It contains some useful key metrics about performance of your strategy on backte
 
 ```
 
+- `Backtesting from` / `Backtesting to`: Backtesting range (usually defined with the `--timerange` option).
+- `Max open trades`: Setting of `max_open_trades` (or `--max-open-trades`) - to clearly see settings for this.
 - `Total trades`: Identical to the total trades of the backtest output table.
 - `First trade`: First trade entered.
 - `First trade pair`: Which pair was part of the first trade.
-- `Backtesting from` / `Backtesting to`: Backtesting range (usually defined with the `--timerange` option).
 - `Total Profit %`: Total profit per stake amount. Aligned to the TOTAL column of the first table.
 - `Trades per day`: Total trades divided by the backtesting duration in days (this will give you information about how many trades to expect from the strategy).
 - `Best day` / `Worst day`: Best and worst day based on daily profit.
 - `Avg. Duration Winners` / `Avg. Duration Loser`: Average durations for winning and losing trades.
 - `Max Drawdown`: Maximum drawdown experienced. For example, the value of 50% means that from highest to subsequent lowest point, a 50% drop was experienced).
-- `Drawdown Start` / `Drawdown End`: Start and end datetimes for this largest drawdown (can also be visualized via the `plot-dataframe` sub-command).
+- `Drawdown Start` / `Drawdown End`: Start and end datetime for this largest drawdown (can also be visualized via the `plot-dataframe` sub-command).
 - `Market change`: Change of the market during the backtest period. Calculated as average of all pairs changes from the first to the last candle using the "close" column.
 
 ### Assumptions made by backtesting

docs/bot-usage.md

@@ -5,6 +5,9 @@ This page explains the different parameters of the bot and how to run it.
 !!! Note
     If you've used `setup.sh`, don't forget to activate your virtual environment (`source .env/bin/activate`) before running freqtrade commands.
 
+!!! 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.
+
 ## Bot commands
 
 ```
@@ -300,7 +303,7 @@ usage: freqtrade hyperopt [-h] [-v] [--logfile FILE] [-V] [-c PATH] [-d PATH]
                           [--spaces {all,buy,sell,roi,stoploss,trailing,default} [{all,buy,sell,roi,stoploss,trailing,default} ...]]
                           [--dmmp] [--print-all] [--no-color] [--print-json]
                           [-j JOBS] [--random-state INT] [--min-trades INT]
-                          [--continue] [--hyperopt-loss NAME]
+                          [--hyperopt-loss NAME]
 
 optional arguments:
   -h, --help            show this help message and exit
@@ -346,18 +349,14 @@ optional arguments:
                         reproducible hyperopt results.
   --min-trades INT      Set minimal desired number of trades for evaluations
                         in the hyperopt optimization path (default: 1).
-  --continue            Continue hyperopt from previous runs. By default,
-                        temporary files will be removed and hyperopt will
-                        start from scratch.
   --hyperopt-loss NAME  Specify the class name of the hyperopt loss function
                         class (IHyperOptLoss). Different functions can
                         generate completely different results, since the
                         target for optimization is different. Built-in
-                        Hyperopt-loss-functions are: DefaultHyperOptLoss,
+                        Hyperopt-loss-functions are: ShortTradeDurHyperOptLoss,
                         OnlyProfitHyperOptLoss, SharpeHyperOptLoss,
                         SharpeHyperOptLossDaily, SortinoHyperOptLoss,
-                        SortinoHyperOptLossDaily.(default:
-                        `DefaultHyperOptLoss`).
+                        SortinoHyperOptLossDaily.
 
 Common arguments:
   -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).

docs/configuration.md

@@ -59,8 +59,8 @@ Mandatory parameters are marked as **Required**, which means that they are requi
 | `trailing_stop_positive` | Changes stoploss once profit has been reached. More details in the [stoploss documentation](stoploss.md#trailing-stop-loss-custom-positive-loss). [Strategy Override](#parameters-in-the-strategy). <br> **Datatype:** Float
 | `trailing_stop_positive_offset` | Offset on when to apply `trailing_stop_positive`. Percentage value which should be positive. More details in the [stoploss documentation](stoploss.md#trailing-stop-loss-only-once-the-trade-has-reached-a-certain-offset). [Strategy Override](#parameters-in-the-strategy). <br>*Defaults to `0.0` (no offset).* <br> **Datatype:** Float
 | `trailing_only_offset_is_reached` | Only apply trailing stoploss when the offset is reached. [stoploss documentation](stoploss.md). [Strategy Override](#parameters-in-the-strategy). <br>*Defaults to `false`.*  <br> **Datatype:** Boolean
-| `unfilledtimeout.buy` | **Required.** How long (in minutes) the bot will wait for an unfilled buy order to complete, after which the order will be cancelled. [Strategy Override](#parameters-in-the-strategy).<br> **Datatype:** Integer
-| `unfilledtimeout.sell` | **Required.** How long (in minutes) the bot will wait for an unfilled sell order to complete, after which the order will be cancelled. [Strategy Override](#parameters-in-the-strategy).<br> **Datatype:** Integer
+| `unfilledtimeout.buy` | **Required.** How long (in minutes) the bot will wait for an unfilled buy order to complete, after which the order will be cancelled and repeated at current (new) price, as long as there is a signal. [Strategy Override](#parameters-in-the-strategy).<br> **Datatype:** Integer
+| `unfilledtimeout.sell` | **Required.** How long (in minutes) the bot will wait for an unfilled sell order to complete, after which the order will be cancelled and repeated at current (new) price, as long as there is a signal. [Strategy Override](#parameters-in-the-strategy).<br> **Datatype:** Integer
 | `bid_strategy.price_side` | Select the side of the spread the bot should look at to get the buy rate. [More information below](#buy-price-side).<br> *Defaults to `bid`.* <br> **Datatype:** String (either `ask` or `bid`).
 | `bid_strategy.ask_last_balance` | **Required.** Set the bidding price. More information [below](#buy-price-without-orderbook-enabled).
 | `bid_strategy.use_order_book` | Enable buying using the rates in [Order Book Bids](#buy-price-with-orderbook-enabled). <br> **Datatype:** Boolean
@@ -87,6 +87,7 @@ Mandatory parameters are marked as **Required**, which means that they are requi
 | `exchange.ccxt_sync_config` | Additional CCXT parameters passed to the regular (sync) ccxt instance. Parameters may differ from exchange to exchange and are documented in the [ccxt documentation](https://ccxt.readthedocs.io/en/latest/manual.html#instantiation) <br> **Datatype:** Dict
 | `exchange.ccxt_async_config` | Additional CCXT parameters passed to the async ccxt instance. Parameters may differ from exchange to exchange  and are documented in the [ccxt documentation](https://ccxt.readthedocs.io/en/latest/manual.html#instantiation) <br> **Datatype:** Dict
 | `exchange.markets_refresh_interval` | The interval in minutes in which markets are reloaded. <br>*Defaults to `60` minutes.* <br> **Datatype:** Positive Integer
+| `exchange.skip_pair_validation` | Skip pairlist validation on startup.<br>*Defaults to `false`<br> **Datatype:** Boolean
 | `edge.*` | Please refer to [edge configuration document](edge.md) for detailed explanation.
 | `experimental.block_bad_exchanges` | Block exchanges known to not work with freqtrade. Leave on default unless you want to test if that exchange works now. <br>*Defaults to `true`.* <br> **Datatype:** Boolean
 | `pairlists` | Define one or more pairlists to be used. [More information below](#pairlists-and-pairlist-handlers). <br>*Defaults to `StaticPairList`.*  <br> **Datatype:** List of Dicts
@@ -176,7 +177,7 @@ In the example above this would mean:
     This option only applies with [Static stake amount](#static-stake-amount) - since [Dynamic stake amount](#dynamic-stake-amount) divides the balances evenly.
 
 !!! Note
-    The minimum last stake amount can be configured using `amend_last_stake_amount` - which defaults to 0.5 (50%). This means that the minimum stake amount that's ever used is `stake_amount * 0.5`. This avoids very low stake amounts, that are close to the minimum tradable amount for the pair and can be refused by the exchange.
+    The minimum last stake amount can be configured using `last_stake_amount_min_ratio` - which defaults to 0.5 (50%). This means that the minimum stake amount that's ever used is `stake_amount * 0.5`. This avoids very low stake amounts, that are close to the minimum tradable amount for the pair and can be refused by the exchange.
 
 #### Static stake amount
 
@@ -313,22 +314,21 @@ Configuration:
 }
 ```
 
-!!! Note
+!!! Note "Market order support"
     Not all exchanges support "market" orders.
     The following message will be shown if your exchange does not support market orders:
-    `"Exchange <yourexchange>  does not support market orders."`
+    `"Exchange <yourexchange> does not support market orders."` and the bot will refuse to start.
 
-!!! Note
-    Stoploss on exchange interval is not mandatory. Do not change its value if you are
+!!! Warning "Using market orders"
+    Please carefully read the section [Market order pricing](#market-order-pricing) section when using market orders.
+
+!!! Note "Stoploss on exchange"
+    `stoploss_on_exchange_interval` is not mandatory. Do not change its value if you are
     unsure of what you are doing. For more information about how stoploss works please
     refer to [the stoploss documentation](stoploss.md).
 
-!!! Note
     If `stoploss_on_exchange` is enabled and the stoploss is cancelled manually on the exchange, then the bot will create a new stoploss order.
 
-!!! Warning "Using market orders"
-    Please read the section [Market order pricing](#market-order-pricing) section when using market orders.
-
 !!! Warning "Warning: stoploss_on_exchange failures"
     If stoploss on exchange creation fails for some reason, then an "emergency sell" is initiated. By default, this will sell the asset using a market order. The order-type for the emergency-sell can be changed by setting the `emergencysell` value in the `order_types` dictionary - however this is not advised.
 
@@ -375,7 +375,7 @@ Freqtrade is based on [CCXT library](https://github.com/ccxt/ccxt) that supports
 exchange markets and trading APIs. The complete up-to-date list can be found in the
 [CCXT repo homepage](https://github.com/ccxt/ccxt/tree/master/python).
  However, the bot was tested by the development team with only Bittrex, Binance and Kraken,
- so the these are the only officially supported exhanges:
+ so the these are the only officially supported exchanges:
 
 - [Bittrex](https://bittrex.com/): "bittrex"
 - [Binance](https://www.binance.com/): "binance"
@@ -574,144 +574,7 @@ Assuming both buy and sell are using market orders, a configuration similar to t
 ```
 
 Obviously, if only one side is using limit orders, different pricing combinations can be used.
-
-## Pairlists and Pairlist Handlers
-
-Pairlist Handlers define the list of pairs (pairlist) that the bot should trade. They are configured in the `pairlists` section of the configuration settings.
-
-In your configuration, you can use Static Pairlist (defined by the [`StaticPairList`](#static-pair-list) Pairlist Handler) and Dynamic Pairlist (defined by the [`VolumePairList`](#volume-pair-list) Pairlist Handler).
-
-Additionaly, [`AgeFilter`](#agefilter), [`PrecisionFilter`](#precisionfilter), [`PriceFilter`](#pricefilter), [`ShuffleFilter`](#shufflefilter) and [`SpreadFilter`](#spreadfilter) act as Pairlist Filters, removing certain pairs and/or moving their positions in the pairlist.
-
-If multiple Pairlist Handlers are used, they are chained and a combination of all Pairlist Handlers forms the resulting pairlist the bot uses for trading and backtesting. Pairlist Handlers are executed in the sequence they are configured. You should always configure either `StaticPairList` or `VolumePairList` as the starting Pairlist Handler.
-
-Inactive markets are always removed from the resulting pairlist. Explicitly blacklisted pairs (those in the `pair_blacklist` configuration setting) are also always removed from the resulting pairlist.
-
-### Available Pairlist Handlers
-
-* [`StaticPairList`](#static-pair-list) (default, if not configured differently)
-* [`VolumePairList`](#volume-pair-list)
-* [`AgeFilter`](#agefilter)
-* [`PrecisionFilter`](#precisionfilter)
-* [`PriceFilter`](#pricefilter)
-* [`ShuffleFilter`](#shufflefilter)
-* [`SpreadFilter`](#spreadfilter)
-
-!!! Tip "Testing pairlists"
-    Pairlist configurations can be quite tricky to get right. Best use the [`test-pairlist`](utils.md#test-pairlist) utility subcommand to test your configuration quickly.
-
-#### Static Pair List
-
-By default, the `StaticPairList` method is used, which uses a statically defined pair whitelist from the configuration. 
-
-It uses configuration from `exchange.pair_whitelist` and `exchange.pair_blacklist`.
-
-```json
-"pairlists": [
-    {"method": "StaticPairList"}
-    ],
-```
-
-#### Volume Pair List
-
-`VolumePairList` employs sorting/filtering of pairs by their trading volume. It selects `number_assets` top pairs with sorting based on the `sort_key` (which can only be `quoteVolume`).
-
-When used in the chain of Pairlist Handlers in a non-leading position (after StaticPairList and other Pairlist Filters), `VolumePairList` considers outputs of previous Pairlist Handlers, adding its sorting/selection of the pairs by the trading volume.
-
-When used on the leading position of the chain of Pairlist Handlers, it does not consider `pair_whitelist` configuration setting, but selects the top assets from all available markets (with matching stake-currency) on the exchange.
-
-The `refresh_period` setting allows to define the period (in seconds), at which the pairlist will be refreshed. Defaults to 1800s (30 minutes).
-
-`VolumePairList` is based on the ticker data from exchange, as reported by the ccxt library:
-
-* The `quoteVolume` is the amount of quote (stake) currency traded (bought or sold) in last 24 hours.
-
-```json
-"pairlists": [{
-        "method": "VolumePairList",
-        "number_assets": 20,
-        "sort_key": "quoteVolume",
-        "refresh_period": 1800,
-}],
-```
-
-#### AgeFilter
-
-Removes pairs that have been listed on the exchange for less than `min_days_listed` days (defaults to `10`).
-
-When pairs are first listed on an exchange they can suffer huge price drops and volatility
-in the first few days while the pair goes through its price-discovery period. Bots can often
-be caught out buying before the pair has finished dropping in price.
-
-This filter allows freqtrade to ignore pairs until they have been listed for at least `min_days_listed` days.
-
-#### PrecisionFilter
-
-Filters low-value coins which would not allow setting stoplosses.
-
-#### PriceFilter
-
-The `PriceFilter` allows filtering of pairs by price. Currently the following price filters are supported:
-
-* `min_price`
-* `max_price`
-* `low_price_ratio`
-
-The `min_price` setting removes pairs where the price is below the specified price. This is useful if you wish to avoid trading very low-priced pairs.
-This option is disabled by default, and will only apply if set to > 0.
-
-The `max_price` setting removes pairs where the price is above the specified price. This is useful if you wish to trade only low-priced pairs.
-This option is disabled by default, and will only apply if set to > 0.
-
-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.
-
-For `PriceFiler` at least one of its `min_price`, `max_price` or `low_price_ratio` settings must be applied.
-
-Calculation example:
-
-Min price precision for SHITCOIN/BTC is 8 decimals. If its price is 0.00000011 - one price step above would be 0.00000012, which is ~9% higher than the previous price value. You may filter out this pair by using PriceFilter with `low_price_ratio` set to 0.09 (9%) or with `min_price` set to 0.00000011, correspondingly.
-
-!!! Warning "Low priced pairs"
-    Low priced pairs with high "1 pip movements" are dangerous since they are often illiquid and it may also be impossible to place the desired stoploss, which can often result in high losses since price needs to be rounded to the next tradable price - so instead of having a stoploss of -5%, you could end up with a stoploss of -9% simply due to price rounding.
-
-#### ShuffleFilter
-
-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.
-
-!!! 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.
-
-#### SpreadFilter
-
-Removes pairs that have a difference between asks and bids above the specified ratio, `max_spread_ratio` (defaults to `0.005`).
-
-Example:
-
-If `DOGE/BTC` maximum bid is 0.00000026 and minimum ask is 0.00000027, the ratio is calculated as: `1 - bid/ask ~= 0.037` which is `> 0.005` and this pair will be filtered out.
-
-### Full example of Pairlist Handlers
-
-The below example blacklists `BNB/BTC`, uses `VolumePairList` with `20` assets, sorting pairs by `quoteVolume` and applies both [`PrecisionFilter`](#precisionfilter) and [`PriceFilter`](#price-filter), filtering all assets where 1 priceunit is > 1%. Then the `SpreadFilter` is applied and pairs are finally shuffled with the random seed set to some predefined value.
-
-```json
-"exchange": {
-    "pair_whitelist": [],
-    "pair_blacklist": ["BNB/BTC"]
-},
-"pairlists": [
-    {
-        "method": "VolumePairList",
-        "number_assets": 20,
-        "sort_key": "quoteVolume",
-    },
-    {"method": "AgeFilter", "min_days_listed": 10},
-    {"method": "PrecisionFilter"},
-    {"method": "PriceFilter", "low_price_ratio": 0.01},
-    {"method": "SpreadFilter", "max_spread_ratio": 0.005},
-    {"method": "ShuffleFilter", "seed": 42}
-    ],
-```
+--8<-- "includes/pairlists.md"
 
 ## Switch to Dry-run mode
 

docs/data-analysis.md

@@ -1,12 +1,22 @@
 # Analyzing bot data with Jupyter notebooks  
 
-You can analyze the results of backtests and trading history easily using Jupyter notebooks. Sample notebooks are located at `user_data/notebooks/`.  
+You can analyze the results of backtests and trading history easily using Jupyter notebooks. Sample notebooks are located at `user_data/notebooks/` after initializing the user directory with `freqtrade create-userdir --userdir user_data`.  
 
-## Pro tips  
+## 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`
+
+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.
+
+For more information, Please visit the [Data analysis with Docker](docker_quickstart.md#data-analayis-using-docker-compose) section.
+
+### Pro tips
 
 * See [jupyter.org](https://jupyter.org/documentation) for usage instructions.
 * Don't forget to start a Jupyter notebook server from within your conda or venv environment or use [nb_conda_kernels](https://github.com/Anaconda-Platform/nb_conda_kernels)*
-* Copy the example notebook before use so your changes don't get clobbered with the next freqtrade update.
+* Copy the example notebook before use so your changes don't get overwritten with the next freqtrade update.
 
 ### Using virtual environment with system-wide Jupyter installation
 
@@ -28,10 +38,8 @@ ipython kernel install --user --name=freqtrade
 !!! Note
     This section is provided for completeness, the Freqtrade Team won't provide full support for problems with this setup and will recommend to install Jupyter in the virtual environment directly, as that is the easiest way to get jupyter notebooks up and running. For help with this setup please refer to the [Project Jupyter](https://jupyter.org/) [documentation](https://jupyter.org/documentation) or [help channels](https://jupyter.org/community).
 
-    
-## Fine print  
-
-Some tasks don't work especially well in notebooks. For example, anything using asynchronous execution is a problem for Jupyter. Also, freqtrade's primary entry point is the shell cli, so using pure python in a notebook bypasses arguments that provide required objects and parameters to helper functions. You may need to set those values or create expected objects manually.
+!!! Warning
+    Some tasks don't work especially well in notebooks. For example, anything using asynchronous execution is a problem for Jupyter. Also, freqtrade's primary entry point is the shell cli, so using pure python in a notebook bypasses arguments that provide required objects and parameters to helper functions. You may need to set those values or create expected objects manually.
 
 ## Recommended workflow  
 

docs/data-download.md

@@ -8,82 +8,121 @@ If no additional parameter is specified, freqtrade will download data for `"1m"`
 Exchange and pairs will come from `config.json` (if specified using `-c/--config`).
 Otherwise `--exchange` becomes mandatory.
 
+You can use a relative timerange (`--days 20`) or an absolute starting point (`--timerange 20200101`). For incremental downloads, the relative approach should be used.
+
 !!! Tip "Tip: Updating existing data"
     If you already have backtesting data available in your data-directory and would like to refresh this data up to today, use `--days xx` with a number slightly higher than the missing number of days. Freqtrade will keep the available data and only download the missing data.
-    Be carefull though: If the number is too small (which would result in a few missing days), the whole dataset will be removed and only xx days will be downloaded.
+    Be careful though: If the number is too small (which would result in a few missing days), the whole dataset will be removed and only xx days will be downloaded.
 
 ### Usage
 
 ```
-usage: freqtrade download-data [-h] [-v] [--logfile FILE] [-V] [-c PATH] [-d PATH] [--userdir PATH] [-p PAIRS [PAIRS ...]]
-                               [--pairs-file FILE] [--days INT] [--dl-trades] [--exchange EXCHANGE]
-                               [-t {1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w} [{1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w} ...]]
-                               [--erase] [--data-format-ohlcv {json,jsongz}] [--data-format-trades {json,jsongz}]
-
-optional arguments:
-  -h, --help            show this help message and exit
-  -p PAIRS [PAIRS ...], --pairs PAIRS [PAIRS ...]
-                        Show profits for only these pairs. Pairs are space-separated.
-  --pairs-file FILE     File containing a list of pairs to download.
-  --days INT            Download data for given number of days.
-  --dl-trades           Download trades instead of OHLCV data. The bot will resample trades to the desired timeframe as specified as
-                        --timeframes/-t.
-  --exchange EXCHANGE   Exchange name (default: `bittrex`). Only valid if no config is provided.
-  -t {1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w} [{1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w} ...], --timeframes {1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w} [{1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w} ...]
-                        Specify which tickers to download. Space-separated list. Default: `1m 5m`.
-  --erase               Clean all existing data for the selected exchange/pairs/timeframes.
-  --data-format-ohlcv {json,jsongz}
-                        Storage format for downloaded candle (OHLCV) data. (default: `json`).
-  --data-format-trades {json,jsongz}
-                        Storage format for downloaded trades data. (default: `jsongz`).
-
-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: `config.json`). Multiple --config options may be used. Can be set to `-`
-                        to read config from stdin.
-  -d PATH, --datadir PATH
-                        Path to directory with historical backtesting data.
-  --userdir PATH, --user-data-dir PATH
-                        Path to userdata directory.
-```
-
-### Data format
-
-Freqtrade currently supports 2 dataformats, `json` (plain "text" json files) and `jsongz` (a gzipped version of json files).
-By default, OHLCV data is stored as `json` data, while trades data is stored as `jsongz` data.
-
-This can be changed via the `--data-format-ohlcv` and `--data-format-trades` parameters respectivly.
-
-If the default dataformat has been changed during download, then the keys `dataformat_ohlcv` and `dataformat_trades` in the configuration file need to be adjusted to the selected dataformat as well.
-
-!!! Note
-    You can convert between data-formats using the [convert-data](#subcommand-convert-data) and [convert-trade-data](#subcommand-convert-trade-data) methods.
-
-#### Subcommand convert data
-
-```
-usage: freqtrade convert-data [-h] [-v] [--logfile FILE] [-V] [-c PATH]
-                              [-d PATH] [--userdir PATH]
-                              [-p PAIRS [PAIRS ...]] --format-from
-                              {json,jsongz} --format-to {json,jsongz}
-                              [--erase]
-                              [-t {1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w} [{1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w} ...]]
+usage: freqtrade download-data [-h] [-v] [--logfile FILE] [-V] [-c PATH]
+                               [-d PATH] [--userdir PATH]
+                               [-p PAIRS [PAIRS ...]] [--pairs-file FILE]
+                               [--days INT] [--timerange TIMERANGE]
+                               [--dl-trades] [--exchange EXCHANGE]
+                               [-t {1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} [{1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} ...]]
+                               [--erase]
+                               [--data-format-ohlcv {json,jsongz,hdf5}]
+                               [--data-format-trades {json,jsongz,hdf5}]
 
 optional arguments:
   -h, --help            show this help message and exit
   -p PAIRS [PAIRS ...], --pairs PAIRS [PAIRS ...]
                         Show profits for only these pairs. Pairs are space-
                         separated.
-  --format-from {json,jsongz}
+  --pairs-file FILE     File containing a list of pairs to download.
+  --days INT            Download data for given number of days.
+  --timerange TIMERANGE
+                        Specify what timerange of data to use.
+  --dl-trades           Download trades instead of OHLCV data. The bot will
+                        resample trades to the desired timeframe as specified
+                        as --timeframes/-t.
+  --exchange EXCHANGE   Exchange name (default: `bittrex`). Only valid if no
+                        config is provided.
+  -t {1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} [{1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} ...], --timeframes {1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} [{1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} ...]
+                        Specify which tickers to download. Space-separated
+                        list. Default: `1m 5m`.
+  --erase               Clean all existing data for the selected
+                        exchange/pairs/timeframes.
+  --data-format-ohlcv {json,jsongz,hdf5}
+                        Storage format for downloaded candle (OHLCV) data.
+                        (default: `json`).
+  --data-format-trades {json,jsongz,hdf5}
+                        Storage format for downloaded trades data. (default:
+                        `jsongz`).
+
+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
+                        Path to directory with historical backtesting data.
+  --userdir PATH, --user-data-dir PATH
+                        Path to userdata directory.
+
+```
+
+!!! Note "Startup period"
+    `download-data` is a strategy-independent command. The idea is to download a big chunk of data once, and then iteratively increase the amount of data stored.
+
+    For that reason, `download-data` does not care about the "startup-period" defined in a strategy. It's up to the user to download additional days if the backtest should start at a specific point in time (while respecting startup period).
+
+### Data format
+
+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)
+
+By default, OHLCV data is stored as `json` data, while trades data is stored as `jsongz` data.
+
+This can be changed via the `--data-format-ohlcv` and `--data-format-trades` command line arguments respectively.
+To persist this change, you can should also add the following snippet to your configuration, so you don't have to insert the above arguments each time:
+
+``` jsonc
+    // ...
+    "dataformat_ohlcv": "hdf5",
+    "dataformat_trades": "hdf5",
+    // ...
+```
+
+If the default data-format has been changed during download, then the keys `dataformat_ohlcv` and `dataformat_trades` in the configuration file need to be adjusted to the selected dataformat as well.
+
+!!! Note
+    You can convert between data-formats using the [convert-data](#sub-command-convert-data) and [convert-trade-data](#sub-command-convert-trade-data) methods.
+
+#### Sub-command convert data
+
+```
+usage: freqtrade convert-data [-h] [-v] [--logfile FILE] [-V] [-c PATH]
+                              [-d PATH] [--userdir PATH]
+                              [-p PAIRS [PAIRS ...]] --format-from
+                              {json,jsongz,hdf5} --format-to
+                              {json,jsongz,hdf5} [--erase]
+                              [-t {1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} [{1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} ...]]
+
+optional arguments:
+  -h, --help            show this help message and exit
+  -p PAIRS [PAIRS ...], --pairs PAIRS [PAIRS ...]
+                        Show profits for only these pairs. Pairs are space-
+                        separated.
+  --format-from {json,jsongz,hdf5}
                         Source format for data conversion.
-  --format-to {json,jsongz}
+  --format-to {json,jsongz,hdf5}
                         Destination format for data conversion.
   --erase               Clean all existing data for the selected
                         exchange/pairs/timeframes.
-  -t {1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w} [{1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w} ...], --timeframes {1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w} [{1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w} ...]
+  -t {1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} [{1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} ...], --timeframes {1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} [{1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,2w,1M,1y} ...]
                         Specify which tickers to download. Space-separated
                         list. Default: `1m 5m`.
 
@@ -94,9 +133,10 @@ Common arguments:
                         details.
   -V, --version         show program's version number and exit
   -c PATH, --config PATH
-                        Specify configuration file (default: `config.json`).
-                        Multiple --config options may be used. Can be set to
-                        `-` to read config from stdin.
+                        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
                         Path to directory with historical backtesting data.
   --userdir PATH, --user-data-dir PATH
@@ -112,23 +152,23 @@ It'll also remove original json data files (`--erase` parameter).
 freqtrade convert-data --format-from json --format-to jsongz --datadir ~/.freqtrade/data/binance -t 5m 15m --erase
 ```
 
-#### Subcommand convert-trade data
+#### Sub-command convert trade data
 
 ```
 usage: freqtrade convert-trade-data [-h] [-v] [--logfile FILE] [-V] [-c PATH]
                                     [-d PATH] [--userdir PATH]
                                     [-p PAIRS [PAIRS ...]] --format-from
-                                    {json,jsongz} --format-to {json,jsongz}
-                                    [--erase]
+                                    {json,jsongz,hdf5} --format-to
+                                    {json,jsongz,hdf5} [--erase]
 
 optional arguments:
   -h, --help            show this help message and exit
   -p PAIRS [PAIRS ...], --pairs PAIRS [PAIRS ...]
                         Show profits for only these pairs. Pairs are space-
                         separated.
-  --format-from {json,jsongz}
+  --format-from {json,jsongz,hdf5}
                         Source format for data conversion.
-  --format-to {json,jsongz}
+  --format-to {json,jsongz,hdf5}
                         Destination format for data conversion.
   --erase               Clean all existing data for the selected
                         exchange/pairs/timeframes.
@@ -140,13 +180,15 @@ Common arguments:
                         details.
   -V, --version         show program's version number and exit
   -c PATH, --config PATH
-                        Specify configuration file (default: `config.json`).
-                        Multiple --config options may be used. Can be set to
-                        `-` to read config from stdin.
+                        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
                         Path to directory with historical backtesting data.
   --userdir PATH, --user-data-dir PATH
                         Path to userdata directory.
+
 ```
 
 ##### Example converting trades
@@ -158,21 +200,21 @@ It'll also remove original jsongz data files (`--erase` parameter).
 freqtrade convert-trade-data --format-from jsongz --format-to json --datadir ~/.freqtrade/data/kraken --erase
 ```
 
-### Subcommand list-data
+### Sub-command list-data
 
-You can get a list of downloaded data using the `list-data` subcommand.
+You can get a list of downloaded data using the `list-data` sub-command.
 
 ```
 usage: freqtrade list-data [-h] [-v] [--logfile FILE] [-V] [-c PATH] [-d PATH]
                            [--userdir PATH] [--exchange EXCHANGE]
-                           [--data-format-ohlcv {json,jsongz}]
+                           [--data-format-ohlcv {json,jsongz,hdf5}]
                            [-p PAIRS [PAIRS ...]]
 
 optional arguments:
   -h, --help            show this help message and exit
   --exchange EXCHANGE   Exchange name (default: `bittrex`). Only valid if no
                         config is provided.
-  --data-format-ohlcv {json,jsongz}
+  --data-format-ohlcv {json,jsongz,hdf5}
                         Storage format for downloaded candle (OHLCV) data.
                         (default: `json`).
   -p PAIRS [PAIRS ...], --pairs PAIRS [PAIRS ...]
@@ -194,6 +236,7 @@ Common arguments:
                         Path to directory with historical backtesting data.
   --userdir PATH, --user-data-dir PATH
                         Path to userdata directory.
+
 ```
 
 #### Example list-data
@@ -249,15 +292,16 @@ This will download historical candle (OHLCV) data for all the currency pairs you
 ### Other Notes
 
 - To use a different directory than the exchange specific default, use `--datadir user_data/data/some_directory`.
-- To change the exchange used to download the historical data from, please use a different configuration file (you'll probably need to adjust ratelimits etc.)
+- To change the exchange used to download the historical data from, please use a different configuration file (you'll probably need to adjust rate limits etc.)
 - To use `pairs.json` from some other directory, use `--pairs-file some_other_dir/pairs.json`.
 - To download historical candle (OHLCV) data for only 10 days, use `--days 10` (defaults to 30 days).
+- To download historical candle (OHLCV) data from a fixed starting point, use `--timerange 20200101-` - which will download all data from January 1st, 2020. Eventually set end dates are ignored.
 - Use `--timeframes` to specify what timeframe download the historical candle (OHLCV) data for. Default is `--timeframes 1m 5m` which will download 1-minute and 5-minute data.
 - To use exchange, timeframe and list of pairs as defined in your configuration file, use the `-c/--config` option. With this, the script uses the whitelist defined in the config as the list of currency pairs to download data for and does not require the pairs.json file. You can combine `-c/--config` with most other options.
 
 ### Trades (tick) data
 
-By default, `download-data` subcommand downloads Candles (OHLCV) data. Some exchanges also provide historic trade-data via their API.
+By default, `download-data` sub-command downloads Candles (OHLCV) data. Some exchanges also provide historic trade-data via their API.
 This data can be useful if you need many different timeframes, since it is only downloaded once, and then resampled locally to the desired timeframes.
 
 Since this data is large by default, the files use gzip by default. They are stored in your data-directory with the naming convention of `<pair>-trades.json.gz` (`ETH_BTC-trades.json.gz`). Incremental mode is also supported, as for historic OHLCV data, so downloading the data once per week with `--days 8` will create an incremental data-repository.

docs/deprecated.md

@@ -32,4 +32,4 @@ The old section of configuration parameters (`"pairlist"`) has been deprecated i
 
 ### deprecation of bidVolume and askVolume from volume-pairlist
 
-Since only quoteVolume can be compared between assets, the other options (bidVolume, askVolume) have been deprecated in 2020.4.
+Since only quoteVolume can be compared between assets, the other options (bidVolume, askVolume) have been deprecated in 2020.4, and have been removed in 2020.9.

docs/developer.md

@@ -2,7 +2,7 @@
 
 This page is intended for developers of Freqtrade, people who want to contribute to the Freqtrade codebase or documentation, or people who want to understand the source code of the application they're running.
 
-All contributions, bug reports, bug fixes, documentation improvements, enhancements and ideas are welcome. We [track issues](https://github.com/freqtrade/freqtrade/issues) on [GitHub](https://github.com) and also have a dev channel in [slack](https://join.slack.com/t/highfrequencybot/shared_invite/enQtNjU5ODcwNjI1MDU3LTU1MTgxMjkzNmYxNWE1MDEzYzQ3YmU4N2MwZjUyNjJjODRkMDVkNjg4YTAyZGYzYzlhOTZiMTE4ZjQ4YzM0OGE) where you can ask questions.
+All contributions, bug reports, bug fixes, documentation improvements, enhancements and ideas are welcome. We [track issues](https://github.com/freqtrade/freqtrade/issues) on [GitHub](https://github.com) and also have a dev channel on [discord](https://discord.gg/MA9v74M) or [slack](https://join.slack.com/t/highfrequencybot/shared_invite/zt-jaut7r4m-Y17k4x5mcQES9a9swKuxbg) where you can ask questions.
 
 ## Documentation
 
@@ -10,13 +10,35 @@ Documentation is available at [https://freqtrade.io](https://www.freqtrade.io/)
 
 Special fields for the documentation (like Note boxes, ...) can be found [here](https://squidfunk.github.io/mkdocs-material/extensions/admonition/).
 
+To test the documentation locally use the following commands.
+
+``` bash
+pip install -r docs/requirements-docs.txt
+mkdocs serve
+```
+
+This will spin up a local server (usually on port 8000) so you can see if everything looks as you'd like it to.
+
 ## Developer setup
 
-To configure a development environment, best use the `setup.sh` script and answer "y" when asked "Do you want to install dependencies for dev [y/N]? ".
-Alternatively (if your system is not supported by the setup.sh script), follow the manual installation process and run `pip3 install -e .[all]`.
+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`, `flake8`, `mypy`, and `coveralls`.
 
+### Devcontainer setup
+
+The fastest and easiest way to get started is to use [VSCode](https://code.visualstudio.com/) with the Remote container extension.
+This gives developers the ability to start the bot with all required dependencies *without* needing to install any freqtrade specific dependencies on your local machine.
+
+#### Devcontainer dependencies
+
+* [VSCode](https://code.visualstudio.com/)
+* [docker](https://docs.docker.com/install/)
+* [Remote container extension documentation](https://code.visualstudio.com/docs/remote)
+
+For more information about the [Remote container extension](https://code.visualstudio.com/docs/remote), best consult the documentation.
+
 ### Tests
 
 New code should be covered by basic unittests. Depending on the complexity of the feature, Reviewers may request more in-depth unittests.
@@ -41,50 +63,6 @@ def test_method_to_test(caplog):
 
 ```
 
-### Local docker usage
-
-The fastest and easiest way to start up is to use docker-compose.develop which gives developers the ability to start the bot up with all the required dependencies, *without* needing to install any freqtrade specific dependencies on your local machine.
-
-#### Install
-
-* [git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
-* [docker](https://docs.docker.com/install/)
-* [docker-compose](https://docs.docker.com/compose/install/)
-
-#### Starting the bot
-##### Use the develop dockerfile
-
-``` bash
-rm docker-compose.yml && mv docker-compose.develop.yml docker-compose.yml
-```
-
-#### Docker Compose
-
-##### Starting
-
-``` bash
-docker-compose up
-```
-
-![Docker compose up](https://user-images.githubusercontent.com/419355/65456322-47f63a80-de06-11e9-90c6-3c74d1bad0b8.png)
-
-##### Rebuilding
-
-``` bash
-docker-compose build
-```
-
-##### Execing (effectively SSH into the container)
-
-The `exec` command requires that the container already be running, if you want to start it
-that can be effected by `docker-compose up` or `docker-compose run freqtrade_develop`
-
-``` bash
-docker-compose exec freqtrade_develop /bin/bash
-```
-
-![image](https://user-images.githubusercontent.com/419355/65456522-ba671a80-de06-11e9-9598-df9ca0d8dcac.png)
-
 ## ErrorHandling
 
 Freqtrade Exceptions all inherit from `FreqtradeException`.
@@ -110,13 +88,15 @@ Below is an outline of exception inheritance hierarchy:
 |       +---+ InvalidOrderException
 |           |
 |           +---+ RetryableOrderError
+|           |
+|           +---+ InsufficientFundsError
 |
 +---+ StrategyError
 ```
 
 ## Modules
 
-### Dynamic Pairlist
+### Pairlists
 
 You have a great idea for a new pair selection algorithm you would like to try out? Great.
 Hopefully you also want to contribute this back upstream.
@@ -127,7 +107,7 @@ First of all, have a look at the [VolumePairList](https://github.com/freqtrade/f
 
 This is a simple Handler, which however serves as a good example on how to start developing.
 
-Next, modify the classname of the Handler (ideally align this with the module filename).
+Next, modify the class-name of the Handler (ideally align this with the module filename).
 
 The base-class provides an instance of the exchange (`self._exchange`) the pairlist manager (`self._pairlistmanager`), as well as the main configuration (`self._config`), the pairlist dedicated configuration (`self._pairlistconfig`) and the absolute position within the list of pairlists.
 
@@ -147,7 +127,7 @@ Configuration for the chain of Pairlist Handlers is done in the bot configuratio
 
 By convention, `"number_assets"` is used to specify the maximum number of pairs to keep in the pairlist. Please follow this to ensure a consistent user experience.
 
-Additional parameters can be configured as needed. For instance, `VolumePairList` uses `"sort_key"` to specify the sorting value - however feel free to specify whatever is necessary for your great algorithm to be successfull and dynamic.
+Additional parameters can be configured as needed. For instance, `VolumePairList` uses `"sort_key"` to specify the sorting value - however feel free to specify whatever is necessary for your great algorithm to be successful and dynamic.
 
 #### short_desc
 
@@ -163,7 +143,7 @@ This is called with each iteration of the bot (only if the Pairlist Handler is a
 
 It must return the resulting pairlist (which may then be passed into the chain of Pairlist Handlers).
 
-Validations are optional, the parent class exposes a `_verify_blacklist(pairlist)` and `_whitelist_for_active_markets(pairlist)` to do default filtering. Use this if you limit your result to a certain number of pairs - so the endresult is not shorter than expected.
+Validations are optional, the parent class exposes a `_verify_blacklist(pairlist)` and `_whitelist_for_active_markets(pairlist)` to do default filtering. Use this if you limit your result to a certain number of pairs - so the end-result is not shorter than expected.
 
 #### filter_pairlist
 
@@ -171,13 +151,13 @@ This method is called for each Pairlist Handler in the chain by the pairlist man
 
 This is called with each iteration of the bot - so consider implementing caching for compute/network heavy calculations.
 
-It get's passed a pairlist (which can be the result of previous pairlists) as well as `tickers`, a pre-fetched version of `get_tickers()`.
+It gets passed a pairlist (which can be the result of previous pairlists) as well as `tickers`, a pre-fetched version of `get_tickers()`.
 
 The default implementation in the base class simply calls the `_validate_pair()` method for each pair in the pairlist, but you may override it. So you should either implement the `_validate_pair()` in your Pairlist Handler or override `filter_pairlist()` to do something else.
 
 If overridden, it must return the resulting pairlist (which may then be passed into the next Pairlist Handler in the chain).
 
-Validations are optional, the parent class exposes a `_verify_blacklist(pairlist)` and `_whitelist_for_active_markets(pairlist)` to do default filters. Use this if you limit your result to a certain number of pairs - so the endresult is not shorter than expected.
+Validations are optional, the parent class exposes a `_verify_blacklist(pairlist)` and `_whitelist_for_active_markets(pairlist)` to do default filters. Use this if you limit your result to a certain number of pairs - so the end result is not shorter than expected.
 
 In `VolumePairList`, this implements different methods of sorting, does early validation so only the expected number of pairs is returned.
 
@@ -201,7 +181,7 @@ Most exchanges supported by CCXT should work out of the box.
 
 Check if the new exchange supports Stoploss on Exchange orders through their API.
 
-Since CCXT does not provide unification for Stoploss On Exchange yet, we'll need to implement the exchange-specific parameters ourselfs. Best look at `binance.py` for an example implementation of this. You'll need to dig through the documentation of the Exchange's API on how exactly this can be done. [CCXT Issues](https://github.com/ccxt/ccxt/issues) may also provide great help, since others may have implemented something similar for their projects.
+Since CCXT does not provide unification for Stoploss On Exchange yet, we'll need to implement the exchange-specific parameters ourselves. Best look at `binance.py` for an example implementation of this. You'll need to dig through the documentation of the Exchange's API on how exactly this can be done. [CCXT Issues](https://github.com/ccxt/ccxt/issues) may also provide great help, since others may have implemented something similar for their projects.
 
 ### Incomplete candles
 
@@ -251,13 +231,14 @@ jupyter nbconvert --ClearOutputPreprocessor.enabled=True --to markdown freqtrade
 This documents some decisions taken for the CI Pipeline.
 
 * CI runs on all OS variants, Linux (ubuntu), macOS and Windows.
-* Docker images are build for the branches `master` and `develop`.
-* Raspberry PI Docker images are postfixed with `_pi` - so tags will be `:master_pi` and `develop_pi`.
+* Docker images are build for the branches `stable` and `develop`.
+* Docker images containing Plot dependencies are also available as `stable_plot` and `develop_plot`.
+* Raspberry PI Docker images are postfixed with `_pi` - so tags will be `:stable_pi` and `develop_pi`.
 * Docker images contain a file, `/freqtrade/freqtrade_commit` containing the commit this image is based of.
 * Full docker image rebuilds are run once a week via schedule.
 * Deployments run on ubuntu.
 * ta-lib binaries are contained in the build_helpers directory to avoid fails related to external unavailability.
-* All tests must pass for a PR to be merged to `master` or `develop`.
+* All tests must pass for a PR to be merged to `stable` or `develop`.
 
 ## Creating a release
 
@@ -274,21 +255,22 @@ git checkout -b new_release <commitid>
 
 Determine if crucial bugfixes have been made between this commit and the current state, and eventually cherry-pick these.
 
+* Merge the release branch (stable) into this branch.
 * Edit `freqtrade/__init__.py` and add the version matching the current date (for example `2019.7` for July 2019). Minor versions can be `2019.7.1` should we need to do a second release that month. Version numbers must follow allowed versions from PEP0440 to avoid failures pushing to pypi.
 * Commit this part
-* push that branch to the remote and create a PR against the master branch
+* push that branch to the remote and create a PR against the stable branch
 
 ### Create changelog from git commits
 
 !!! Note
-    Make sure that the master branch is uptodate!
+    Make sure that the `stable` branch is up-to-date!
 
 ``` bash
 # Needs to be done before merging / pulling that branch.
-git log --oneline --no-decorate --no-merges master..new_release
+git log --oneline --no-decorate --no-merges stable..new_release
 ```
 
-To keep the release-log short, best wrap the full git changelog into a collapsible details secction.
+To keep the release-log short, best wrap the full git changelog into a collapsible details section.
 
 ```markdown
 <details>
@@ -301,17 +283,20 @@ To keep the release-log short, best wrap the full git changelog into a collapsib
 
 ### Create github release / tag
 
-Once the PR against master is merged (best right after merging):
+Once the PR against stable is merged (best right after merging):
 
 * Use the button "Draft a new release" in the Github UI (subsection releases).
 * Use the version-number specified as tag.
-* Use "master" as reference (this step comes after the above PR is merged).
+* Use "stable" as reference (this step comes after the above PR is merged).
 * Use the above changelog as release comment (as codeblock)
 
 ## Releases
 
 ### pypi
 
+!!! Note
+    This process is now automated as part of Github Actions.
+
 To create a pypi release, please run the following commands:
 
 Additional requirement: `wheel`, `twine` (for uploading), account on pypi with proper permissions.

docs/docker.md

@@ -1,145 +1,7 @@
-# Using Freqtrade with Docker
-
-## Install Docker
-
-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/)
-
-Optionally, [docker-compose](https://docs.docker.com/compose/install/) should be installed and available to follow the [docker quick start guide](#docker-quick-start).
-
-Once you have Docker installed, simply prepare the config file (e.g. `config.json`) and run the image for `freqtrade` as explained below.
-
-## 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/develop/docker-compose.yml) ready for usage.
-
-!!! Note
-    The following section assumes that docker and docker-compose is installed and available to the logged in user.
-
-!!! Note
-    All below comands use relative directories and will have to be executed from the directory containing the `docker-compose.yml` file.
-
-!!! Note "Docker on Raspberry"
-    If you're running freqtrade on a Raspberry PI, you must change the image from `freqtradeorg/freqtrade:master` to `freqtradeorg/freqtrade:master_pi` or `freqtradeorg/freqtrade:develop_pi`, otherwise the image will not work.
-
-### Docker quick start
-
-Create a new directory and place the [docker-compose file](https://github.com/freqtrade/freqtrade/blob/develop/docker-compose.yml) in this directory.
-
-``` bash
-mkdir ft_userdata
-cd ft_userdata/
-# Download the docker-compose file from the repository
-curl https://raw.githubusercontent.com/freqtrade/freqtrade/develop/docker-compose.yml -o docker-compose.yml
-
-# Pull the freqtrade image
-docker-compose pull
-
-# Create user directory structure
-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
-```
-
-The above snippet creates a new directory called "ft_userdata", downloads the latest compose file and pulls the freqtrade image.
-The last 2 steps in the snippet create the directory with user-data, as well as (interactively) the default configuration based on your selections.
-
-!!! Note
-    You can edit the configuration at any time, which is available as `user_data/config.json` (within the directory `ft_userdata`) when using the above configuration.
-
-#### Adding your strategy
-
-The configuration is now available as `user_data/config.json`.
-You should now copy your strategy to `user_data/strategies/` - and add the Strategy class name to the `docker-compose.yml` file, replacing `SampleStrategy`. If you wish to run the bot with the SampleStrategy, just leave it as it is.
-
-!!! Warning
-    The `SampleStrategy` is there for your reference and give you ideas for your own strategy.
-    Please always backtest the strategy and use dry-run for some time before risking real money!
-
-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 logs
-
-Logs will be written to `user_data/logs/freqtrade.log`. 
-Alternatively, you can check the latest logs using `docker-compose logs -f`.
-
-#### Database
-
-The database will be in the user_data directory as well, and will be called `user_data/tradesv3.sqlite`.
-
-#### Updating freqtrade with docker-compose
-
-To update freqtrade when using docker-compose is as simple as running the following 2 commands:
-
-``` bash
-# Download the latest image
-docker-compose pull
-# Restart the image
-docker-compose up -d
-```
-
-This will first pull the latest image, and will then restart the container with the just pulled version.
-
-!!! Note
-    You should always check the changelog for breaking changes / manual interventions required and make sure the bot starts correctly after the update.
-
-#### Going from here
-
-Advanced users may edit the docker-compose file further to include all possible options or arguments.
-
-All possible freqtrade arguments will be available by running `docker-compose run --rm freqtrade <command> <optional arguments>`.
-
-!!! Note "`docker-compose run --rm`"
-    Including `--rm` will clean up the container after completion, and is highly recommended for all modes except trading mode (running with `freqtrade trade` command).
-
-##### 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
-```
-
-Head over to the [Data Downloading Documentation](data-download.md) for more details on downloading data.
-
-##### 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
-```
-
-Head over to the [Backtesting Documentation](backtesting.md) to learn more.
-
-#### Additional dependencies with docker-compose
-
-If your strategy requires dependencies not included in the default image (like [technical](https://github.com/freqtrade/technical)) - 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 [Dockerfile.technical](https://github.com/freqtrade/freqtrade/blob/develop/Dockerfile.technical) for an example).
-
-You'll then also need to modify the `docker-compose.yml` file and uncomment the build step, as well as rename the image to avoid naming collisions.
-
-``` yaml
-    image: freqtrade_custom
-    build:
-      context: .
-      dockerfile: "./Dockerfile.<yourextension>"
-```
-
-You can then run `docker-compose build` to build the docker image, and run it using the commands described above.
-
 ## Freqtrade with docker without docker-compose
 
 !!! Warning
-    The below documentation is provided for completeness and assumes that you are somewhat familiar with running docker containers. If you're just starting out with docker, we recommend to follow the [Freqtrade with docker-compose](#freqtrade-with-docker-compose) instructions.
+    The below documentation is provided for completeness and assumes that you are familiar with running docker containers. If you're just starting out with Docker, we recommend to follow the [Quickstart](docker.md) instructions.
 
 ### Download the official Freqtrade docker image
 
@@ -148,9 +10,9 @@ Pull the image from docker hub.
 Branches / tags available can be checked out on [Dockerhub tags page](https://hub.docker.com/r/freqtradeorg/freqtrade/tags/).
 
 ```bash
-docker pull freqtradeorg/freqtrade:develop
+docker pull freqtradeorg/freqtrade:stable
 # Optionally tag the repository so the run-commands remain shorter
-docker tag freqtradeorg/freqtrade:develop freqtrade
+docker tag freqtradeorg/freqtrade:stable freqtrade
 ```
 
 To update the image, simply run the above commands again and restart your running container.
@@ -158,7 +20,7 @@ To update the image, simply run the above commands again and restart your runnin
 Should you require additional libraries, please [build the image yourself](#build-your-own-docker-image).
 
 !!! Note "Docker image update frequency"
-    The official docker images with tags `master`, `develop` and `latest` are automatically rebuild once a week to keep the base image uptodate.
+    The official docker images with tags `stable`, `develop` and `latest` are automatically rebuild once a week to keep the base image up-to-date.
     In addition to that, every merge to `develop` will trigger a rebuild for `develop` and `latest`.
 
 ### Prepare the configuration files
@@ -190,39 +52,38 @@ cp -n config.json.example config.json
 
 #### Create your database file
 
-Production
+=== "Dry-Run"
+    ``` bash
+    touch tradesv3.dryrun.sqlite
+    ```
 
-```bash
-touch tradesv3.sqlite
-````
+=== "Production"
+    ``` bash
+    touch tradesv3.sqlite
+    ```
 
-Dry-Run
 
-```bash
-touch tradesv3.dryrun.sqlite
-```
-
-!!! Note
-    Make sure to use the path to this file when starting the bot in docker.
+!!! Warning "Database File Path"
+    Make sure to use the path to the correct database file when starting the bot in Docker.
 
 ### Build your own Docker image
 
 Best start by pulling the official docker image from dockerhub as explained [here](#download-the-official-docker-image) to speed up building.
 
-To add additional libraries to your docker image, best check out [Dockerfile.technical](https://github.com/freqtrade/freqtrade/blob/develop/Dockerfile.technical) which adds the [technical](https://github.com/freqtrade/technical) module to the image.
+To add additional libraries to your docker image, best check out [Dockerfile.technical](https://github.com/freqtrade/freqtrade/blob/develop/docker/Dockerfile.technical) which adds the [technical](https://github.com/freqtrade/technical) module to the image.
 
 ```bash
-docker build -t freqtrade -f Dockerfile.technical .
+docker build -t freqtrade -f docker/Dockerfile.technical .
 ```
 
-If you are developing using Docker, use `Dockerfile.develop` to build a dev Docker image, which will also set up develop dependencies:
+If you are developing using Docker, use `docker/Dockerfile.develop` to build a dev Docker image, which will also set up develop dependencies:
 
 ```bash
-docker build -f Dockerfile.develop -t freqtrade-dev .
+docker build -f docker/Dockerfile.develop -t freqtrade-dev .
 ```
 
-!!! Note
-    For security reasons, your configuration file will not be included in the image, you will need to bind mount it. It is also advised to bind mount an SQLite database file (see the "5. Run a restartable docker image" section) to keep it between  updates.
+!!! Warning "Include your config file manually"
+    For security reasons, your configuration file will not be included in the image, you will need to bind mount it. It is also advised to bind mount an SQLite database file (see [5. Run a restartable docker image](#run-a-restartable-docker-image)") to keep it between  updates.
 
 #### Verify the Docker image
 
@@ -243,37 +104,36 @@ docker run --rm -v `pwd`/config.json:/freqtrade/config.json -it freqtrade
 ```
 
 !!! Warning
-    In this example, the database will be created inside the docker instance and will be lost when you will refresh your image.
+    In this example, the database will be created inside the docker instance and will be lost when you refresh your image.
 
 #### Adjust timezone
 
 By default, the container will use UTC timezone.
-Should you find this irritating please add the following to your docker commands:
+If you would like to change the timezone use the following commands:
 
-##### Linux
+=== "Linux"
+    ``` bash
+    -v /etc/timezone:/etc/timezone:ro
 
-``` bash
--v /etc/timezone:/etc/timezone:ro
+    # Complete command:
+    docker run --rm -v /etc/timezone:/etc/timezone:ro -v `pwd`/config.json:/freqtrade/config.json -it freqtrade
+    ```
 
-# Complete command:
-docker run --rm -v /etc/timezone:/etc/timezone:ro -v `pwd`/config.json:/freqtrade/config.json -it freqtrade
-```
+=== "MacOS"
+    ```bash
+    docker run --rm -e TZ=`ls -la /etc/localtime | cut -d/ -f8-9` -v `pwd`/config.json:/freqtrade/config.json -it freqtrade
+    ```
 
-##### MacOS
-
-There is known issue in OSX Docker versions after 17.09.1, whereby `/etc/localtime` cannot be shared causing Docker to not start. A work-around for this is to start with the following cmd.
-
-```bash
-docker run --rm -e TZ=`ls -la /etc/localtime | cut -d/ -f8-9` -v `pwd`/config.json:/freqtrade/config.json -it freqtrade
-```
-
-More information on this docker issue and work-around can be read [here](https://github.com/docker/for-mac/issues/2396).
+!!! Note "MacOS Issues"
+    The OSX Docker versions after 17.09.1 have a known issue whereby `/etc/localtime` cannot be shared causing Docker to not start.<br>
+    A work-around for this is to start with the MacOS command above
+    More information on this docker issue and work-around can be read [here](https://github.com/docker/for-mac/issues/2396).
 
 ### Run a restartable docker image
 
 To run a restartable instance in the background (feel free to place your configuration and database files wherever it feels comfortable on your filesystem).
 
-#### Move your config file and database
+#### 1. Move your config file and database
 
 The following will assume that you place your configuration / database files to `~/.freqtrade`, which is a hidden directory in your home directory. Feel free to use a different directory and replace the directory in the upcomming commands.
 
@@ -283,7 +143,7 @@ mv config.json ~/.freqtrade
 mv tradesv3.sqlite ~/.freqtrade
 ```
 
-#### Run the docker image
+#### 2. Run the docker image
 
 ```bash
 docker run -d \

docs/docker_quickstart.md

@@ -0,0 +1,191 @@
+# Using Freqtrade with Docker
+
+## Install Docker
+
+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/)
+
+Optionally, [`docker-compose`](https://docs.docker.com/compose/install/) should be installed and available to follow the [docker quick start guide](#docker-quick-start).
+
+Once you have Docker installed, simply prepare the config file (e.g. `config.json`) and run the image for `freqtrade` as explained below.
+
+## 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/develop/docker-compose.yml) ready for usage.
+
+!!! Note
+    - 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
+
+Create a new directory and place the [docker-compose file](https://github.com/freqtrade/freqtrade/blob/develop/docker-compose.yml) in this directory.
+
+=== "PC/MAC/Linux"
+    ``` bash
+    mkdir ft_userdata
+    cd ft_userdata/
+    # Download the docker-compose file from the repository
+    curl https://raw.githubusercontent.com/freqtrade/freqtrade/stable/docker-compose.yml -o docker-compose.yml
+
+    # Pull the freqtrade image
+    docker-compose pull
+
+    # Create user directory structure
+    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
+    ```
+
+=== "RaspberryPi"
+    ``` bash
+    mkdir ft_userdata
+    cd ft_userdata/
+    # Download the docker-compose file from the repository
+    curl https://raw.githubusercontent.com/freqtrade/freqtrade/stable/docker-compose.yml -o docker-compose.yml
+
+    # Pull the freqtrade image
+    docker-compose pull
+
+    # Create user directory structure
+    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
+    ```
+
+    !!! Note "Change your docker Image"
+        You have to change the docker image in the docker-compose file for your Raspberry build to work properly.
+        ``` yml
+        image: freqtradeorg/freqtrade:stable_pi
+        # image: freqtradeorg/freqtrade:develop_pi
+        ```
+
+The above snippet creates a new directory called `ft_userdata`, downloads the latest compose file and pulls the freqtrade image.
+The last 2 steps in the snippet create the directory with `user_data`, as well as (interactively) the default configuration based on your selections.
+
+!!! Question "How to edit the bot configuration?"
+    You can edit the configuration at any time, which is available as `user_data/config.json` (within the directory `ft_userdata`) when using the above configuration.
+
+    You can also change the both Strategy and commands by editing the `docker-compose.yml` file.
+
+#### Adding a custom strategy
+
+1. The configuration is now available as `user_data/config.json`
+2. Copy a custom strategy to the directory `user_data/strategies/`
+3. add the Strategy' class name to the `docker-compose.yml` file
+
+The `SampleStrategy` is run by default.
+
+!!! Warning "`SampleStrategy` is just a demo!"
+    The `SampleStrategy` is there for your reference and give you ideas for your own strategy.
+    Please always backtest the strategy and use dry-run for some time before risking real money!
+
+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 logs
+
+Logs will be located at: `user_data/logs/freqtrade.log`. 
+You can check the latest log with the command `docker-compose logs -f`.
+
+#### Database
+
+The database will be at: `user_data/tradesv3.sqlite`
+
+#### Updating freqtrade with docker-compose
+
+To update freqtrade when using `docker-compose` is as simple as running the following 2 commands:
+
+``` bash
+# Download the latest image
+docker-compose pull
+# Restart the image
+docker-compose up -d
+```
+
+This will first pull the latest image, and will then restart the container with the just pulled version.
+
+!!! Warning "Check the Changelog"
+    You should always check the changelog for breaking changes / manual interventions required and make sure the bot starts correctly after the update.
+
+### Editing the docker-compose file
+
+Advanced users may edit the docker-compose file further to include all possible options or arguments.
+
+All possible freqtrade arguments will be available by running `docker-compose run --rm freqtrade <command> <optional arguments>`.
+
+!!! Note "`docker-compose run --rm`"
+    Including `--rm` will clean up the container after completion, and is highly recommended for all modes except trading mode (running with `freqtrade trade` command).
+
+#### 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
+```
+
+Head over to the [Data Downloading Documentation](data-download.md) for more details on downloading data.
+
+#### 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
+```
+
+Head over to the [Backtesting Documentation](backtesting.md) to learn more.
+
+### Additional dependencies with docker-compose
+
+If your strategy requires dependencies not included in the default image (like [technical](https://github.com/freqtrade/technical)) - 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.technical](https://github.com/freqtrade/freqtrade/blob/develop/docker/Dockerfile.technical) for an example).
+
+You'll then also need to modify the `docker-compose.yml` file and uncomment the build step, as well as rename the image to avoid naming collisions.
+
+``` yaml
+    image: freqtrade_custom
+    build:
+      context: .
+      dockerfile: "./Dockerfile.<yourextension>"
+```
+
+You can then run `docker-compose build` to build the docker image, and run it using the commands described above.
+
+## 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
+```
+
+The output will be stored in the `user_data/plot` directory, and can be opened with any modern browser.
+
+## Data analayis using docker compose
+
+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 --rm -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.
+
+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) uptodate.
+
+``` bash
+docker-compose -f docker/docker-compose-jupyter.yml build --no-cache
+```

docs/edge.md

@@ -1,92 +1,156 @@
 # Edge positioning
 
-This page explains how to use Edge Positioning module in your bot in order to enter into a trade only if the trade has a reasonable win rate and risk reward ratio, and consequently adjust your position size and stoploss.
+The `Edge Positioning` module uses probability to calculate your win rate and risk reward ration. It will use these statistics to control your strategy trade entry points, position side and, stoploss. 
 
 !!! Warning
-    Edge positioning is not compatible with dynamic (volume-based) whitelist.
+    `Edge positioning` is not compatible with dynamic (volume-based) whitelist.
 
 !!! Note
-    Edge does not consider anything other than *its own* buy/sell/stoploss signals. It ignores the stoploss, trailing stoploss, and ROI settings in the strategy configuration file.
-    Therefore, it is important to understand that Edge can improve the performance of some trading strategies but *decrease* the performance of others.
+    `Edge Positioning` only considers *its own* buy/sell/stoploss signals. It ignores the stoploss, trailing stoploss, and ROI settings in the strategy configuration file.
+    `Edge Positioning` improves the performance of some trading strategies and *decreases* the performance of others.
 
 ## Introduction
 
-Trading is all about probability. No one can claim that he has a strategy working all the time. You have to assume that sometimes you lose.
+Trading strategies are not perfect. They are frameworks that are susceptible to the market and its indicators. Because the market is not at all predictable, sometimes a strategy will win and sometimes the same strategy will lose.
 
-But it doesn't mean there is no rule, it only means rules should work "most of the time". Let's play a game: we toss a coin, heads: I give you 10$, tails: you give me 10$. Is it an interesting game? No, it's quite boring, isn't it?
+To obtain an edge in the market, a strategy has to make more money than it loses. Making money in trading is not only about *how often* the strategy makes or loses money. 
 
-But let's say the probability that we have heads is 80% (because our coin has the displaced distribution of mass or other defect), and the probability that we have tails is 20%. Now it is becoming interesting...
+!!! tip "It doesn't matter how often, but how much!"
+    A bad strategy might make 1 penny in *ten* transactions but lose 1 dollar in *one* transaction. If one only checks the number of winning trades, it would be misleading to think that the strategy is actually making a profit.
 
-That means 10$ X 80% versus 10$ X 20%. 8$ versus 2$. That means over time you will win 8$ risking only 2$ on each toss of coin.
+The Edge Positioning module seeks to improve a strategy's winning probability and the money that the strategy will make *on the long run*. 
 
-Let's complicate it more: you win 80% of the time but only 2$, I win 20% of the time but 8$. The calculation is: 80% X 2$ versus 20% X 8$. It is becoming boring again because overtime you win $1.6$ (80% X 2$) and me $1.6 (20% X 8$) too.
+We raise the following question[^1]:
 
-The question is: How do you calculate that? How do you know if you wanna play?
+!!! Question "Which trade is a better option?"
+    a) A trade with 80% of chance of losing $100 and 20% chance of winning $200<br/>
+    b) A trade with 100% of chance of losing $30
 
-The answer comes to two factors:
+???+ Info "Answer"
+    The expected value of *a)* is smaller than the expected value of *b)*.<br/>
+    Hence, *b*) represents a smaller loss in the long run.<br/>
+    However, the answer is: *it depends*
 
-- Win Rate
-- Risk Reward Ratio
+Another way to look at it is to ask a similar question:
 
-### Win Rate
+!!! Question "Which trade is a better option?"
+    a) A trade with 80% of chance of winning 100 and 20% chance of losing $200<br/>
+    b) A trade with 100% of chance of winning $30
 
-Win Rate (*W*) is is the mean over some amount of trades (*N*) what is the percentage of winning trades to total number of trades (note that we don't consider how much you gained but only if you won or not).
+Edge positioning tries to answer the hard questions about risk/reward and position size automatically, seeking to minimizes the chances of losing of a given strategy.
 
-```
-W = (Number of winning trades) / (Total number of trades) = (Number of winning trades) / N
-```
+### Trading, winning and losing
 
-Complementary Loss Rate (*L*) is defined as
+Let's call $o$ the return of a single transaction $o$ where $o \in \mathbb{R}$. The collection $O = \{o_1, o_2, ..., o_N\}$ is the set of all returns of transactions made during a trading session. We say that $N$ is the cardinality of $O$, or, in lay terms, it is the number of transactions made in a trading session.
 
-```
-L = (Number of losing trades) / (Total number of trades) = (Number of losing trades) / N
-```
+!!! Example
+    In a session where a strategy made three transactions we can say that $O = \{3.5, -1, 15\}$. That means that $N = 3$ and $o_1 = 3.5$, $o_2 = -1$, $o_3 = 15$.
 
-or, which is the same, as
+A winning trade is a trade where a strategy *made* money. Making money means that the strategy closed the position in a value that returned a profit, after all deducted fees. Formally, a winning trade will have a return $o_i > 0$. Similarly, a losing trade will have a return $o_j \leq 0$. With that, we can discover the set of all winning trades, $T_{win}$, as follows:
 
-```
-L = 1 – W
-```
+$$ T_{win} = \{ o \in O | o > 0 \} $$
+
+Similarly, we can discover the set of losing trades $T_{lose}$ as follows:
+
+$$ T_{lose} = \{o \in O | o \leq 0\} $$
+
+!!! Example
+    In a section where a strategy made three transactions $O = \{3.5, -1, 15, 0\}$:<br>
+    $T_{win} = \{3.5, 15\}$<br>
+    $T_{lose} = \{-1, 0\}$<br>
+
+### Win Rate and Lose Rate
+
+The win rate $W$ is the proportion of winning trades with respect to all the trades made by a strategy. We use the following function to compute the win rate:
+
+$$W = \frac{|T_{win}|}{N}$$
+
+Where $W$ is the win rate, $N$ is the number of trades and, $T_{win}$ is the set of all trades where the strategy made money.
+
+Similarly, we can compute the rate of losing trades:
+
+$$ 
+    L = \frac{|T_{lose}|}{N} 
+$$
+
+Where $L$ is the lose rate, $N$ is the amount of trades made and, $T_{lose}$ is the set of all trades where the strategy lost money. Note that the above formula is the same as calculating $L = 1 – W$ or $W = 1 – L$
 
 ### Risk Reward Ratio
 
-Risk Reward Ratio (*R*) is a formula used to measure the expected gains of a given investment against the risk of loss. It is basically what you potentially win divided by what you potentially lose:
+Risk Reward Ratio ($R$) is a formula used to measure the expected gains of a given investment against the risk of loss. It is basically what you potentially win divided by what you potentially lose. Formally:
 
-```
-R = Profit / Loss
-```
+$$ R = \frac{\text{potential_profit}}{\text{potential_loss}} $$
 
-Over time, on many trades, you can calculate your risk reward by dividing your average profit on winning trades by your average loss on losing trades:
+???+ Example "Worked example of $R$ calculation"
+    Let's say that you think that the price of *stonecoin* today is $10.0. You believe that, because they will start mining stonecoin, it will go up to $15.0 tomorrow. There is the risk that the stone is too hard, and the GPUs can't mine it, so the price might go to $0 tomorrow. You are planning to invest $100, which will give you 10 shares (100 / 10).
 
-```
-Average profit = (Sum of profits) / (Number of winning trades)
+    Your potential profit is calculated as:
 
-Average loss = (Sum of losses) / (Number of losing trades)
+    $\begin{aligned} 
+        \text{potential_profit} &= (\text{potential_price} - \text{entry_price}) * \frac{\text{investment}}{\text{entry_price}} \\
+                                &= (15 - 10) * (100 / 10) \\
+                                &= 50
+    \end{aligned}$
+
+    Since the price might go to $0, the $100 dollars invested could turn into 0.
+
+    We do however use a stoploss of 15% - so in the worst case, we'll sell 15% below entry price (or at 8.5$).
+
+    $\begin{aligned}
+        \text{potential_loss} &= (\text{entry_price} - \text{stoploss}) * \frac{\text{investment}}{\text{entry_price}} \\
+                                &= (10 - 8.5) * (100 / 10)\\
+                                &= 15
+    \end{aligned}$
+
+    We can compute the Risk Reward Ratio as follows:
+
+    $\begin{aligned}
+        R   &= \frac{\text{potential_profit}}{\text{potential_loss}}\\
+            &= \frac{50}{15}\\
+            &= 3.33
+    \end{aligned}$<br>
+    What it effectively means is that the strategy have the potential to make 3.33$ for each $1 invested.
+
+On a long horizon, that is, on many trades, we can calculate the risk reward by dividing the strategy' average profit on winning trades by the strategy' average loss on losing trades. We can calculate the average profit, $\mu_{win}$, as follows:
+
+$$ \text{average_profit} = \mu_{win} = \frac{\text{sum_of_profits}}{\text{count_winning_trades}} = \frac{\sum^{o \in T_{win}} o}{|T_{win}|} $$
+
+Similarly, we can calculate the average loss, $\mu_{lose}$, as follows:
+
+$$ \text{average_loss} = \mu_{lose} = \frac{\text{sum_of_losses}}{\text{count_losing_trades}} = \frac{\sum^{o \in T_{lose}} o}{|T_{lose}|} $$
+
+Finally, we can calculate the Risk Reward ratio, $R$, as follows:
+
+$$ R = \frac{\text{average_profit}}{\text{average_loss}} = \frac{\mu_{win}}{\mu_{lose}}\\ $$
+
+
+???+ Example "Worked example of $R$ calculation using mean profit/loss"
+    Let's say the strategy that we are using makes an average win $\mu_{win} = 2.06$ and an average loss $\mu_{loss} = 4.11$.<br>
+    We calculate the risk reward ratio as follows:<br>
+    $R = \frac{\mu_{win}}{\mu_{loss}} = \frac{2.06}{4.11} = 0.5012...$
     
-R = (Average profit) / (Average loss)
-```
 
 ### Expectancy
 
-At this point we can combine *W* and *R* to create an expectancy ratio. This is a simple process of multiplying the risk reward ratio by the percentage of winning trades and subtracting the percentage of losing trades, which is calculated as follows:
+By combining the Win Rate $W$ and and the Risk Reward ratio $R$ to create an expectancy ratio $E$. A expectance ratio is the expected return of the investment made in a trade. We can compute the value of $E$ as follows:
 
-```
-Expectancy Ratio = (Risk Reward Ratio X Win Rate) – Loss Rate = (R X W) – L
-```
+$$E = R * W - L$$
 
-So lets say your Win rate is 28% and your Risk Reward Ratio is 5:
+!!! Example "Calculating $E$"
+    Let's say that a strategy has a win rate $W = 0.28$ and a risk reward ratio $R = 5$. What this means is that the strategy is expected to make 5 times the investment around on 28% of the trades it makes. Working out the example:<br>
+    $E = R * W - L = 5 * 0.28 - 0.72 = 0.68$
+    <br>
 
-```
-Expectancy = (5 X 0.28) – 0.72 = 0.68
-```
+The expectancy worked out in the example above means that, on average, this strategy' trades will return 1.68 times the size of its losses. Said another way, the strategy makes $1.68 for every $1 it loses, on average. 
 
-Superficially, this means that on average you expect this strategy’s trades to return 1.68 times the size of your loses. Said another way, you can expect to win $1.68 for every $1 you lose. This is important for two reasons: First, it may seem obvious, but you know right away that you have a positive return. Second, you now have a number you can compare to other candidate systems to make decisions about which ones you employ.
+This is important for two reasons: First, it may seem obvious, but you know right away that you have a positive return. Second, you now have a number you can compare to other candidate systems to make decisions about which ones you employ.
 
 It is important to remember that any system with an expectancy greater than 0 is profitable using past data. The key is finding one that will be profitable in the future.
 
 You can also use this value to evaluate the effectiveness of modifications to this system.
 
-**NOTICE:** It's important to keep in mind that Edge is testing your expectancy using historical data, there's no guarantee that you will have a similar edge in the future. It's still vital to do this testing in order to build confidence in your methodology, but be wary of "curve-fitting" your approach to the historical data as things are unlikely to play out the exact same way for future trades.
+!!! Note
+    It's important to keep in mind that Edge is testing your expectancy using historical data, there's no guarantee that you will have a similar edge in the future. It's still vital to do this testing in order to build confidence in your methodology but be wary of "curve-fitting" your approach to the historical data as things are unlikely to play out the exact same way for future trades.
 
 ## How does it work?
 
@@ -99,13 +163,13 @@ Edge combines dynamic stoploss, dynamic positions, and whitelist generation into
 | XZC/ETH  |  -0.03        |   0.52       |1.359670           | 0.228      |
 | XZC/ETH  |  -0.04        |   0.51       |1.234539           | 0.117      |
 
-The goal here is to find the best stoploss for the strategy in order to have the maximum expectancy. In the above example stoploss at 3% leads to the maximum expectancy according to historical data.
+The goal here is to find the best stoploss for the strategy in order to have the maximum expectancy. In the above example stoploss at $3%$ leads to the maximum expectancy according to historical data.
 
 Edge module then forces stoploss value it evaluated to your strategy dynamically.
 
 ### Position size
 
-Edge also dictates the stake amount for each trade to the bot according to the following factors:
+Edge dictates the amount at stake for each trade to the bot according to the following factors:
 
 - Allowed capital at risk
 - Stoploss
@@ -116,9 +180,9 @@ Allowed capital at risk is calculated as follows:
 Allowed capital at risk = (Capital available_percentage) X (Allowed risk per trade)
 ```
 
-Stoploss is calculated as described above against historical data.
+Stoploss is calculated as described above with respect to historical data.
 
-Your position size then will be:
+The position size is calculated as follows:
 
 ```
 Position size = (Allowed capital at risk) / Stoploss
@@ -126,19 +190,23 @@ Position size = (Allowed capital at risk) / Stoploss
 
 Example:
 
-Let's say the stake currency is ETH and you have 10 ETH on the exchange, your capital available percentage is 50% and you would allow 1% of risk for each trade. thus your available capital for trading is **10 x 0.5 = 5 ETH** and allowed capital at risk would be **5 x 0.01 = 0.05 ETH**.
+Let's say the stake currency is **ETH** and there is $10$ **ETH** on the wallet. The capital available percentage is $50%$ and the allowed risk per trade is $1\%$. Thus, the available capital for trading is $10 * 0.5 = 5$ **ETH** and the allowed capital at risk would be $5 * 0.01 = 0.05$ **ETH**.
 
-Let's assume Edge has calculated that for **XLM/ETH** market your stoploss should be at 2%. So your position size will be **0.05 / 0.02 = 2.5 ETH**.
+-   **Trade 1:** The strategy detects a new buy signal in the **XLM/ETH** market. `Edge Positioning` calculates a stoploss of $2\%$ and a position of $0.05 / 0.02 = 2.5$ **ETH**. The bot takes a position of $2.5$ **ETH** in the **XLM/ETH** market.
 
-Bot takes a position of 2.5 ETH on XLM/ETH (call it trade 1). Up next, you receive another buy signal while trade 1 is still open. This time on **BTC/ETH** market. Edge calculated stoploss for this market at 4%. So your position size would be 0.05 / 0.04 = 1.25 ETH (call it trade 2).
+-   **Trade 2:** The strategy detects a buy signal on the **BTC/ETH** market while **Trade 1** is still open. `Edge Positioning` calculates the stoploss of $4\%$ on this market. Thus, **Trade 2** position size is $0.05 / 0.04 = 1.25$ **ETH**.
 
-Note that available capital for trading didn’t change for trade 2 even if you had already trade 1. The available capital doesn’t mean the free amount on your wallet.
+!!! Tip "Available Capital $\neq$ Available in wallet"
+    The available capital for trading didn't change in **Trade 2** even with **Trade 1** still open. The available capital **is not** the free amount in the wallet.
 
-Now you have two trades open. The bot receives yet another buy signal for another market: **ADA/ETH**. This time the stoploss is calculated at 1%. So your position size is **0.05 / 0.01 = 5 ETH**. But there are already 3.75 ETH blocked in two previous trades. So the position size for this third trade would be **5 – 3.75 = 1.25 ETH**.
+-   **Trade 3:** The strategy detects a buy signal in the **ADA/ETH** market. `Edge Positioning` calculates a stoploss of $1\%$ and a position of $0.05 / 0.01 = 5$ **ETH**. Since **Trade 1** has $2.5$ **ETH** blocked and **Trade 2** has $1.25$ **ETH** blocked, there is only $5 - 1.25 - 2.5 = 1.25$ **ETH** available. Hence, the position size of **Trade 3** is $1.25$ **ETH**. 
 
-Available capital doesn’t change before a position is sold. Let’s assume that trade 1 receives a sell signal and it is sold with a profit of 1 ETH. Your total capital on exchange would be 11 ETH and the available capital for trading becomes 5.5 ETH.
+!!! Tip "Available Capital Updates"
+    The available capital does not change before a position is sold. After a trade is closed the Available Capital goes up if the trade was profitable or goes down if the trade was a loss.
 
-So the Bot receives another buy signal for trade 4 with a stoploss at 2% then your position size would be **0.055 / 0.02 = 2.75 ETH**.
+-   The strategy detects a sell signal in the **XLM/ETH** market. The bot exits **Trade 1** for a profit of $1$ **ETH**. The total capital in the wallet becomes $11$ **ETH** and the available capital for trading becomes $5.5$ **ETH**.
+
+-   **Trade 4** The strategy detects a new buy signal int the **XLM/ETH** market. `Edge Positioning` calculates the stoploss of $2%$, and the position size of $0.055 / 0.02 = 2.75$ **ETH**.
 
 ## Configurations
 
@@ -169,23 +237,23 @@ freqtrade edge
 
 An example of its output:
 
-| pair      |   stoploss |   win rate |   risk reward ratio |   required risk reward |   expectancy |   total number of trades |   average duration (min) |
-|:----------|-----------:|-----------:|--------------------:|-----------------------:|-------------:|-------------------------:|-------------------------:|
-| AGI/BTC   |      -0.02 |       0.64 |                5.86 |                   0.56 |         3.41 |                       14 |                       54 |
-| NXS/BTC   |      -0.03 |       0.64 |                2.99 |                   0.57 |         1.54 |                       11 |                       26 |
-| LEND/BTC  |      -0.02 |       0.82 |                2.05 |                   0.22 |         1.50 |                       11 |                       36 |
-| VIA/BTC   |      -0.01 |       0.55 |                3.01 |                   0.83 |         1.19 |                       11 |                       48 |
-| MTH/BTC   |      -0.09 |       0.56 |                2.82 |                   0.80 |         1.12 |                       18 |                       52 |
-| ARDR/BTC  |      -0.04 |       0.42 |                3.14 |                   1.40 |         0.73 |                       12 |                       42 |
-| BCPT/BTC  |      -0.01 |       0.71 |                1.34 |                   0.40 |         0.67 |                       14 |                       30 |
-| WINGS/BTC |      -0.02 |       0.56 |                1.97 |                   0.80 |         0.65 |                       27 |                       42 |
-| VIBE/BTC  |      -0.02 |       0.83 |                0.91 |                   0.20 |         0.59 |                       12 |                       35 |
-| MCO/BTC   |      -0.02 |       0.79 |                0.97 |                   0.27 |         0.55 |                       14 |                       31 |
-| GNT/BTC   |      -0.02 |       0.50 |                2.06 |                   1.00 |         0.53 |                       18 |                       24 |
-| HOT/BTC   |      -0.01 |       0.17 |                7.72 |                   4.81 |         0.50 |                      209 |                        7 |
-| SNM/BTC   |      -0.03 |       0.71 |                1.06 |                   0.42 |         0.45 |                       17 |                       38 |
-| APPC/BTC  |      -0.02 |       0.44 |                2.28 |                   1.27 |         0.44 |                       25 |                       43 |
-| NEBL/BTC  |      -0.03 |       0.63 |                1.29 |                   0.58 |         0.44 |                       19 |                       59 |
+| **pair**     |   **stoploss** |   **win rate** |   **risk reward ratio** |   **required risk reward** |   **expectancy** |   **total number of trades** |   **average duration (min)** |
+|:----------|-----------:|-----------:|--------------------:|-----------------------:|-------------:|-----------------:|---------------:|
+| **AGI/BTC**   |      -0.02 |       0.64 |                5.86 |                   0.56 |         3.41 |                       14 |                       54 |
+| **NXS/BTC**   |      -0.03 |       0.64 |                2.99 |                   0.57 |         1.54 |                       11 |                       26 |
+| **LEND/BTC**  |      -0.02 |       0.82 |                2.05 |                   0.22 |         1.50 |                       11 |                       36 |
+| **VIA/BTC**   |      -0.01 |       0.55 |                3.01 |                   0.83 |         1.19 |                       11 |                       48 |
+| **MTH/BTC**   |      -0.09 |       0.56 |                2.82 |                   0.80 |         1.12 |                       18 |                       52 |
+| **ARDR/BTC**  |      -0.04 |       0.42 |                3.14 |                   1.40 |         0.73 |                       12 |                       42 |
+| **BCPT/BTC**  |      -0.01 |       0.71 |                1.34 |                   0.40 |         0.67 |                       14 |                       30 |
+| **WINGS/BTC** |      -0.02 |       0.56 |                1.97 |                   0.80 |         0.65 |                       27 |                       42 |
+| **VIBE/BTC**  |      -0.02 |       0.83 |                0.91 |                   0.20 |         0.59 |                       12 |                       35 |
+| **MCO/BTC**   |      -0.02 |       0.79 |                0.97 |                   0.27 |         0.55 |                       14 |                       31 |
+| **GNT/BTC**   |      -0.02 |       0.50 |                2.06 |                   1.00 |         0.53 |                       18 |                       24 |
+| **HOT/BTC**   |      -0.01 |       0.17 |                7.72 |                   4.81 |         0.50 |                      209 |                        7 |
+| **SNM/BTC**   |      -0.03 |       0.71 |                1.06 |                   0.42 |         0.45 |                       17 |                       38 |
+| **APPC/BTC**  |      -0.02 |       0.44 |                2.28 |                   1.27 |         0.44 |                       25 |                       43 |
+| **NEBL/BTC**  |      -0.03 |       0.63 |                1.29 |                   0.58 |         0.44 |                       19 |                       59 |
 
 Edge produced the above table by comparing `calculate_since_number_of_days` to `minimum_expectancy` to find `min_trade_number` historical information based on the config file. The timerange Edge uses for its comparisons can be further limited by using the `--timerange` switch.
 
@@ -218,3 +286,6 @@ The full timerange specification:
 * Use tickframes since 2018/01/31: `--timerange=20180131-`
 * Use tickframes since 2018/01/31 till 2018/03/01 : `--timerange=20180131-20180301`
 * Use tickframes between POSIX timestamps 1527595200 1527618600: `--timerange=1527595200-1527618600`
+
+
+[^1]: Question extracted from MIT Opencourseware S096 - Mathematics with applications in Finance: https://ocw.mit.edu/courses/mathematics/18-s096-topics-in-mathematics-with-applications-in-finance-fall-2013/

docs/exchanges.md

@@ -23,7 +23,8 @@ Binance has been split into 3, and users must use the correct ccxt exchange ID f
 ## Kraken
 
 !!! Tip "Stoploss on Exchange"
-    Kraken supports `stoploss_on_exchange` and uses stop-loss-market orders. It provides great advantages, so we recommend to benefit from it, however since the resulting order is a stoploss-market order, sell-rates are not guaranteed, which makes this feature less secure than on other exchanges. This limitation is based on kraken's policy [source](https://blog.kraken.com/post/1234/announcement-delisting-pairs-and-temporary-suspension-of-advanced-order-types/) and [source2](https://blog.kraken.com/post/1494/kraken-enables-advanced-orders-and-adds-10-currency-pairs/) - which has stoploss-limit orders disabled.
+    Kraken 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 to use.
 
 ### Historic Kraken data
 
@@ -75,8 +76,7 @@ print(res)
 
 !!! 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.
-
+    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
 
@@ -99,10 +99,10 @@ To use subaccounts with FTX, you need to edit the configuration and add the foll
 
 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.
 
-
 ## Random notes for other exchanges
 
 * The Ocean (exchange id: `theocean`) exchange uses Web3 functionality and requires `web3` python package to be installed:
+
 ```shell
 $ pip3 install web3
 ```

docs/faq.md

@@ -89,7 +89,7 @@ Same fix should be done in the configuration file, if order types are defined in
 
 ### How do I search the bot logs for something?
 
-By default, the bot writes its log into stderr stream. This is implemented this way so that you can easily separate the bot's diagnostics messages from Backtesting, Edge and Hyperopt results, output from other various Freqtrade utility subcommands, as well as from the output of your custom `print()`'s you may have inserted into your strategy. So if you need to search the log messages with the grep utility, you need to redirect stderr to stdout and disregard stdout.
+By default, the bot writes its log into stderr stream. This is implemented this way so that you can easily separate the bot's diagnostics messages from Backtesting, Edge and Hyperopt results, output from other various Freqtrade utility sub-commands, as well as from the output of your custom `print()`'s you may have inserted into your strategy. So if you need to search the log messages with the grep utility, you need to redirect stderr to stdout and disregard stdout.
 
 * In unix shells, this normally can be done as simple as:
 ```shell
@@ -114,7 +114,7 @@ and then grep it as:
 ```shell
 $ cat /path/to/mylogfile.log | grep 'something'
 ```
-or even on the fly, as the bot works and the logfile grows:
+or even on the fly, as the bot works and the log file grows:
 ```shell
 $ tail -f /path/to/mylogfile.log | grep 'something'
 ```
@@ -137,23 +137,17 @@ compute.
 
 Since hyperopt uses Bayesian search, running for too many epochs may not produce greater results.
 
-It's therefore recommended to run between 500-1000 epochs over and over until you hit at least 10.000 epocs in total (or are satisfied with the result). You can best judge by looking at the results - if the bot keeps discovering better strategies, it's best to keep on going. 
+It's therefore recommended to run between 500-1000 epochs over and over until you hit at least 10.000 epochs in total (or are satisfied with the result). You can best judge by looking at the results - if the bot keeps discovering better strategies, it's best to keep on going.
 
 ```bash
-freqtrade hyperopt -e 1000
-```
-
-or if you want intermediate result to see
-
-```bash
-for i in {1..100}; do freqtrade hyperopt -e 1000; done
+freqtrade hyperopt --hyperop SampleHyperopt --hyperopt-loss SharpeHyperOptLossDaily --strategy SampleStrategy -e 1000
 ```
 
 ### Why does it take a long time to run hyperopt?
 
-* Discovering a great strategy with Hyperopt takes time. Study www.freqtrade.io, the Freqtrade Documentation page, join the Freqtrade [Slack community](https://join.slack.com/t/highfrequencybot/shared_invite/enQtNjU5ODcwNjI1MDU3LTU1MTgxMjkzNmYxNWE1MDEzYzQ3YmU4N2MwZjUyNjJjODRkMDVkNjg4YTAyZGYzYzlhOTZiMTE4ZjQ4YzM0OGE) - or the Freqtrade [discord community](https://discord.gg/X89cVG). While you patiently wait for the most advanced, free crypto bot in the world, to hand you a possible golden strategy specially designed just for you.
+* Discovering a great strategy with Hyperopt takes time. Study www.freqtrade.io, the Freqtrade Documentation page, join the Freqtrade [Slack community](https://join.slack.com/t/highfrequencybot/shared_invite/zt-jaut7r4m-Y17k4x5mcQES9a9swKuxbg) - or the Freqtrade [discord community](https://discord.gg/X89cVG). While you patiently wait for the most advanced, free crypto bot in the world, to hand you a possible golden strategy specially designed just for you.
 
-* If you wonder why it can take from 20 minutes to days to do 1000 epocs here are some answers:
+* If you wonder why it can take from 20 minutes to days to do 1000 epochs here are some answers:
 
 This answer was written during the release 0.15.1, when we had:
 
@@ -167,7 +161,7 @@ already 8\*10^9\*10 evaluations. A roughly total of 80 billion evals.
 Did you run 100 000 evals? Congrats, you've done roughly 1 / 100 000 th
 of the search space, assuming that the bot never tests the same parameters more than once.
 
-* The time it takes to run 1000 hyperopt epocs depends on things like: The available cpu, harddisk, ram, timeframe, timerange, indicator settings, indicator count, amount of coins that hyperopt test strategies on and the resulting trade count - which can be 650 trades in a year or 10.0000 trades depending if the strategy aims for big profits by trading rarely or for many low profit trades. 
+* The time it takes to run 1000 hyperopt epochs depends on things like: The available cpu, hard-disk, ram, timeframe, timerange, indicator settings, indicator count, amount of coins that hyperopt test strategies on and the resulting trade count - which can be 650 trades in a year or 10.0000 trades depending if the strategy aims for big profits by trading rarely or for many low profit trades. 
 
 Example: 4% profit 650 times vs 0,3% profit a trade 10.000 times in a year. If we assume you set the --timerange to 365 days. 
 
@@ -180,7 +174,7 @@ Example:
 
 The Edge module is mostly a result of brainstorming of [@mishaker](https://github.com/mishaker) and [@creslinux](https://github.com/creslinux) freqtrade team members.
 
-You can find further info on expectancy, winrate, risk management and position size in the following sources:
+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

docs/hyperopt.md

@@ -37,12 +37,20 @@ pip install -r requirements-hyperopt.txt
 Before we start digging into Hyperopt, we recommend you to take a look at
 the sample hyperopt file located in [user_data/hyperopts/](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/templates/sample_hyperopt.py).
 
-Configuring hyperopt is similar to writing your own strategy, and many tasks will be similar and a lot of code can be copied across from the strategy.
+Configuring hyperopt is similar to writing your own strategy, and many tasks will be similar.
 
-The simplest way to get started is to use `freqtrade new-hyperopt --hyperopt AwesomeHyperopt`.
-This will create a new hyperopt file from a template, which will be located under `user_data/hyperopts/AwesomeHyperopt.py`.
+!!! Tip "About this page"
+    For this page, we will be using a fictional strategy called `AwesomeStrategy` - which will be optimized using the `AwesomeHyperopt` class.
 
-### Checklist on all tasks / possibilities in hyperopt
+The simplest way to get started is to use the following, command, which will create a new hyperopt file from a template, which will be located under `user_data/hyperopts/AwesomeHyperopt.py`.
+
+``` bash
+freqtrade new-hyperopt --hyperopt AwesomeHyperopt
+```
+
+### Hyperopt checklist
+
+Checklist on all tasks / possibilities in hyperopt
 
 Depending on the space you want to optimize, only some of the below are required:
 
@@ -54,17 +62,15 @@ Depending on the space you want to optimize, only some of the below are required
 !!! Note
     `populate_indicators` needs to create all indicators any of thee spaces may use, otherwise hyperopt will not work.
 
-Optional - can also be loaded from a strategy:
+Optional in hyperopt - can also be loaded from a strategy (recommended):
 
 * copy `populate_indicators` from your strategy - otherwise default-strategy will be used
 * copy `populate_buy_trend` from your strategy - otherwise default-strategy will be used
 * copy `populate_sell_trend` from your strategy - otherwise default-strategy will be used
 
-!!! Note
-    Assuming the optional methods are not in your hyperopt file, please use `--strategy AweSomeStrategy` which contains these methods so hyperopt can use these methods instead.
-
 !!! Note
     You always have to provide a strategy to Hyperopt, even if your custom Hyperopt class contains all methods.
+    Assuming the optional methods are not in your hyperopt file, please use `--strategy AweSomeStrategy` which contains these methods so hyperopt can use these methods instead.
 
 Rarely you may also need to override:
 
@@ -80,17 +86,20 @@ Rarely you may also need to override:
     # Have a working strategy at hand.
     freqtrade new-hyperopt --hyperopt EmptyHyperopt
 
-    freqtrade hyperopt --hyperopt EmptyHyperopt --spaces roi stoploss trailing --strategy MyWorkingStrategy --config config.json -e 100
+    freqtrade hyperopt --hyperopt EmptyHyperopt --hyperopt-loss SharpeHyperOptLossDaily --spaces roi stoploss trailing --strategy MyWorkingStrategy --config config.json -e 100
     ```
 
-### 1. Install a Custom Hyperopt File
+### Create a Custom Hyperopt File
 
-Put your hyperopt file into the directory `user_data/hyperopts`.
+Let assume you want a hyperopt file `AwesomeHyperopt.py`:  
 
-Let assume you want a hyperopt file `awesome_hyperopt.py`:  
-Copy the file `user_data/hyperopts/sample_hyperopt.py` into `user_data/hyperopts/awesome_hyperopt.py`
+``` bash
+freqtrade new-hyperopt --hyperopt AwesomeHyperopt
+```
 
-### 2. Configure your Guards and Triggers
+This command will create a new hyperopt file from a template, allowing you to get started quickly.
+
+### Configure your Guards and Triggers
 
 There are two places you need to change in your hyperopt file to add a new buy hyperopt for testing:
 
@@ -102,14 +111,16 @@ There you have two different types of indicators: 1. `guards` and 2. `triggers`.
 1. Guards are conditions like "never buy if ADX < 10", or never buy if current price is over EMA10.
 2. Triggers are ones that actually trigger buy in specific moment, like "buy when EMA5 crosses over EMA10" or "buy when close price touches lower Bollinger band".
 
-Hyperoptimization will, for each eval round, pick one trigger and possibly
-multiple guards. The constructed strategy will be something like
-"*buy exactly when close price touches lower Bollinger band, BUT only if
+!!! Hint "Guards and Triggers"
+    Technically, there is no difference between Guards and Triggers.  
+    However, this guide will make this distinction to make it clear that signals should not be "sticking".
+    Sticking signals are signals that are active for multiple candles. This can lead into buying a signal late (right before the signal disappears - which means that the chance of success is a lot lower than right at the beginning).
+
+Hyper-optimization will, for each epoch round, pick one trigger and possibly
+multiple guards. The constructed strategy will be something like "*buy exactly when close price touches lower Bollinger band, BUT only if
 ADX > 10*".
 
-If you have updated the buy strategy, i.e. changed the contents of
-`populate_buy_trend()` method, you have to update the `guards` and
-`triggers` your hyperopt must use correspondingly.
+If you have updated the buy strategy, i.e. changed the contents of `populate_buy_trend()` method, you have to update the `guards` and `triggers` your hyperopt must use correspondingly.
 
 #### Sell optimization
 
@@ -126,7 +137,7 @@ To avoid naming collisions in the search-space, please prefix all sell-spaces wi
 
 The Strategy class exposes the timeframe value as the `self.timeframe` attribute.
 The same value is available as class-attribute `HyperoptName.timeframe`.
-In the case of the linked sample-value this would be `SampleHyperOpt.timeframe`.
+In the case of the linked sample-value this would be `AwesomeHyperopt.timeframe`.
 
 ## Solving a Mystery
 
@@ -192,27 +203,25 @@ So let's write the buy strategy using these values:
         return populate_buy_trend
 ```
 
-Hyperopting will now call this `populate_buy_trend` as many times you ask it (`epochs`)
-with different value combinations. It will then use the given historical data and make
-buys based on the buy signals generated with the above function and based on the results
-it will end with telling you which parameter combination produced the best profits.
+Hyperopt will now call `populate_buy_trend()` many times (`epochs`) with different value combinations.  
+It will use the given historical data and make buys based on the buy signals generated with the above function.  
+Based on the results, hyperopt will tell you which parameter combination produced the best results (based on the configured [loss function](#loss-functions)).
 
-The above setup expects to find ADX, RSI and Bollinger Bands in the populated indicators.
-When you want to test an indicator that isn't used by the bot currently, remember to
-add it to the `populate_indicators()` method in your custom hyperopt file.
+!!! Note
+    The above setup expects to find ADX, RSI and Bollinger Bands in the populated indicators.
+    When you want to test an indicator that isn't used by the bot currently, remember to
+    add it to the `populate_indicators()` method in your strategy or hyperopt file.
 
 ## Loss-functions
 
 Each hyperparameter tuning requires a target. This is usually defined as a loss function (sometimes also called objective function), which should decrease for more desirable results, and increase for bad results.
 
-By default, Freqtrade uses a loss function, which has been with freqtrade since the beginning and optimizes mostly for short trade duration and avoiding losses.
-
-A different loss function can be specified by using the `--hyperopt-loss <Class-name>` argument.
+A loss function must be specified via the `--hyperopt-loss <Class-name>` argument (or optionally via the configuration under the `"hyperopt_loss"` key).
 This class should be in its own file within the `user_data/hyperopts/` directory.
 
 Currently, the following loss functions are builtin:
 
-* `DefaultHyperOptLoss` (default legacy Freqtrade hyperoptimization loss function)
+* `ShortTradeDurHyperOptLoss` (default legacy Freqtrade hyperoptimization loss function) - Mostly for short trade duration and avoiding losses.
 * `OnlyProfitHyperOptLoss` (which takes only amount of profit into consideration)
 * `SharpeHyperOptLoss` (optimizes Sharpe Ratio calculated on trade returns relative to standard deviation)
 * `SharpeHyperOptLossDaily` (optimizes Sharpe Ratio calculated on **daily** trade returns relative to standard deviation)
@@ -229,21 +238,20 @@ Because hyperopt tries a lot of combinations to find the best parameters it will
 We strongly recommend to use `screen` or `tmux` to prevent any connection loss.
 
 ```bash
-freqtrade hyperopt --config config.json --hyperopt <hyperoptname> -e 5000 --spaces all
+freqtrade hyperopt --config config.json --hyperopt <hyperoptname> --hyperopt-loss <hyperoptlossname> --strategy <strategyname> -e 500 --spaces all
 ```
 
 Use `<hyperoptname>` as the name of the custom hyperopt used.
 
-The `-e` option will set how many evaluations hyperopt will do. We recommend
-running at least several thousand evaluations.
+The `-e` option will set how many evaluations hyperopt will do. Since hyperopt uses Bayesian search, running too many epochs at once may not produce greater results. Experience has shown that best results are usually not improving much after 500-1000 epochs.  
+Doing multiple runs (executions) with a few 1000 epochs and different random state will most likely produce different results.
 
 The `--spaces all` option determines that all possible parameters should be optimized. Possibilities are listed below.
 
 !!! Note
-    By default, hyperopt will erase previous results and start from scratch. Continuation can be archived by using `--continue`.
-
-!!! Warning
-    When switching parameters or changing configuration options, make sure to not use the argument `--continue` so temporary results can be removed.
+    Hyperopt will store hyperopt results with the timestamp of the hyperopt start time.
+    Reading commands (`hyperopt-list`, `hyperopt-show`) can use `--hyperopt-filename <filename>` to read and display older hyperopt results.
+    You can find a list of filenames with `ls -l user_data/hyperopt_results/`.
 
 ### Execute Hyperopt with different historical data source
 
@@ -251,13 +259,13 @@ If you would like to hyperopt parameters using an alternate historical data set
 you have on-disk, use the `--datadir PATH` option. By default, hyperopt
 uses data from directory `user_data/data`.
 
-### Running Hyperopt with Smaller Testset
+### Running Hyperopt with a smaller test-set
 
-Use the `--timerange` argument to change how much of the testset you want to use.
+Use the `--timerange` argument to change how much of the test-set you want to use.
 For example, to use one month of data, pass the following parameter to the hyperopt call:
 
 ```bash
-freqtrade hyperopt --timerange 20180401-20180501
+freqtrade hyperopt --hyperopt <hyperoptname> --strategy <strategyname> --timerange 20180401-20180501
 ```
 
 ### Running Hyperopt using methods from a strategy
@@ -265,16 +273,15 @@ freqtrade hyperopt --timerange 20180401-20180501
 Hyperopt can reuse `populate_indicators`, `populate_buy_trend`, `populate_sell_trend` from your strategy, assuming these methods are **not** in your custom hyperopt file, and a strategy is provided.
 
 ```bash
-freqtrade hyperopt --strategy SampleStrategy --hyperopt SampleHyperopt
+freqtrade hyperopt --hyperopt AwesomeHyperopt --hyperopt-loss SharpeHyperOptLossDaily --strategy AwesomeStrategy
 ```
 
 ### Running Hyperopt with Smaller Search Space
 
 Use the `--spaces` option to limit the search space used by hyperopt.
-Letting Hyperopt optimize everything is a huuuuge search space. Often it
-might make more sense to start by just searching for initial buy algorithm.
-Or maybe you just want to optimize your stoploss or roi table for that awesome
-new buy strategy you have.
+Letting Hyperopt optimize everything is a huuuuge search space. 
+Often it might make more sense to start by just searching for initial buy algorithm.
+Or maybe you just want to optimize your stoploss or roi table for that awesome new buy strategy you have.
 
 Legal values are:
 
@@ -318,7 +325,7 @@ The initial state for generation of these random values (random state) is contro
 
 If you have not set this value explicitly in the command line options, Hyperopt seeds the random state with some random value for you. The random state value for each Hyperopt run is shown in the log, so you can copy and paste it into the `--random-state` command line option to repeat the set of the initial random epochs used.
 
-If you have not changed anything in the command line options, configuration, timerange, Strategy and Hyperopt classes, historical data and the Loss Function -- you should obtain same hyperoptimization results with same random state value used.
+If you have not changed anything in the command line options, configuration, timerange, Strategy and Hyperopt classes, historical data and the Loss Function -- you should obtain same hyper-optimization results with same random state value used.
 
 ## Understand the Hyperopt Result
 
@@ -371,7 +378,7 @@ By default, hyperopt prints colorized results -- epochs with positive profit are
 You can use the `--print-all` command line option if you would like to see all results in the hyperopt output, not only the best ones. When `--print-all` is used, current best results are also colorized by default -- they are printed in bold (bright) style. This can also be switched off with the `--no-color` command line option.
 
 !!! Note "Windows and color output"
-    Windows does not support color-output nativly, therefore it is automatically disabled. To have color-output for hyperopt running under windows, please consider using WSL.
+    Windows does not support color-output natively, therefore it is automatically disabled. To have color-output for hyperopt running under windows, please consider using WSL.
 
 ### Understand Hyperopt ROI results
 
@@ -419,7 +426,9 @@ These ranges should be sufficient in most cases. The minutes in the steps (ROI d
 
 If you have the `generate_roi_table()` and `roi_space()` methods in your custom hyperopt file, remove them in order to utilize these adaptive ROI tables and the ROI hyperoptimization space generated by Freqtrade by default.
 
-Override the `roi_space()` method if you need components of the ROI tables to vary in other ranges. Override the `generate_roi_table()` and `roi_space()` methods and implement your own custom approach for generation of the ROI tables during hyperoptimization if you need a different structure of the ROI tables or other amount of rows (steps). A sample for these methods can be found in [user_data/hyperopts/sample_hyperopt_advanced.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/templates/sample_hyperopt_advanced.py).
+Override the `roi_space()` method if you need components of the ROI tables to vary in other ranges. Override the `generate_roi_table()` and `roi_space()` methods and implement your own custom approach for generation of the ROI tables during hyperoptimization if you need a different structure of the ROI tables or other amount of rows (steps). 
+
+A sample for these methods can be found in [sample_hyperopt_advanced.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/templates/sample_hyperopt_advanced.py).
 
 ### Understand Hyperopt Stoploss results
 
@@ -441,7 +450,7 @@ Stoploss: -0.27996
 
 In order to use this best stoploss value found by Hyperopt in backtesting and for live trades/dry-run, copy-paste it as the value of the `stoploss` attribute of your custom strategy:
 
-```
+``` python
     # Optimal stoploss designed for the strategy
     # This attribute will be overridden if the config file contains "stoploss"
     stoploss = -0.27996
@@ -475,7 +484,7 @@ Trailing stop:
 
 In order to use these best trailing stop parameters found by Hyperopt in backtesting and for live trades/dry-run, copy-paste them as the values of the corresponding attributes of your custom strategy:
 
-```
+``` python
     # Trailing stop
     # These attributes will be overridden if the config file contains corresponding values.
     trailing_stop = True
@@ -494,10 +503,14 @@ Override the `trailing_space()` method and define the desired range in it if you
 
 ## Show details of Hyperopt results
 
-After you run Hyperopt for the desired amount of epochs, you can later list all results for analysis, select only best or profitable once, and show the details for any of the epochs previously evaluated. This can be done with the `hyperopt-list` and `hyperopt-show` subcommands. The usage of these subcommands is described in the [Utils](utils.md#list-hyperopt-results) chapter.
+After you run Hyperopt for the desired amount of epochs, you can later list all results for analysis, select only best or profitable once, and show the details for any of the epochs previously evaluated. This can be done with the `hyperopt-list` and `hyperopt-show` sub-commands. The usage of these sub-commands is described in the [Utils](utils.md#list-hyperopt-results) chapter.
 
 ## Validate backtesting results
 
 Once the optimized strategy has been implemented into your strategy, you should backtest this strategy to make sure everything is working as expected.
 
-To achieve same results (number of trades, their durations, profit, etc.) than during Hyperopt, please use same set of arguments `--dmmp`/`--disable-max-market-positions` and `--eps`/`--enable-position-stacking` for Backtesting.
+To achieve same results (number of trades, their durations, profit, etc.) than during Hyperopt, please use same configuration and parameters (timerange, timeframe, ...) used for hyperopt `--dmmp`/`--disable-max-market-positions` and `--eps`/`--enable-position-stacking` for Backtesting.
+
+Should results don't match, please double-check to make sure you transferred all conditions correctly.
+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` or `trailing_stop`).

docs/includes/pairlists.md

@@ -0,0 +1,170 @@
+## Pairlists and Pairlist Handlers
+
+Pairlist Handlers define the list of pairs (pairlist) that the bot should trade. They are configured in the `pairlists` section of the configuration settings.
+
+In your configuration, you can use Static Pairlist (defined by the [`StaticPairList`](#static-pair-list) Pairlist Handler) and Dynamic Pairlist (defined by the [`VolumePairList`](#volume-pair-list) Pairlist Handler).
+
+Additionally, [`AgeFilter`](#agefilter), [`PrecisionFilter`](#precisionfilter), [`PriceFilter`](#pricefilter), [`ShuffleFilter`](#shufflefilter) and [`SpreadFilter`](#spreadfilter) act as Pairlist Filters, removing certain pairs and/or moving their positions in the pairlist.
+
+If multiple Pairlist Handlers are used, they are chained and a combination of all Pairlist Handlers forms the resulting pairlist the bot uses for trading and backtesting. Pairlist Handlers are executed in the sequence they are configured. You should always configure either `StaticPairList` or `VolumePairList` as the starting Pairlist Handler.
+
+Inactive markets are always removed from the resulting pairlist. Explicitly blacklisted pairs (those in the `pair_blacklist` configuration setting) are also always removed from the resulting pairlist.
+
+### Available Pairlist Handlers
+
+* [`StaticPairList`](#static-pair-list) (default, if not configured differently)
+* [`VolumePairList`](#volume-pair-list)
+* [`AgeFilter`](#agefilter)
+* [`PrecisionFilter`](#precisionfilter)
+* [`PriceFilter`](#pricefilter)
+* [`ShuffleFilter`](#shufflefilter)
+* [`SpreadFilter`](#spreadfilter)
+* [`RangeStabilityFilter`](#rangestabilityfilter)
+
+!!! Tip "Testing pairlists"
+    Pairlist configurations can be quite tricky to get right. Best use the [`test-pairlist`](utils.md#test-pairlist) utility sub-command to test your configuration quickly.
+
+#### Static Pair List
+
+By default, the `StaticPairList` method is used, which uses a statically defined pair whitelist from the configuration.
+
+It uses configuration from `exchange.pair_whitelist` and `exchange.pair_blacklist`.
+
+```json
+"pairlists": [
+    {"method": "StaticPairList"}
+    ],
+```
+
+By default, only currently enabled pairs are allowed.
+To skip pair validation against active markets, set `"allow_inactive": true` within the `StaticPairList` configuration.
+This can be useful for backtesting expired pairs (like quarterly spot-markets).
+This option must be configured along with `exchange.skip_pair_validation` in the exchange configuration.
+
+#### Volume Pair List
+
+`VolumePairList` employs sorting/filtering of pairs by their trading volume. It selects `number_assets` top pairs with sorting based on the `sort_key` (which can only be `quoteVolume`).
+
+When used in the chain of Pairlist Handlers in a non-leading position (after StaticPairList and other Pairlist Filters), `VolumePairList` considers outputs of previous Pairlist Handlers, adding its sorting/selection of the pairs by the trading volume.
+
+When used on the leading position of the chain of Pairlist Handlers, it does not consider `pair_whitelist` configuration setting, but selects the top assets from all available markets (with matching stake-currency) on the exchange.
+
+The `refresh_period` setting allows to define the period (in seconds), at which the pairlist will be refreshed. Defaults to 1800s (30 minutes).
+
+`VolumePairList` is based on the ticker data from exchange, as reported by the ccxt library:
+
+* The `quoteVolume` is the amount of quote (stake) currency traded (bought or sold) in last 24 hours.
+
+```json
+"pairlists": [{
+        "method": "VolumePairList",
+        "number_assets": 20,
+        "sort_key": "quoteVolume",
+        "refresh_period": 1800
+}],
+```
+
+#### AgeFilter
+
+Removes pairs that have been listed on the exchange for less than `min_days_listed` days (defaults to `10`).
+
+When pairs are first listed on an exchange they can suffer huge price drops and volatility
+in the first few days while the pair goes through its price-discovery period. Bots can often
+be caught out buying before the pair has finished dropping in price.
+
+This filter allows freqtrade to ignore pairs until they have been listed for at least `min_days_listed` days.
+
+#### PrecisionFilter
+
+Filters low-value coins which would not allow setting stoplosses.
+
+#### PriceFilter
+
+The `PriceFilter` allows filtering of pairs by price. Currently the following price filters are supported:
+
+* `min_price`
+* `max_price`
+* `low_price_ratio`
+
+The `min_price` setting removes pairs where the price is below the specified price. This is useful if you wish to avoid trading very low-priced pairs.
+This option is disabled by default, and will only apply if set to > 0.
+
+The `max_price` setting removes pairs where the price is above the specified price. This is useful if you wish to trade only low-priced pairs.
+This option is disabled by default, and will only apply if set to > 0.
+
+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.
+
+For `PriceFiler` at least one of its `min_price`, `max_price` or `low_price_ratio` settings must be applied.
+
+Calculation example:
+
+Min price precision for SHITCOIN/BTC is 8 decimals. If its price is 0.00000011 - one price step above would be 0.00000012, which is ~9% higher than the previous price value. You may filter out this pair by using PriceFilter with `low_price_ratio` set to 0.09 (9%) or with `min_price` set to 0.00000011, correspondingly.
+
+!!! Warning "Low priced pairs"
+    Low priced pairs with high "1 pip movements" are dangerous since they are often illiquid and it may also be impossible to place the desired stoploss, which can often result in high losses since price needs to be rounded to the next tradable price - so instead of having a stoploss of -5%, you could end up with a stoploss of -9% simply due to price rounding.
+
+#### ShuffleFilter
+
+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.
+
+!!! 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.
+
+#### SpreadFilter
+
+Removes pairs that have a difference between asks and bids above the specified ratio, `max_spread_ratio` (defaults to `0.005`).
+
+Example:
+
+If `DOGE/BTC` maximum bid is 0.00000026 and minimum ask is 0.00000027, the ratio is calculated as: `1 - bid/ask ~= 0.037` which is `> 0.005` and this pair will be filtered out.
+
+#### RangeStabilityFilter
+
+Removes pairs where the difference between lowest low and highest high over `lookback_days` days is below `min_rate_of_change`. Since this is a filter that requires additional data, the results are cached for `refresh_period`.
+
+In the below example:
+If the trading range over the last 10 days is <1%, remove the pair from the whitelist.
+
+```json
+"pairlists": [
+    {
+        "method": "RangeStabilityFilter",
+        "lookback_days": 10,
+        "min_rate_of_change": 0.01,
+        "refresh_period": 1440
+    }
+]
+```
+
+!!! Tip
+    This Filter can be used to automatically remove stable coin pairs, which have a very low trading range, and are therefore extremely difficult to trade with profit.
+
+### Full example of Pairlist Handlers
+
+The below example blacklists `BNB/BTC`, uses `VolumePairList` with `20` assets, sorting pairs by `quoteVolume` and applies both [`PrecisionFilter`](#precisionfilter) and [`PriceFilter`](#price-filter), filtering all assets where 1 price unit is > 1%. Then the `SpreadFilter` is applied and pairs are finally shuffled with the random seed set to some predefined value.
+
+```json
+"exchange": {
+    "pair_whitelist": [],
+    "pair_blacklist": ["BNB/BTC"]
+},
+"pairlists": [
+    {
+        "method": "VolumePairList",
+        "number_assets": 20,
+        "sort_key": "quoteVolume",
+    },
+    {"method": "AgeFilter", "min_days_listed": 10},
+    {"method": "PrecisionFilter"},
+    {"method": "PriceFilter", "low_price_ratio": 0.01},
+    {"method": "SpreadFilter", "max_spread_ratio": 0.005},
+    {
+        "method": "RangeStabilityFilter",
+        "lookback_days": 10,
+        "min_rate_of_change": 0.01,
+        "refresh_period": 1440
+    },
+    {"method": "ShuffleFilter", "seed": 42}
+    ],
+```

docs/index.md

@@ -8,7 +8,7 @@
 <!-- Place this tag where you want the button to render. -->
 <a class="github-button" href="https://github.com/freqtrade/freqtrade/fork" data-icon="octicon-repo-forked" data-size="large" aria-label="Fork freqtrade/freqtrade on GitHub">Fork</a>
 <!-- Place this tag where you want the button to render. -->
-<a class="github-button" href="https://github.com/freqtrade/freqtrade/archive/master.zip" data-icon="octicon-cloud-download" data-size="large" aria-label="Download freqtrade/freqtrade on GitHub">Download</a>
+<a class="github-button" href="https://github.com/freqtrade/freqtrade/archive/stable.zip" data-icon="octicon-cloud-download" data-size="large" aria-label="Download freqtrade/freqtrade on GitHub">Download</a>
 <!-- Place this tag where you want the button to render. -->
 <a class="github-button" href="https://github.com/freqtrade" data-size="large" aria-label="Follow @freqtrade on GitHub">Follow @freqtrade</a>
 
@@ -37,13 +37,9 @@ Freqtrade is a crypto-currency algorithmic trading software developed in python
 
 ## Requirements
 
-### 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.
-
 ### Hardware requirements
 
-To run this bot we recommend you a cloud instance with a minimum of:
+To run this bot we recommend you a linux cloud instance with a minimum of:
 
 - 2GB RAM
 - 1GB disk space
@@ -63,11 +59,14 @@ Alternatively
 
 ## Support
 
-### Help / Slack
-For any questions not covered by the documentation or for further information about the bot, we encourage you to join our passionate  Slack community.
+### Help / Discord / Slack
 
-Click [here](https://join.slack.com/t/highfrequencybot/shared_invite/enQtNjU5ODcwNjI1MDU3LTU1MTgxMjkzNmYxNWE1MDEzYzQ3YmU4N2MwZjUyNjJjODRkMDVkNjg4YTAyZGYzYzlhOTZiMTE4ZjQ4YzM0OGE) to join the Freqtrade Slack channel.
+For any questions not covered by the documentation or for further information about the bot, or to simply engage with like-minded individuals, we encourage you to join our slack channel.
+
+Please check out our [discord server](https://discord.gg/MA9v74M).
+
+You can also join our [Slack channel](https://join.slack.com/t/highfrequencybot/shared_invite/zt-jaut7r4m-Y17k4x5mcQES9a9swKuxbg).
 
 ## Ready to try?
 
-Begin by reading our installation guide [for docker](docker.md), or for [installation without docker](installation.md).
+Begin by reading our installation guide [for docker](docker_quickstart.md) (recommended), or for [installation without docker](installation.md).

docs/installation.md

@@ -18,6 +18,9 @@ Click each one for install guide:
 
  We also recommend a [Telegram bot](telegram-usage.md#setup-your-telegram-bot), which is optional but recommended.
 
+!!! 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.
+
 ## Quick start
 
 Freqtrade provides the Linux/MacOS Easy Installation script to install all dependencies and help you configure the bot.
@@ -28,7 +31,7 @@ Freqtrade provides the Linux/MacOS Easy Installation script to install all depen
 The easiest way to install and run Freqtrade is to clone the bot Github repository and then run the Easy Installation script, if it's available for your platform.
 
 !!! Note "Version considerations"
-    When cloning the repository the default working branch has the name `develop`. This branch contains all last features (can be considered as relatively stable, thanks to automated tests). The `master` branch contains the code of the last release (done usually once per month on an approximately one week old snapshot of the `develop` branch to prevent packaging bugs, so potentially it's more stable).
+    When cloning the repository the default working branch has the name `develop`. This branch contains all last features (can be considered as relatively stable, thanks to automated tests). The `stable` branch contains the code of the last release (done usually once per month on an approximately one week old snapshot of the `develop` branch to prevent packaging bugs, so potentially it's more stable).
 
 !!! Note
     Python3.6 or higher and the corresponding `pip` are assumed to be available. The install-script will warn you and stop if that's not the case. `git` is also needed to clone the Freqtrade repository.
@@ -38,11 +41,11 @@ This can be achieved with the following commands:
 ```bash
 git clone https://github.com/freqtrade/freqtrade.git
 cd freqtrade
-git checkout master  # Optional, see (1)
+# git checkout stable  # Optional, see (1)
 ./setup.sh --install
 ```
 
-(1) This command switches the cloned repository to the use of the `master` branch. It's not needed if you wish to stay on the `develop` branch. You may later switch between branches at any time with the `git checkout master`/`git checkout develop` commands.
+(1) This command switches the cloned repository to the use of the `stable` branch. It's not needed if you wish to stay on the `develop` branch. You may later switch between branches at any time with the `git checkout stable`/`git checkout develop` commands.
 
 ## Easy Installation Script (Linux/MacOS)
 
@@ -53,7 +56,7 @@ $ ./setup.sh
 usage:
 	-i,--install    Install freqtrade from scratch
 	-u,--update     Command git pull to update.
-	-r,--reset      Hard reset your develop/master branch.
+	-r,--reset      Hard reset your develop/stable branch.
 	-c,--config     Easy config generator (Will override your existing file).
 ```
 
@@ -73,12 +76,16 @@ This option will pull the last version of your current branch and update your vi
 
 ** --reset **
 
-This option will hard reset your branch (only if you are on either `master` or `develop`) and recreate your virtualenv.
+This option will hard reset your branch (only if you are on either `stable` or `develop`) and recreate your virtualenv.
 
 ** --config **
 
 DEPRECATED - use `freqtrade new-config -c config.json` instead.
 
+### Activate your virtual environment
+
+Each time you open a new terminal, you must run `source .env/bin/activate`.
+
 ------
 
 ## Custom Installation
@@ -89,36 +96,34 @@ OS Specific steps are listed first, the [Common](#common) section below is neces
 !!! Note
     Python3.6 or higher and the corresponding pip are assumed to be available.
 
-### Linux - Ubuntu 16.04
+=== "Ubuntu 16.04"
+    #### Install necessary dependencies
 
-#### Install necessary dependencies
+    ```bash
+    sudo apt-get update
+    sudo apt-get install build-essential git
+    ```
 
-```bash
-sudo apt-get update
-sudo apt-get install build-essential git
-```
+=== "RaspberryPi/Raspbian"
+    The following assumes the latest [Raspbian Buster lite image](https://www.raspberrypi.org/downloads/raspbian/) from at least September 2019.
+    This image comes with python3.7 preinstalled, making it easy to get freqtrade up and running.
 
-### Raspberry Pi / Raspbian
+    Tested using a Raspberry Pi 3 with the Raspbian Buster lite image, all updates applied.
 
-The following assumes the latest [Raspbian Buster lite image](https://www.raspberrypi.org/downloads/raspbian/) from at least September 2019.
-This image comes with python3.7 preinstalled, making it easy to get freqtrade up and running.
+    ``` bash
+    sudo apt-get install python3-venv libatlas-base-dev
+    git clone https://github.com/freqtrade/freqtrade.git
+    cd freqtrade
 
-Tested using a Raspberry Pi 3 with the Raspbian Buster lite image, all updates applied.
+    bash setup.sh -i
+    ```
 
-``` bash
-sudo apt-get install python3-venv libatlas-base-dev
-git clone https://github.com/freqtrade/freqtrade.git
-cd freqtrade
+    !!! Note "Installation duration"
+        Depending on your internet speed and the Raspberry Pi version, installation can take multiple hours to complete.
 
-bash setup.sh -i
-```
-
-!!! Note "Installation duration"
-    Depending on your internet speed and the Raspberry Pi version, installation can take multiple hours to complete.
-
-!!! Note
-    The above does not install hyperopt dependencies. To install these, please use `python3 -m pip install -e .[hyperopt]`.
-    We do not advise to run hyperopt on a Raspberry Pi, since this is a very resource-heavy operation, which should be done on powerful machine.
+    !!! Note
+        The above does not install hyperopt dependencies. To install these, please use `python3 -m pip install -e .[hyperopt]`.
+        We do not advise to run hyperopt on a Raspberry Pi, since this is a very resource-heavy operation, which should be done on powerful machine.
 
 ### Common
 
@@ -169,12 +174,7 @@ Clone the git repository:
 ```bash
 git clone https://github.com/freqtrade/freqtrade.git
 cd freqtrade
-```
-
-Optionally checkout the master branch to get the latest stable release:
-
-```bash
-git checkout master
+git checkout stable
 ```
 
 #### 4. Install python dependencies
@@ -212,72 +212,18 @@ On Linux, as an optional post-installation task, you may wish to setup the bot t
 
 ------
 
-## Using Conda
+### Anaconda
 
 Freqtrade can also be installed using Anaconda (or Miniconda).
 
+!!! Note
+    This requires the [ta-lib](#1-install-ta-lib) C-library to be installed first. See below.
+
 ``` bash
 conda env create -f environment.yml
 ```
 
-!!! Note
-    This requires the [ta-lib](#1-install-ta-lib) C-library to be installed first.
-
-## Windows
-
-We recommend that Windows users use [Docker](docker.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.
-If that is not available on your system, feel free to try the instructions below, which led to success for some.
-
-### Install freqtrade manually
-
-!!! Note
-    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.
-
-!!! Hint
-    Using the [Anaconda Distribution](https://www.anaconda.com/distribution/) under Windows can greatly help with installation problems. Check out the [Conda section](#using-conda) in this document for more information.
-
-#### Clone the git repository
-
-```bash
-git clone https://github.com/freqtrade/freqtrade.git
-```
-
-#### Install ta-lib
-
-Install ta-lib according to the [ta-lib documentation](https://github.com/mrjbq7/ta-lib#windows).
-
-As compiling from source on windows has heavy dependencies (requires a partial visual studio installation), there is also a repository of unofficial precompiled windows Wheels [here](https://www.lfd.uci.edu/~gohlke/pythonlibs/#ta-lib), which needs to be downloaded and installed using `pip install TA_Lib‑0.4.18‑cp38‑cp38‑win_amd64.whl` (make sure to use the version matching your python version)
-
-```cmd
->cd \path\freqtrade-develop
->python -m venv .env
->.env\Scripts\activate.bat
-REM optionally install ta-lib from wheel
-REM >pip install TA_Lib‑0.4.18‑cp38‑cp38‑win_amd64.whl
->pip install -r requirements.txt
->pip install -e .
->freqtrade
-```
-
-> Thanks [Owdr](https://github.com/Owdr) for the commands. Source: [Issue #222](https://github.com/freqtrade/freqtrade/issues/222)
-
-#### Error during installation under Windows
-
-``` bash
-error: Microsoft Visual C++ 14.0 is required. Get it with "Microsoft Visual C++ Build Tools": http://landinghub.visualstudio.com/visual-cpp-build-tools
-```
-
-Unfortunately, many packages requiring compilation don't provide a pre-build wheel. It is therefore mandatory to have a C/C++ compiler installed and available for your python environment to use.
-
-The easiest way is to download install Microsoft Visual Studio Community [here](https://visualstudio.microsoft.com/downloads/) and make sure to install "Common Tools for Visual C++" to enable building c code on Windows. Unfortunately, this is a heavy download / dependency (~4Gb) so you might want to consider WSL or [docker](docker.md) first.
-
----
-
-Now you have an environment ready, the next step is
-[Bot Configuration](configuration.md).
-
+-----
 ## Troubleshooting 
 
 ### MacOS installation error
@@ -291,4 +237,9 @@ For MacOS 10.14, this can be accomplished with the below command.
 open /Library/Developer/CommandLineTools/Packages/macOS_SDK_headers_for_macOS_10.14.pkg
 ```
 
-If this file is inexistant, then you're probably on a different version of MacOS, so you may need to consult the internet for specific resolution details.
+If this file is inexistent, then you're probably on a different version of MacOS, so you may need to consult the internet for specific resolution details.
+
+-----
+
+Now you have an environment ready, the next step is
+[Bot Configuration](configuration.md).

docs/javascripts/config.js

@@ -0,0 +1,12 @@
+window.MathJax = {
+  tex: {
+    inlineMath: [["\\(", "\\)"]],
+    displayMath: [["\\[", "\\]"]],
+    processEscapes: true,
+    processEnvironments: true
+  },
+  options: {
+    ignoreHtmlClass: ".*|",
+    processHtmlClass: "arithmatex"
+  }
+};

docs/requirements-docs.txt

@@ -1,2 +1,3 @@
-mkdocs-material==5.5.8
+mkdocs-material==6.1.6
 mdx_truly_sane_lists==1.2
+pymdown-extensions==8.0.1

docs/rest-api.md

@@ -104,32 +104,42 @@ By default, the script assumes `127.0.0.1` (localhost) and port `8080` to be use
 python3 scripts/rest_client.py --config rest_config.json <command> [optional parameters]
 ```
 
-## Available commands
+## Available endpoints
 
 |  Command | Description |
 |----------|-------------|
 | `ping` | Simple command testing the API Readiness - requires no authentication.
-| `start` | Starts the trader
-| `stop` | Stops the trader
+| `start` | Starts the trader.
+| `stop` | Stops the trader.
 | `stopbuy` | Stops the trader from opening new trades. Gracefully closes open trades according to their rules.
-| `reload_config` | Reloads the configuration file
+| `reload_config` | Reloads the configuration file.
 | `trades` | List last trades.
 | `delete_trade <trade_id>` | Remove trade from the database. Tries to close open orders. Requires manual handling of this trade on the exchange.
-| `show_config` | Shows part of the current configuration with relevant settings to operation
-| `logs` | Shows last log messages
-| `status` | Lists all open trades
-| `count` | Displays number of trades used and available
-| `profit` | Display a summary of your profit/loss from close trades and some stats about your performance
+| `show_config` | Shows part of the current configuration with relevant settings to operation.
+| `logs` | Shows last log messages.
+| `status` | Lists all open trades.
+| `count` | Displays number of trades used and available.
+| `locks` | Displays currently locked pairs.
+| `profit` | Display a summary of your profit/loss from close trades and some stats about your performance.
 | `forcesell <trade_id>` | Instantly sells the given trade  (Ignoring `minimum_roi`).
 | `forcesell all` | Instantly sells all open trades (Ignoring `minimum_roi`).
 | `forcebuy <pair> [rate]` | Instantly buys the given pair. Rate is optional. (`forcebuy_enable` must be set to True)
-| `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)
-| `whitelist` | Show the current whitelist
+| `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).
+| `whitelist` | Show the current whitelist.
 | `blacklist [pair]` | Show the current blacklist, or adds a pair to the blacklist.
 | `edge` | Show validated pairs by Edge if it is enabled.
-| `version` | Show version
+| `pair_candles` | Returns dataframe for a pair / timeframe combination while the bot is running. **Alpha**
+| `pair_history` | Returns an analyzed dataframe for a given timerange, analyzed by a given strategy. **Alpha**
+| `plot_config` | Get plot config from the strategy (or nothing if not configured). **Alpha**
+| `strategies` | List strategies in strategy directory. **Alpha**
+| `strategy <strategy>` | Get specific Strategy content. **Alpha**
+| `available_pairs` | List available backtest data. **Alpha**
+| `version` | Show version.
+
+!!! Warning "Alpha status"
+    Endpoints labeled with *Alpha status* above may change at any time without notice.
 
 Possible commands can be listed from the rest-client script using the `help` command.
 
@@ -140,6 +150,12 @@ python3 scripts/rest_client.py help
 ``` output
 Possible commands:
 
+available_pairs
+	Return available pair (backtest data) based on timeframe / stake_currency selection
+
+        :param timeframe: Only pairs with this timeframe available.
+        :param stake_currency: Only pairs that include this timeframe
+
 balance
 	Get the account balance.
 
@@ -179,9 +195,27 @@ logs
 
         :param limit: Limits log messages to the last <limit> logs. No limit to get all the trades.
 
+pair_candles
+	Return live dataframe for <pair><timeframe>.
+
+        :param pair: Pair to get data for
+        :param timeframe: Only pairs with this timeframe available.
+        :param limit: Limit result to the last n candles.
+
+pair_history
+	Return historic, analyzed dataframe
+
+        :param pair: Pair to get data for
+        :param timeframe: Only pairs with this timeframe available.
+        :param strategy: Strategy to analyze and get values for
+        :param timerange: Timerange to get data for (same format than --timerange endpoints)
+
 performance
 	Return the performance of the different coins.
 
+plot_config
+	Return plot configuration if the strategy defines one.
+
 profit
 	Return the profit summary.
 
@@ -204,6 +238,14 @@ stop
 stopbuy
 	Stop buying (but handle sells gracefully). Use `reload_config` to reset.
 
+strategies
+	Lists available strategies
+
+strategy
+	Get strategy details
+
+        :param strategy: Strategy class name
+
 trades
 	Return trades history.
 
@@ -215,7 +257,6 @@ version
 whitelist
 	Show the current whitelist.
 
-
 ```
 
 ## Advanced API usage using JWT tokens

docs/sql_cheatsheet.md

@@ -43,52 +43,6 @@ sqlite3
 .schema <table_name>
 ```
 
-### Trade table structure
-
-```sql
-CREATE TABLE trades
-    id INTEGER NOT NULL,
-    exchange VARCHAR NOT NULL,
-    pair VARCHAR NOT NULL,
-    is_open BOOLEAN NOT NULL,
-    fee_open FLOAT NOT NULL,
-    fee_open_cost FLOAT,
-    fee_open_currency VARCHAR,
-    fee_close FLOAT NOT NULL,
-    fee_close_cost FLOAT,
-    fee_close_currency VARCHAR,
-    open_rate FLOAT,
-    open_rate_requested FLOAT,
-    open_trade_price FLOAT,
-    close_rate FLOAT,
-    close_rate_requested FLOAT,
-    close_profit FLOAT,
-    close_profit_abs FLOAT,
-    stake_amount FLOAT NOT NULL,
-    amount FLOAT,
-    open_date DATETIME NOT NULL,
-    close_date DATETIME,
-    open_order_id VARCHAR,
-    stop_loss FLOAT,
-    stop_loss_pct FLOAT,
-    initial_stop_loss FLOAT,
-    initial_stop_loss_pct FLOAT,
-    stoploss_order_id VARCHAR,
-    stoploss_last_update DATETIME,
-    max_rate FLOAT,
-    min_rate FLOAT,
-    sell_reason VARCHAR,
-    strategy VARCHAR,
-    timeframe INTEGER,
-    PRIMARY KEY (id),
-    CHECK (is_open IN (0, 1))
-);
-CREATE INDEX ix_trades_stoploss_order_id ON trades (stoploss_order_id);
-CREATE INDEX ix_trades_pair ON trades (pair);
-CREATE INDEX ix_trades_is_open ON trades (is_open);
-
-```
-
 ## Get all trades in the table
 
 ```sql
@@ -98,11 +52,11 @@ SELECT * FROM trades;
 ## Fix trade still open after a manual sell on the exchange
 
 !!! Warning
-  	Manually selling a pair on the exchange will not be detected by the bot and it will try to sell anyway. Whenever possible, forcesell <tradeid> should be used to accomplish the same thing.  
-	It is strongly advised to backup your database file before making any manual changes.
+    Manually selling a pair on the exchange will not be detected by the bot and it will try to sell anyway. Whenever possible, forcesell <tradeid> should be used to accomplish the same thing.  
+    It is strongly advised to backup your database file before making any manual changes.
 
 !!! Note
-  	This should not be necessary after /forcesell, as forcesell orders are closed automatically by the bot on the next iteration.
+    This should not be necessary after /forcesell, as forcesell orders are closed automatically by the bot on the next iteration.
 
 ```sql
 UPDATE trades
@@ -128,23 +82,12 @@ SET is_open=0,
 WHERE id=31;
 ```
 
-## Manually insert a new trade
-
-```sql
-INSERT INTO trades (exchange, pair, is_open, fee_open, fee_close, open_rate, stake_amount, amount, open_date)
-VALUES ('binance', 'ETH/BTC', 1, 0.0025, 0.0025, <open_rate>, <stake_amount>, <amount>, '<datetime>')
-```
-
-### Insert trade example
-
-```sql
-INSERT INTO trades (exchange, pair, is_open, fee_open, fee_close, open_rate, stake_amount, amount, open_date)
-VALUES ('binance', 'ETH/BTC', 1, 0.0025, 0.0025, 0.00258580, 0.002, 0.7715262081, '2020-06-28 12:44:24.000000')
-```
-
 ## Remove trade from the database
 
-Maybe you'd like to remove a trade from the database, because something went wrong.
+!!! Tip "Use RPC Methods to delete trades"
+    Consider using `/delete <tradeid>` via telegram or rest API. That's the recommended way to deleting trades.
+
+If you'd still like to remove a trade from the database directly, you can use the below query.
 
 ```sql
 DELETE FROM trades WHERE id = <tradeid>;

docs/stoploss.md

@@ -23,11 +23,12 @@ These modes can be configured with these values:
 ```
 
 !!! Note
-    Stoploss on exchange is only supported for Binance (stop-loss-limit), Kraken (stop-loss-market) and FTX (stop limit and stop-market) as of now.  
-    <ins>Do not set too low stoploss value if using stop loss on exchange!</ins>  
-    If set to low/tight then you have greater risk of missing fill on the order and stoploss will not work
+    Stoploss on exchange is only supported for Binance (stop-loss-limit), Kraken (stop-loss-market, stop-loss-limit) and FTX (stop limit and stop-market) as of now.  
+    <ins>Do not set too low/tight stoploss value if using stop loss on exchange!</ins>  
+    If set to low/tight then you have greater risk of missing fill on the order and stoploss will not work.
 
 ### stoploss_on_exchange and stoploss_on_exchange_limit_ratio
+
 Enable or Disable stop loss on exchange.
 If the stoploss is *on exchange* it means a stoploss limit order is placed on the exchange immediately after buy order happens successfully. This will protect you against sudden crashes in market as the order will be in the queue immediately and if market goes down then the order has more chance of being fulfilled.
 
@@ -35,18 +36,23 @@ If `stoploss_on_exchange` uses limit orders, the exchange needs 2 prices, the st
 `stoploss` defines the stop-price where the limit order is placed - and limit should be slightly below this.  
 If an exchange supports both limit and market stoploss orders, then the value of `stoploss` will be used to determine the stoploss type.  
 
-Calculation example: we bought the asset at 100$.  
-Stop-price is 95$, then limit would be `95 * 0.99 = 94.05$` - so the limit order fill can happen between 95$ and 94.05$.  
+Calculation example: we bought the asset at 100\$.  
+Stop-price is 95\$, then limit would be `95 * 0.99 = 94.05$` - so the limit order fill can happen between 95$ and 94.05$.  
 
 For example, assuming the stoploss is on exchange, and trailing stoploss is enabled, and the market is going up, then the bot automatically cancels the previous stoploss order and puts a new one with a stop value higher than the previous stoploss order.
 
+!!! Note
+    If `stoploss_on_exchange` is enabled and the stoploss is cancelled manually on the exchange, then the bot will create a new stoploss order.
+
 ### stoploss_on_exchange_interval
+
 In case of stoploss on exchange there is another parameter called `stoploss_on_exchange_interval`. This configures the interval in seconds at which the bot will check the stoploss and update it if necessary.  
 The bot cannot do these every 5 seconds (at each iteration), otherwise it would get banned by the exchange.
 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.
 
 ### emergencysell
+
 `emergencysell` is an optional value, which defaults to `market` and is used when creating stop loss on exchange orders fails.
 The below is the default which is used if not changed in strategy or configuration file.
 
@@ -84,6 +90,7 @@ Example of stop loss:
 ```
 
 For example, simplified math:
+
 * the bot buys an asset at a price of 100$
 * the stop loss is defined at -10%
 * the stop loss would get triggered once the asset drops below 90$
@@ -107,7 +114,7 @@ For example, simplified math:
 * the stop loss would get triggered once the asset drops below 90$
 * assuming the asset now increases to 102$
 * the stop loss will now be -10% of 102$ = 91.8$
-* now the asset drops in value to 101$, the stop loss will still be 91.8$ and would trigger at 91.8$.
+* now the asset drops in value to 101\$, the stop loss will still be 91.8$ and would trigger at 91.8$.
 
 In summary: The stoploss will be adjusted to be always be -10% of the highest observed price.
 
@@ -133,8 +140,8 @@ For example, simplified math:
 * the stop loss is defined at -10%
 * the stop loss would get triggered once the asset drops below 90$
 * assuming the asset now increases to 102$
-* the stop loss will now be -2% of 102$ = 99.96$ (99.96$ stop loss will be locked in and will follow asset price increasements with -2%)
-* now the asset drops in value to 101$, the stop loss will still be 99.96$ and would trigger at 99.96$
+* the stop loss will now be -2% of 102$ = 99.96$ (99.96$ stop loss will be locked in and will follow asset price increments with -2%)
+* now the asset drops in value to 101\$, the stop loss will still be 99.96$ and would trigger at 99.96$
 
 The 0.02 would translate to a -2% stop loss.
 Before this, `stoploss` is used for the trailing stoploss.
@@ -151,7 +158,7 @@ This option can be used with or without `trailing_stop_positive`, but uses `trai
     trailing_only_offset_is_reached = True
 ```
 
-Configuration (offset is buyprice + 3%):
+Configuration (offset is buy-price + 3%):
 
 ``` python
     stoploss = -0.10
@@ -169,7 +176,7 @@ For example, simplified math:
 * stoploss will remain at 90$ unless asset increases to or above our configured offset
 * assuming the asset now increases to 103$ (where we have the offset configured)
 * the stop loss will now be -2% of 103$ = 100.94$
-* now the asset drops in value to 101$, the stop loss will still be 100.94$ and would trigger at 100.94$
+* now the asset drops in value to 101\$, the stop loss will still be 100.94$ and would trigger at 100.94$
 
 !!! Tip
     Make sure to have this value (`trailing_stop_positive_offset`) lower than minimal ROI, otherwise minimal ROI will apply first and sell the trade.

docs/strategy-customization.md

@@ -312,12 +312,17 @@ The name of the variable can be chosen at will, but should be prefixed with `cus
 class Awesomestrategy(IStrategy):
     # Create custom dictionary
     cust_info = {}
+
     def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
         # Check if the entry already exists
+        if not metadata["pair"] in self._cust_info:
+            # Create empty entry for this pair
+            self._cust_info[metadata["pair"]] = {}
+
         if "crosstime" in self.cust_info[metadata["pair"]:
-            self.cust_info[metadata["pair"]["crosstime"] += 1
+            self.cust_info[metadata["pair"]]["crosstime"] += 1
         else:
-            self.cust_info[metadata["pair"]["crosstime"] = 1
+            self.cust_info[metadata["pair"]]["crosstime"] = 1
 ```
 
 !!! Warning
@@ -483,6 +488,9 @@ if self.dp:
 ### Complete Data-provider sample
 
 ```python
+from freqtrade.strategy import IStrategy, merge_informative_pair
+from pandas import DataFrame
+
 class SampleStrategy(IStrategy):
     # strategy init stuff...
 
@@ -513,17 +521,12 @@ class SampleStrategy(IStrategy):
         # Get the 14 day rsi
         informative['rsi'] = ta.RSI(informative, timeperiod=14)
 
-        # Rename columns to be unique
-        informative.columns = [f"{col}_{inf_tf}" for col in informative.columns]
-        # Assuming inf_tf = '1d' - then the columns will now be:
-        # date_1d, open_1d, high_1d, low_1d, close_1d, rsi_1d
-
-        # Combine the 2 dataframes
-        # all indicators on the informative sample MUST be calculated before this point
-        dataframe = pd.merge(dataframe, informative, left_on='date', right_on=f'date_{inf_tf}', how='left')
-        # FFill to have the 1d value available in every row throughout the day.
-        # Without this, comparisons would only work once per day.
-        dataframe = dataframe.ffill()
+        # Use the helper function merge_informative_pair to safely merge the pair
+        # Automatically renames the columns and merges a shorter timeframe dataframe and a longer timeframe informative pair
+        # use ffill to have the 1d value available in every row throughout the day.
+        # Without this, comparisons between columns of the original and the informative pair would only work once per day.
+        # Full documentation of this method, see below
+        dataframe = merge_informative_pair(dataframe, informative, self.timeframe, inf_tf, ffill=True)
 
         # Calculate rsi of the original dataframe (5m timeframe)
         dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
@@ -547,6 +550,69 @@ class SampleStrategy(IStrategy):
 
 ***
 
+## Helper functions
+
+### *merge_informative_pair()*
+
+This method helps you merge an informative pair to a regular dataframe without lookahead bias.
+It's there to help you merge the dataframe in a safe and consistent way.
+
+Options:
+
+- Rename the columns for you to create unique columns
+- Merge the dataframe without lookahead bias
+- Forward-fill (optional)
+
+All columns of the informative dataframe will be available on the returning dataframe in a renamed fashion:
+
+!!! Example "Column renaming"
+    Assuming `inf_tf = '1d'` the resulting columns will be:
+
+    ``` python
+    'date', 'open', 'high', 'low', 'close', 'rsi'                     # from the original dataframe
+    'date_1d', 'open_1d', 'high_1d', 'low_1d', 'close_1d', 'rsi_1d'   # from the informative dataframe
+    ```
+
+??? Example "Column renaming - 1h"
+    Assuming `inf_tf = '1h'` the resulting columns will be:
+
+    ``` python
+    'date', 'open', 'high', 'low', 'close', 'rsi'                     # from the original dataframe
+    'date_1h', 'open_1h', 'high_1h', 'low_1h', 'close_1h', 'rsi_1h'   # from the informative dataframe 
+    ```
+
+??? Example "Custom implementation"
+    A custom implementation for this is possible, and can be done as follows:
+
+    ``` python
+
+    # Shift date by 1 candle
+    # This is necessary since the data is always the "open date"
+    # and a 15m candle starting at 12:15 should not know the close of the 1h candle from 12:00 to 13:00
+    minutes = timeframe_to_minutes(inf_tf)
+    # Only do this if the timeframes are different:
+    informative['date_merge'] = informative["date"] + pd.to_timedelta(minutes, 'm')
+
+    # Rename columns to be unique
+    informative.columns = [f"{col}_{inf_tf}" for col in informative.columns]
+    # Assuming inf_tf = '1d' - then the columns will now be:
+    # date_1d, open_1d, high_1d, low_1d, close_1d, rsi_1d
+
+    # Combine the 2 dataframes
+    # all indicators on the informative sample MUST be calculated before this point
+    dataframe = pd.merge(dataframe, informative, left_on='date', right_on=f'date_merge_{inf_tf}', how='left')
+    # FFill to have the 1d value available in every row throughout the day.
+    # Without this, comparisons would only work once per day.
+    dataframe = dataframe.ffill()
+
+    ```
+
+!!! Warning "Informative timeframe < timeframe"
+    Using informative timeframes smaller than the dataframe timeframe is not recommended with this method, as it will not use any of the additional information this would provide.
+    To use the more detailed information properly, more advanced methods should be applied (which are out of scope for freqtrade documentation, as it'll depend on the respective need).
+
+***
+
 ## Additional data (Wallets)
 
 The strategy provides access to the `Wallets` object. This contains the current balances on the exchange.
@@ -627,18 +693,18 @@ Locked pairs will show the message `Pair <pair> is currently locked.`.
 
 Sometimes it may be desired to lock a pair after certain events happen (e.g. multiple losing trades in a row).
 
-Freqtrade has an easy method to do this from within the strategy, by calling `self.lock_pair(pair, until)`.
-`until` must be a datetime object in the future, after which trading will be reenabled for that pair.
+Freqtrade has an easy method to do this from within the strategy, by calling `self.lock_pair(pair, until, [reason])`.
+`until` must be a datetime object in the future, after which trading will be re-enabled for that pair, while `reason` is an optional string detailing why the pair was locked.
 
 Locks can also be lifted manually, by calling `self.unlock_pair(pair)`.
 
 To verify if a pair is currently locked, use `self.is_pair_locked(pair)`.
 
 !!! Note
-    Locked pairs are not persisted, so a restart of the bot, or calling `/reload_config` will reset locked pairs.
+    Locked pairs will always be rounded up to the next candle. So assuming a `5m` timeframe, a lock with `until` set to 10:18 will lock the pair until the candle from 10:15-10:20 will be finished.
 
 !!! Warning
-    Locking pairs is not functioning during backtesting.
+    Locking pairs is not available during backtesting.
 
 #### Pair locking example
 
@@ -704,8 +770,6 @@ To get additional Ideas for strategies, head over to our [strategy repository](h
 Feel free to use any of them as inspiration for your own strategies.
 We're happy to accept Pull Requests containing new Strategies to that repo.
 
-We also got a *strategy-sharing* channel in our [Slack community](https://join.slack.com/t/highfrequencybot/shared_invite/enQtNjU5ODcwNjI1MDU3LTU1MTgxMjkzNmYxNWE1MDEzYzQ3YmU4N2MwZjUyNjJjODRkMDVkNjg4YTAyZGYzYzlhOTZiMTE4ZjQ4YzM0OGE) which is a great place to get and/or share ideas.
-
 ## Next step
 
 Now you have a perfect strategy you probably want to backtest it.

docs/telegram-usage.md

@@ -35,12 +35,58 @@ Copy the API Token (`22222222:APITOKEN` in the above example) and keep use it fo
 
 Don't forget to start the conversation with your bot, by clicking `/START` button
 
-### 2. Get your user id
+### 2. Telegram user_id
+
+#### Get your user id
 
 Talk to the [userinfobot](https://telegram.me/userinfobot)
 
 Get your "Id", you will use it for the config parameter `chat_id`.
 
+#### Use Group id
+
+You can use bots in telegram groups by just adding them to the group. You can find the group id by first adding a [RawDataBot](https://telegram.me/rawdatabot) to your group. The Group id is shown as id in the `"chat"` section, which the RawDataBot will send to you:
+
+``` json
+"chat":{
+   "id":-1001332619709
+}
+```
+
+For the Freqtrade configuration, you can then use the the full value (including `-` if it's there) as string:
+
+```json
+   "chat_id": "-1001332619709"
+```
+
+## Control telegram noise
+
+Freqtrade provides means to control the verbosity of your telegram bot.
+Each setting has the following possible values:
+
+* `on` - Messages will be sent, and user will be notified.
+* `silent` - Message will be sent, Notification will be without sound / vibration.
+* `off` - Skip sending a message-type all together.
+
+Example configuration showing the different settings:
+
+``` json
+"telegram": {
+      "enabled": true,
+      "token": "your_telegram_token",
+      "chat_id": "your_telegram_chat_id",
+      "notification_settings": {
+         "status": "silent",
+         "warning": "on",
+         "startup": "off",
+         "buy": "silent",
+         "sell": "on",
+         "buy_cancel": "silent",
+         "sell_cancel": "on"
+      }
+   },
+```
+
 ## Telegram commands
 
 Per default, the Telegram bot shows predefined commands. Some commands

docs/utils.md

@@ -423,7 +423,7 @@ freqtrade test-pairlist --config config.json --quote USDT BTC
 
 ## List Hyperopt results
 
-You can list the hyperoptimization epochs the Hyperopt module evaluated previously with the `hyperopt-list` subcommand.
+You can list the hyperoptimization epochs the Hyperopt module evaluated previously with the `hyperopt-list` sub-command.
 
 ```
 usage: freqtrade hyperopt-list [-h] [-v] [--logfile FILE] [-V] [-c PATH]
@@ -432,10 +432,11 @@ usage: freqtrade hyperopt-list [-h] [-v] [--logfile FILE] [-V] [-c PATH]
                                [--max-trades INT] [--min-avg-time FLOAT]
                                [--max-avg-time FLOAT] [--min-avg-profit FLOAT]
                                [--max-avg-profit FLOAT]
-                               [--min-total-profit FLOAT] [--max-total-profit FLOAT]
+                               [--min-total-profit FLOAT]
+                               [--max-total-profit FLOAT]
                                [--min-objective FLOAT] [--max-objective FLOAT]
                                [--no-color] [--print-json] [--no-details]
-                               [--export-csv FILE]
+                               [--hyperopt-filename PATH] [--export-csv FILE]
 
 optional arguments:
   -h, --help            show this help message and exit
@@ -443,24 +444,27 @@ optional arguments:
   --profitable          Select only profitable epochs.
   --min-trades INT      Select epochs with more than INT trades.
   --max-trades INT      Select epochs with less than INT trades.
-  --min-avg-time FLOAT  Select epochs on above average time.
-  --max-avg-time FLOAT  Select epochs on under average time.
+  --min-avg-time FLOAT  Select epochs above average time.
+  --max-avg-time FLOAT  Select epochs below average time.
   --min-avg-profit FLOAT
-                        Select epochs on above average profit.
+                        Select epochs above average profit.
   --max-avg-profit FLOAT
-                        Select epochs on below average profit.
+                        Select epochs below average profit.
   --min-total-profit FLOAT
-                        Select epochs on above total profit.
+                        Select epochs above total profit.
   --max-total-profit FLOAT
-                        Select epochs on below total profit.
+                        Select epochs below total profit.
   --min-objective FLOAT
-                        Select epochs on above objective (- is added by default).
+                        Select epochs above objective.
   --max-objective FLOAT
-                        Select epochs on below objective (- is added by default).
+                        Select epochs below objective.
   --no-color            Disable colorization of hyperopt results. May be
                         useful if you are redirecting output to a file.
-  --print-json          Print best result detailization in JSON format.
+  --print-json          Print output in JSON format.
   --no-details          Do not print best epoch details.
+  --hyperopt-filename FILENAME
+                        Hyperopt result filename.Example: `--hyperopt-
+                        filename=hyperopt_results_2020-09-27_16-20-48.pickle`
   --export-csv FILE     Export to CSV-File. This will disable table print.
                         Example: --export-csv hyperopt.csv
 
@@ -481,6 +485,10 @@ Common arguments:
                         Path to userdata directory.
 ```
 
+!!! Note
+    `hyperopt-list` will automatically use the latest available hyperopt results file.
+    You can override this using the `--hyperopt-filename` argument, and specify another, available filename (without path!).
+
 ### Examples
 
 List all results, print details of the best result at the end:
@@ -501,17 +509,41 @@ You can show the details of any hyperoptimization epoch previously evaluated by
 usage: freqtrade hyperopt-show [-h] [-v] [--logfile FILE] [-V] [-c PATH]
                                [-d PATH] [--userdir PATH] [--best]
                                [--profitable] [-n INT] [--print-json]
-                               [--no-header]
+                               [--hyperopt-filename PATH] [--no-header]
 
 optional arguments:
   -h, --help            show this help message and exit
   --best                Select only best epochs.
   --profitable          Select only profitable epochs.
   -n INT, --index INT   Specify the index of the epoch to print details for.
-  --print-json          Print best result detailization in JSON format.
+  --print-json          Print output in JSON format.
+  --hyperopt-filename FILENAME
+                        Hyperopt result filename.Example: `--hyperopt-
+                        filename=hyperopt_results_2020-09-27_16-20-48.pickle`
   --no-header           Do not print epoch details header.
+
+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
+                        Path to directory with historical backtesting data.
+  --userdir PATH, --user-data-dir PATH
+                        Path to userdata directory.
+
 ```
 
+!!! Note
+    `hyperopt-show` will automatically use the latest available hyperopt results file.
+    You can override this using the `--hyperopt-filename` argument, and specify another, available filename (without path!).
+
 ### Examples
 
 Print details for the epoch 168 (the number of the epoch is shown by the `hyperopt-list` subcommand or by Hyperopt itself during hyperoptimization run):

docs/windows_installation.md

@@ -0,0 +1,57 @@
+We **strongly** recommend that Windows users use [Docker](docker.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, try the instructions below.
+
+## Install freqtrade manually
+
+!!! Note
+    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.
+
+!!! 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#Anaconda) in this document for more information.
+
+### 1. Clone the git repository
+
+```bash
+git clone https://github.com/freqtrade/freqtrade.git
+```
+
+### 2. Install ta-lib
+
+Install ta-lib according to the [ta-lib documentation](https://github.com/mrjbq7/ta-lib#windows).
+
+As compiling from source on windows has heavy dependencies (requires a partial visual studio installation), there is also a repository of unofficial precompiled windows Wheels [here](https://www.lfd.uci.edu/~gohlke/pythonlibs/#ta-lib), which needs to be downloaded and installed using `pip install TA_Lib‑0.4.19‑cp38‑cp38‑win_amd64.whl` (make sure to use the version matching your python version)
+
+Freqtrade provides these dependencies for the latest 2 Python versions (3.7 and 3.8) and for 64bit Windows.
+Other versions must be downloaded from the above link.
+
+``` powershell
+cd \path\freqtrade
+python -m venv .env
+.env\Scripts\activate.ps1
+# optionally install ta-lib from wheel
+# Eventually adjust the below filename to match the downloaded wheel
+pip install build_helpers/TA_Lib-0.4.19-cp38-cp38-win_amd64.whl
+pip install -r requirements.txt
+pip install -e .
+freqtrade
+```
+
+!!! Note "Use Powershell"
+    The above installation script assumes you're using powershell on a 64bit windows.
+    Commands for the legacy CMD windows console may differ.
+
+> Thanks [Owdr](https://github.com/Owdr) for the commands. Source: [Issue #222](https://github.com/freqtrade/freqtrade/issues/222)
+
+### Error during installation on Windows
+
+``` bash
+error: Microsoft Visual C++ 14.0 is required. Get it with "Microsoft Visual C++ Build Tools": http://landinghub.visualstudio.com/visual-cpp-build-tools
+```
+
+Unfortunately, many packages requiring compilation don't provide a pre-built wheel. It is therefore mandatory to have a C/C++ compiler installed and available for your python environment to use.
+
+The easiest way is to download install Microsoft Visual Studio Community [here](https://visualstudio.microsoft.com/downloads/) and make sure to install "Common Tools for Visual C++" to enable building C code on Windows. Unfortunately, this is a heavy download / dependency (~4Gb) so you might want to consider WSL or [docker](docker.md) first.
+
+---

freqtrade/__init__.py

@@ -1,5 +1,5 @@
 """ Freqtrade bot """
-__version__ = '2020.8'
+__version__ = '2020.11'
 
 if __version__ == 'develop':
 

freqtrade/__main__.py

@@ -8,5 +8,6 @@ To launch Freqtrade as a module
 
 from freqtrade import main
 
+
 if __name__ == '__main__':
     main.main()

freqtrade/commands/__init__.py

@@ -8,23 +8,15 @@ Note: Be careful with file-scoped imports in these subfiles.
 """
 from freqtrade.commands.arguments import Arguments
 from freqtrade.commands.build_config_commands import start_new_config
-from freqtrade.commands.data_commands import (start_convert_data,
-                                              start_download_data,
+from freqtrade.commands.data_commands import (start_convert_data, start_download_data,
                                               start_list_data)
-from freqtrade.commands.deploy_commands import (start_create_userdir,
-                                                start_new_hyperopt,
+from freqtrade.commands.deploy_commands import (start_create_userdir, start_new_hyperopt,
                                                 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_hyperopts,
-                                              start_list_markets,
-                                              start_list_strategies,
-                                              start_list_timeframes,
-                                              start_show_trades)
-from freqtrade.commands.optimize_commands import (start_backtesting,
-                                                  start_edge, start_hyperopt)
+from freqtrade.commands.hyperopt_commands import start_hyperopt_list, start_hyperopt_show
+from freqtrade.commands.list_commands import (start_list_exchanges, start_list_hyperopts,
+                                              start_list_markets, start_list_strategies,
+                                              start_list_timeframes, start_show_trades)
+from freqtrade.commands.optimize_commands import start_backtesting, 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.plot_commands import start_plot_dataframe, start_plot_profit
 from freqtrade.commands.trade_commands import start_trading

freqtrade/commands/arguments.py

@@ -9,13 +9,14 @@ from typing import Any, Dict, List, Optional
 from freqtrade.commands.cli_options import AVAILABLE_CLI_OPTIONS
 from freqtrade.constants import DEFAULT_CONFIG
 
+
 ARGS_COMMON = ["verbosity", "logfile", "version", "config", "datadir", "user_data_dir"]
 
 ARGS_STRATEGY = ["strategy", "strategy_path"]
 
 ARGS_TRADE = ["db_url", "sd_notify", "dry_run"]
 
-ARGS_COMMON_OPTIMIZE = ["timeframe", "timerange",
+ARGS_COMMON_OPTIMIZE = ["timeframe", "timerange", "dataformat_ohlcv",
                         "max_open_trades", "stake_amount", "fee"]
 
 ARGS_BACKTEST = ARGS_COMMON_OPTIMIZE + ["position_stacking", "use_max_market_positions",
@@ -26,7 +27,7 @@ ARGS_HYPEROPT = ARGS_COMMON_OPTIMIZE + ["hyperopt", "hyperopt_path",
                                         "use_max_market_positions", "print_all",
                                         "print_colorized", "print_json", "hyperopt_jobs",
                                         "hyperopt_random_state", "hyperopt_min_trades",
-                                        "hyperopt_continue", "hyperopt_loss"]
+                                        "hyperopt_loss"]
 
 ARGS_EDGE = ARGS_COMMON_OPTIMIZE + ["stoploss_range"]
 
@@ -56,7 +57,7 @@ ARGS_CONVERT_DATA_OHLCV = ARGS_CONVERT_DATA + ["timeframes"]
 
 ARGS_LIST_DATA = ["exchange", "dataformat_ohlcv", "pairs"]
 
-ARGS_DOWNLOAD_DATA = ["pairs", "pairs_file", "days", "download_trades", "exchange",
+ARGS_DOWNLOAD_DATA = ["pairs", "pairs_file", "days", "timerange", "download_trades", "exchange",
                       "timeframes", "erase", "dataformat_ohlcv", "dataformat_trades"]
 
 ARGS_PLOT_DATAFRAME = ["pairs", "indicators1", "indicators2", "plot_limit",
@@ -75,10 +76,10 @@ ARGS_HYPEROPT_LIST = ["hyperopt_list_best", "hyperopt_list_profitable",
                       "hyperopt_list_min_total_profit", "hyperopt_list_max_total_profit",
                       "hyperopt_list_min_objective", "hyperopt_list_max_objective",
                       "print_colorized", "print_json", "hyperopt_list_no_details",
-                      "export_csv"]
+                      "hyperoptexportfilename", "export_csv"]
 
 ARGS_HYPEROPT_SHOW = ["hyperopt_list_best", "hyperopt_list_profitable", "hyperopt_show_index",
-                      "print_json", "hyperopt_show_no_header"]
+                      "print_json", "hyperoptexportfilename", "hyperopt_show_no_header"]
 
 NO_CONF_REQURIED = ["convert-data", "convert-trade-data", "download-data", "list-timeframes",
                     "list-markets", "list-pairs", "list-strategies", "list-data",
@@ -161,16 +162,14 @@ class Arguments:
         self.parser = argparse.ArgumentParser(description='Free, open source crypto trading bot')
         self._build_args(optionlist=['version'], parser=self.parser)
 
-        from freqtrade.commands import (start_create_userdir, start_convert_data,
-                                        start_download_data, start_list_data,
-                                        start_hyperopt_list, start_hyperopt_show,
+        from freqtrade.commands import (start_backtesting, start_convert_data, start_create_userdir,
+                                        start_download_data, start_edge, start_hyperopt,
+                                        start_hyperopt_list, start_hyperopt_show, start_list_data,
                                         start_list_exchanges, start_list_hyperopts,
                                         start_list_markets, start_list_strategies,
-                                        start_list_timeframes, start_new_config,
-                                        start_new_hyperopt, start_new_strategy,
-                                        start_plot_dataframe, start_plot_profit, start_show_trades,
-                                        start_backtesting, start_hyperopt, start_edge,
-                                        start_test_pairlist, start_trading)
+                                        start_list_timeframes, start_new_config, start_new_hyperopt,
+                                        start_new_strategy, start_plot_dataframe, start_plot_profit,
+                                        start_show_trades, start_test_pairlist, start_trading)
 
         subparsers = self.parser.add_subparsers(dest='command',
                                                 # Use custom message when no subhandler is added

freqtrade/commands/build_config_commands.py

@@ -1,13 +1,15 @@
 import logging
 from pathlib import Path
-from typing import Any, Dict
+from typing import Any, Dict, List
 
 from questionary import Separator, prompt
 
 from freqtrade.constants import UNLIMITED_STAKE_AMOUNT
-from freqtrade.exchange import available_exchanges, MAP_EXCHANGE_CHILDCLASS
-from freqtrade.misc import render_template
 from freqtrade.exceptions import OperationalException
+from freqtrade.exchange import MAP_EXCHANGE_CHILDCLASS, available_exchanges
+from freqtrade.misc import render_template
+
+
 logger = logging.getLogger(__name__)
 
 
@@ -46,7 +48,7 @@ def ask_user_config() -> Dict[str, Any]:
     Interactive questions built using https://github.com/tmbo/questionary
     :returns: Dict with keys to put into template
     """
-    questions = [
+    questions: List[Dict[str, Any]] = [
         {
             "type": "confirm",
             "name": "dry_run",

freqtrade/commands/cli_options.py

@@ -4,6 +4,7 @@ Definition of cli arguments used in arguments.py
 from argparse import ArgumentTypeError
 
 from freqtrade import __version__, constants
+from freqtrade.constants import HYPEROPT_LOSS_BUILTIN
 
 
 def check_int_positive(value: str) -> int:
@@ -252,23 +253,19 @@ AVAILABLE_CLI_OPTIONS = {
         metavar='INT',
         default=1,
     ),
-    "hyperopt_continue": Arg(
-        "--continue",
-        help="Continue hyperopt from previous runs. "
-        "By default, temporary files will be removed and hyperopt will start from scratch.",
-        default=False,
-        action='store_true',
-    ),
     "hyperopt_loss": Arg(
         '--hyperopt-loss',
         help='Specify the class name of the hyperopt loss function class (IHyperOptLoss). '
         'Different functions can generate completely different results, '
         'since the target for optimization is different. Built-in Hyperopt-loss-functions are: '
-        'DefaultHyperOptLoss, OnlyProfitHyperOptLoss, SharpeHyperOptLoss, SharpeHyperOptLossDaily, '
-        'SortinoHyperOptLoss, SortinoHyperOptLossDaily.'
-        '(default: `%(default)s`).',
+        f'{", ".join(HYPEROPT_LOSS_BUILTIN)}',
         metavar='NAME',
-        default=constants.DEFAULT_HYPEROPT_LOSS,
+    ),
+    "hyperoptexportfilename": Arg(
+        '--hyperopt-filename',
+        help='Hyperopt result filename.'
+        'Example: `--hyperopt-filename=hyperopt_results_2020-09-27_16-20-48.pickle`',
+        metavar='FILENAME',
     ),
     # List exchanges
     "print_one_column": Arg(
@@ -357,13 +354,11 @@ AVAILABLE_CLI_OPTIONS = {
         '--data-format-ohlcv',
         help='Storage format for downloaded candle (OHLCV) data. (default: `%(default)s`).',
         choices=constants.AVAILABLE_DATAHANDLERS,
-        default='json'
     ),
     "dataformat_trades": Arg(
         '--data-format-trades',
         help='Storage format for downloaded trades data. (default: `%(default)s`).',
         choices=constants.AVAILABLE_DATAHANDLERS,
-        default='jsongz'
     ),
     "exchange": Arg(
         '--exchange',
@@ -375,7 +370,7 @@ AVAILABLE_CLI_OPTIONS = {
         help='Specify which tickers to download. Space-separated list. '
         'Default: `1m 5m`.',
         choices=['1m', '3m', '5m', '15m', '30m', '1h', '2h', '4h',
-                 '6h', '8h', '12h', '1d', '3d', '1w'],
+                 '6h', '8h', '12h', '1d', '3d', '1w', '2w', '1M', '1y'],
         default=['1m', '5m'],
         nargs='+',
     ),

freqtrade/commands/data_commands.py

@@ -1,21 +1,19 @@
 import logging
 import sys
 from collections import defaultdict
+from datetime import datetime, timedelta
 from typing import Any, Dict, List
 
-import arrow
-
 from freqtrade.configuration import TimeRange, setup_utils_configuration
-from freqtrade.data.converter import (convert_ohlcv_format,
-                                      convert_trades_format)
-from freqtrade.data.history import (convert_trades_to_ohlcv,
-                                    refresh_backtest_ohlcv_data,
+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)
 from freqtrade.exceptions import OperationalException
 from freqtrade.exchange import timeframe_to_minutes
 from freqtrade.resolvers import ExchangeResolver
 from freqtrade.state import RunMode
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -25,11 +23,20 @@ def start_download_data(args: Dict[str, Any]) -> None:
     """
     config = setup_utils_configuration(args, RunMode.UTIL_EXCHANGE)
 
+    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 = arrow.utcnow().shift(days=-config['days']).strftime("%Y%m%d")
+        time_since = (datetime.now() - timedelta(days=config['days'])).strftime("%Y%m%d")
         timerange = TimeRange.parse_timerange(f'{time_since}-')
 
+    if 'timerange' in config:
+        timerange = timerange.parse_timerange(config['timerange'])
+
+    # 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. "
@@ -99,8 +106,9 @@ def start_list_data(args: Dict[str, Any]) -> None:
 
     config = setup_utils_configuration(args, RunMode.UTIL_NO_EXCHANGE)
 
-    from freqtrade.data.history.idatahandler import get_datahandler
     from tabulate import tabulate
+
+    from freqtrade.data.history.idatahandler import get_datahandler
     dhc = get_datahandler(config['datadir'], config['dataformat_ohlcv'])
 
     paircombs = dhc.ohlcv_get_available_data(config['datadir'])

freqtrade/commands/deploy_commands.py

@@ -4,13 +4,13 @@ from pathlib import Path
 from typing import Any, Dict
 
 from freqtrade.configuration import setup_utils_configuration
-from freqtrade.configuration.directory_operations import (copy_sample_files,
-                                                          create_userdata_dir)
+from freqtrade.configuration.directory_operations import copy_sample_files, create_userdata_dir
 from freqtrade.constants import USERPATH_HYPEROPTS, USERPATH_STRATEGIES
 from freqtrade.exceptions import OperationalException
 from freqtrade.misc import render_template, render_template_with_fallback
 from freqtrade.state import RunMode
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -133,7 +133,7 @@ def start_new_hyperopt(args: Dict[str, Any]) -> None:
 
         if new_path.exists():
             raise OperationalException(f"`{new_path}` already exists. "
-                                       "Please choose another Strategy Name.")
+                                       "Please choose another Hyperopt Name.")
         deploy_new_hyperopt(args['hyperopt'], new_path, args['template'])
     else:
         raise OperationalException("`new-hyperopt` requires --hyperopt to be set.")

freqtrade/commands/hyperopt_commands.py

@@ -5,9 +5,11 @@ from typing import Any, Dict, List
 from colorama import init as colorama_init
 
 from freqtrade.configuration import setup_utils_configuration
+from freqtrade.data.btanalysis import get_latest_hyperopt_file
 from freqtrade.exceptions import OperationalException
 from freqtrade.state import RunMode
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -40,8 +42,9 @@ def start_hyperopt_list(args: Dict[str, Any]) -> None:
         'filter_max_objective': config.get('hyperopt_list_max_objective', None),
     }
 
-    results_file = (config['user_data_dir'] /
-                    'hyperopt_results' / 'hyperopt_results.pickle')
+    results_file = get_latest_hyperopt_file(
+        config['user_data_dir'] / 'hyperopt_results',
+        config.get('hyperoptexportfilename'))
 
     # Previous evaluations
     epochs = Hyperopt.load_previous_results(results_file)
@@ -80,8 +83,10 @@ def start_hyperopt_show(args: Dict[str, Any]) -> None:
 
     print_json = config.get('print_json', False)
     no_header = config.get('hyperopt_show_no_header', False)
-    results_file = (config['user_data_dir'] /
-                    'hyperopt_results' / 'hyperopt_results.pickle')
+    results_file = get_latest_hyperopt_file(
+        config['user_data_dir'] / 'hyperopt_results',
+        config.get('hyperoptexportfilename'))
+
     n = config.get('hyperopt_show_index', -1)
 
     filteroptions = {

freqtrade/commands/list_commands.py

@@ -5,20 +5,20 @@ from collections import OrderedDict
 from pathlib import Path
 from typing import Any, Dict, List
 
-from colorama import init as colorama_init
-from colorama import Fore, Style
 import rapidjson
+from colorama import Fore, Style
+from colorama import init as colorama_init
 from tabulate import tabulate
 
 from freqtrade.configuration import setup_utils_configuration
 from freqtrade.constants import USERPATH_HYPEROPTS, USERPATH_STRATEGIES
 from freqtrade.exceptions import OperationalException
-from freqtrade.exchange import (available_exchanges, ccxt_exchanges,
-                                market_is_active)
+from freqtrade.exchange import available_exchanges, ccxt_exchanges, market_is_active
 from freqtrade.misc import plural
 from freqtrade.resolvers import ExchangeResolver, StrategyResolver
 from freqtrade.state import RunMode
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -203,15 +203,16 @@ def start_show_trades(args: Dict[str, Any]) -> None:
     """
     Show trades
     """
-    from freqtrade.persistence import init, Trade
     import json
+
+    from freqtrade.persistence import Trade, init_db
     config = setup_utils_configuration(args, RunMode.UTIL_NO_EXCHANGE)
 
     if 'db_url' not in config:
         raise OperationalException("--db-url is required for this command.")
 
     logger.info(f'Using DB: "{config["db_url"]}"')
-    init(config['db_url'], clean_open_orders=False)
+    init_db(config['db_url'], clean_open_orders=False)
     tfilter = []
 
     if config.get('trade_ids'):

freqtrade/commands/optimize_commands.py

@@ -6,6 +6,7 @@ from freqtrade.configuration import setup_utils_configuration
 from freqtrade.exceptions import DependencyException, OperationalException
 from freqtrade.state import RunMode
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -58,6 +59,7 @@ def start_hyperopt(args: Dict[str, Any]) -> None:
     # Import here to avoid loading hyperopt module when it's not used
     try:
         from filelock import FileLock, Timeout
+
         from freqtrade.optimize.hyperopt import Hyperopt
     except ImportError as e:
         raise OperationalException(
@@ -98,6 +100,7 @@ def start_edge(args: Dict[str, Any]) -> None:
     :return: None
     """
     from freqtrade.optimize.edge_cli import EdgeCli
+
     # Initialize configuration
     config = setup_optimize_configuration(args, RunMode.EDGE)
     logger.info('Starting freqtrade in Edge mode')

freqtrade/commands/pairlist_commands.py

@@ -7,6 +7,7 @@ from freqtrade.configuration import setup_utils_configuration
 from freqtrade.resolvers import ExchangeResolver
 from freqtrade.state import RunMode
 
+
 logger = logging.getLogger(__name__)
 
 

freqtrade/commands/trade_commands.py

@@ -1,5 +1,4 @@
 import logging
-
 from typing import Any, Dict
 
 

freqtrade/configuration/__init__.py

@@ -1,7 +1,7 @@
 # flake8: noqa: F401
 
-from freqtrade.configuration.config_setup import setup_utils_configuration
 from freqtrade.configuration.check_exchange import check_exchange, remove_credentials
-from freqtrade.configuration.timerange import TimeRange
-from freqtrade.configuration.configuration import Configuration
+from freqtrade.configuration.config_setup import setup_utils_configuration
 from freqtrade.configuration.config_validation import validate_config_consistency
+from freqtrade.configuration.configuration import Configuration
+from freqtrade.configuration.timerange import TimeRange

freqtrade/configuration/check_exchange.py

@@ -2,11 +2,11 @@ import logging
 from typing import Any, Dict
 
 from freqtrade.exceptions import OperationalException
-from freqtrade.exchange import (available_exchanges, get_exchange_bad_reason,
-                                is_exchange_bad, is_exchange_known_ccxt,
-                                is_exchange_officially_supported)
+from freqtrade.exchange import (available_exchanges, get_exchange_bad_reason, is_exchange_bad,
+                                is_exchange_known_ccxt, is_exchange_officially_supported)
 from freqtrade.state import RunMode
 
+
 logger = logging.getLogger(__name__)
 
 

freqtrade/configuration/config_setup.py

@@ -1,10 +1,12 @@
 import logging
 from typing import Any, Dict
 
+from freqtrade.state import RunMode
+
+from .check_exchange import remove_credentials
 from .config_validation import validate_config_consistency
 from .configuration import Configuration
-from .check_exchange import remove_credentials
-from freqtrade.state import RunMode
+
 
 logger = logging.getLogger(__name__)
 

freqtrade/configuration/config_validation.py

@@ -9,6 +9,7 @@ from freqtrade import constants
 from freqtrade.exceptions import OperationalException
 from freqtrade.state import RunMode
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -136,6 +137,10 @@ def _validate_edge(conf: Dict[str, Any]) -> None:
             "Edge and VolumePairList are incompatible, "
             "Edge will override whatever pairs VolumePairlist selects."
         )
+    if not conf.get('ask_strategy', {}).get('use_sell_signal', True):
+        raise OperationalException(
+            "Edge requires `use_sell_signal` to be True, otherwise no sells will happen."
+        )
 
 
 def _validate_whitelist(conf: Dict[str, Any]) -> None:

freqtrade/configuration/configuration.py

@@ -10,14 +10,14 @@ from typing import Any, Callable, Dict, List, Optional
 from freqtrade import constants
 from freqtrade.configuration.check_exchange import check_exchange
 from freqtrade.configuration.deprecated_settings import process_temporary_deprecated_settings
-from freqtrade.configuration.directory_operations import (create_datadir,
-                                                          create_userdata_dir)
+from freqtrade.configuration.directory_operations import create_datadir, create_userdata_dir
 from freqtrade.configuration.load_config import load_config_file
 from freqtrade.exceptions import OperationalException
 from freqtrade.loggers import setup_logging
 from freqtrade.misc import deep_merge_dicts, json_load
 from freqtrade.state import NON_UTIL_MODES, TRADING_MODES, RunMode
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -263,6 +263,9 @@ class Configuration:
         self._args_to_config(config, argname='hyperopt_path',
                              logstring='Using additional Hyperopt lookup path: {}')
 
+        self._args_to_config(config, argname='hyperoptexportfilename',
+                             logstring='Using hyperopt file: {}')
+
         self._args_to_config(config, argname='epochs',
                              logstring='Parameter --epochs detected ... '
                              'Will run Hyperopt with for {} epochs ...'
@@ -295,9 +298,6 @@ class Configuration:
         self._args_to_config(config, argname='hyperopt_min_trades',
                              logstring='Parameter --min-trades detected: {}')
 
-        self._args_to_config(config, argname='hyperopt_continue',
-                             logstring='Hyperopt continue: {}')
-
         self._args_to_config(config, argname='hyperopt_loss',
                              logstring='Using Hyperopt loss class name: {}')
 

freqtrade/configuration/directory_operations.py

@@ -3,8 +3,9 @@ import shutil
 from pathlib import Path
 from typing import Any, Dict, Optional
 
-from freqtrade.exceptions import OperationalException
 from freqtrade.constants import USER_DATA_FILES
+from freqtrade.exceptions import OperationalException
+
 
 logger = logging.getLogger(__name__)
 

freqtrade/configuration/load_config.py

@@ -11,6 +11,7 @@ import rapidjson
 
 from freqtrade.exceptions import OperationalException
 
+
 logger = logging.getLogger(__name__)
 
 

freqtrade/configuration/timerange.py

@@ -52,11 +52,11 @@ class TimeRange:
         :return: None (Modifies the object in place)
         """
         if (not self.starttype or (startup_candles
-                                   and min_date.timestamp >= self.startts)):
+                                   and min_date.int_timestamp >= self.startts)):
             # If no startts was defined, or backtest-data starts at the defined backtest-date
             logger.warning("Moving start-date by %s candles to account for startup time.",
                            startup_candles)
-            self.startts = (min_date.timestamp + timeframe_secs * startup_candles)
+            self.startts = (min_date.int_timestamp + timeframe_secs * startup_candles)
             self.starttype = 'date'
 
     @staticmethod
@@ -89,7 +89,7 @@ class TimeRange:
                 if stype[0]:
                     starts = rvals[index]
                     if stype[0] == 'date' and len(starts) == 8:
-                        start = arrow.get(starts, 'YYYYMMDD').timestamp
+                        start = arrow.get(starts, 'YYYYMMDD').int_timestamp
                     elif len(starts) == 13:
                         start = int(starts) // 1000
                     else:
@@ -98,7 +98,7 @@ class TimeRange:
                 if stype[1]:
                     stops = rvals[index]
                     if stype[1] == 'date' and len(stops) == 8:
-                        stop = arrow.get(stops, 'YYYYMMDD').timestamp
+                        stop = arrow.get(stops, 'YYYYMMDD').int_timestamp
                     elif len(stops) == 13:
                         stop = int(stops) // 1000
                     else:

freqtrade/constants.py

@@ -11,7 +11,6 @@ DEFAULT_EXCHANGE = 'bittrex'
 PROCESS_THROTTLE_SECS = 5  # sec
 HYPEROPT_EPOCH = 100  # epochs
 RETRY_TIMEOUT = 30  # sec
-DEFAULT_HYPEROPT_LOSS = 'DefaultHyperOptLoss'
 DEFAULT_DB_PROD_URL = 'sqlite:///tradesv3.sqlite'
 DEFAULT_DB_DRYRUN_URL = 'sqlite:///tradesv3.dryrun.sqlite'
 UNLIMITED_STAKE_AMOUNT = 'unlimited'
@@ -21,10 +20,13 @@ REQUIRED_ORDERTYPES = ['buy', 'sell', 'stoploss', 'stoploss_on_exchange']
 ORDERBOOK_SIDES = ['ask', 'bid']
 ORDERTYPE_POSSIBILITIES = ['limit', 'market']
 ORDERTIF_POSSIBILITIES = ['gtc', 'fok', 'ioc']
+HYPEROPT_LOSS_BUILTIN = ['ShortTradeDurHyperOptLoss', 'OnlyProfitHyperOptLoss',
+                         'SharpeHyperOptLoss', 'SharpeHyperOptLossDaily',
+                         'SortinoHyperOptLoss', 'SortinoHyperOptLossDaily']
 AVAILABLE_PAIRLISTS = ['StaticPairList', 'VolumePairList',
                        'AgeFilter', 'PrecisionFilter', 'PriceFilter',
-                       'ShuffleFilter', 'SpreadFilter']
-AVAILABLE_DATAHANDLERS = ['json', 'jsongz']
+                       'RangeStabilityFilter', 'ShuffleFilter', 'SpreadFilter']
+AVAILABLE_DATAHANDLERS = ['json', 'jsongz', 'hdf5']
 DRY_RUN_WALLET = 1000
 DATETIME_PRINT_FORMAT = '%Y-%m-%d %H:%M:%S'
 MATH_CLOSE_PREC = 1e-14  # Precision used for float comparisons
@@ -39,6 +41,8 @@ USERPATH_HYPEROPTS = 'hyperopts'
 USERPATH_STRATEGIES = 'strategies'
 USERPATH_NOTEBOOKS = 'notebooks'
 
+TELEGRAM_SETTING_OPTIONS = ['on', 'off', 'silent']
+
 # Soure files with destination directories within user-directory
 USER_DATA_FILES = {
     'sample_strategy.py': USERPATH_STRATEGIES,
@@ -201,6 +205,18 @@ CONF_SCHEMA = {
                 'enabled': {'type': 'boolean'},
                 'token': {'type': 'string'},
                 'chat_id': {'type': 'string'},
+                'notification_settings': {
+                    'type': 'object',
+                    'properties': {
+                        'status': {'type': 'string', 'enum': TELEGRAM_SETTING_OPTIONS},
+                        'warning': {'type': 'string', 'enum': TELEGRAM_SETTING_OPTIONS},
+                        'startup': {'type': 'string', 'enum': TELEGRAM_SETTING_OPTIONS},
+                        'buy': {'type': 'string', 'enum': TELEGRAM_SETTING_OPTIONS},
+                        'sell': {'type': 'string', 'enum': TELEGRAM_SETTING_OPTIONS},
+                        'buy_cancel': {'type': 'string', 'enum': TELEGRAM_SETTING_OPTIONS},
+                        'sell_cancel': {'type': 'string', 'enum': TELEGRAM_SETTING_OPTIONS}
+                    }
+                }
             },
             'required': ['enabled', 'token', 'chat_id']
         },
@@ -338,11 +354,17 @@ SCHEMA_MINIMAL_REQUIRED = [
 
 CANCEL_REASON = {
     "TIMEOUT": "cancelled due to timeout",
-    "PARTIALLY_FILLED": "partially filled - keeping order open",
+    "PARTIALLY_FILLED_KEEP_OPEN": "partially filled - keeping order open",
+    "PARTIALLY_FILLED": "partially filled",
+    "FULLY_CANCELLED": "fully cancelled",
     "ALL_CANCELLED": "cancelled (all unfilled and partially filled open orders cancelled)",
     "CANCELLED_ON_EXCHANGE": "cancelled on exchange",
+    "FORCE_SELL": "forcesold",
 }
 
 # List of pairs with their timeframes
 PairWithTimeframe = Tuple[str, str]
 ListPairsWithTimeframes = List[PairWithTimeframe]
+
+# Type for trades list
+TradeList = List[List]

freqtrade/data/btanalysis.py

@@ -2,17 +2,17 @@
 Helpers when analyzing backtest data
 """
 import logging
+from datetime import timezone
 from pathlib import Path
-from typing import Dict, Union, Tuple, Any, Optional
+from typing import Any, Dict, Optional, Tuple, Union
 
 import numpy as np
 import pandas as pd
-from datetime import timezone
 
-from freqtrade import persistence
 from freqtrade.constants import LAST_BT_RESULT_FN
 from freqtrade.misc import json_load
-from freqtrade.persistence import Trade
+from freqtrade.persistence import Trade, init_db
+
 
 logger = logging.getLogger(__name__)
 
@@ -21,10 +21,11 @@ BT_DATA_COLUMNS = ["pair", "profit_percent", "open_date", "close_date", "index",
                    "open_rate", "close_rate", "open_at_end", "sell_reason"]
 
 
-def get_latest_backtest_filename(directory: Union[Path, str]) -> str:
+def get_latest_optimize_filename(directory: Union[Path, str], variant: str) -> str:
     """
     Get latest backtest export based on '.last_result.json'.
     :param directory: Directory to search for last result
+    :param variant: 'backtest' or 'hyperopt' - the method to return
     :return: string containing the filename of the latest backtest result
     :raises: ValueError in the following cases:
         * Directory does not exist
@@ -44,10 +45,57 @@ def get_latest_backtest_filename(directory: Union[Path, str]) -> str:
     with filename.open() as file:
         data = json_load(file)
 
-    if 'latest_backtest' not in data:
+    if f'latest_{variant}' not in data:
         raise ValueError(f"Invalid '{LAST_BT_RESULT_FN}' format.")
 
-    return data['latest_backtest']
+    return data[f'latest_{variant}']
+
+
+def get_latest_backtest_filename(directory: Union[Path, str]) -> str:
+    """
+    Get latest backtest export based on '.last_result.json'.
+    :param directory: Directory to search for last result
+    :return: string containing the filename of the latest backtest result
+    :raises: ValueError in the following cases:
+        * Directory does not exist
+        * `directory/.last_result.json` does not exist
+        * `directory/.last_result.json` has the wrong content
+    """
+    return get_latest_optimize_filename(directory, 'backtest')
+
+
+def get_latest_hyperopt_filename(directory: Union[Path, str]) -> str:
+    """
+    Get latest hyperopt export based on '.last_result.json'.
+    :param directory: Directory to search for last result
+    :return: string containing the filename of the latest hyperopt result
+    :raises: ValueError in the following cases:
+        * Directory does not exist
+        * `directory/.last_result.json` does not exist
+        * `directory/.last_result.json` has the wrong content
+    """
+    try:
+        return get_latest_optimize_filename(directory, 'hyperopt')
+    except ValueError:
+        # Return default (legacy) pickle filename
+        return 'hyperopt_results.pickle'
+
+
+def get_latest_hyperopt_file(directory: Union[Path, str], predef_filename: str = None) -> Path:
+    """
+    Get latest hyperopt export based on '.last_result.json'.
+    :param directory: Directory to search for last result
+    :return: string containing the filename of the latest hyperopt result
+    :raises: ValueError in the following cases:
+        * Directory does not exist
+        * `directory/.last_result.json` does not exist
+        * `directory/.last_result.json` has the wrong content
+    """
+    if isinstance(directory, str):
+        directory = Path(directory)
+    if predef_filename:
+        return directory / predef_filename
+    return directory / get_latest_hyperopt_filename(directory)
 
 
 def load_backtest_stats(filename: Union[Path, str]) -> Dict[str, Any]:
@@ -169,7 +217,7 @@ def load_trades_from_db(db_url: str, strategy: Optional[str] = None) -> pd.DataF
                      Can also serve as protection to load the correct result.
     :return: Dataframe containing Trades
     """
-    persistence.init(db_url, clean_open_orders=False)
+    init_db(db_url, clean_open_orders=False)
 
     columns = ["pair", "open_date", "close_date", "profit", "profit_percent",
                "open_rate", "close_rate", "amount", "trade_duration", "sell_reason",

freqtrade/data/converter.py

@@ -10,8 +10,8 @@ from typing import Any, Dict, List
 import pandas as pd
 from pandas import DataFrame, to_datetime
 
-from freqtrade.constants import (DEFAULT_DATAFRAME_COLUMNS,
-                                 DEFAULT_TRADES_COLUMNS)
+from freqtrade.constants import DEFAULT_DATAFRAME_COLUMNS, DEFAULT_TRADES_COLUMNS, TradeList
+
 
 logger = logging.getLogger(__name__)
 
@@ -168,7 +168,7 @@ def trades_remove_duplicates(trades: List[List]) -> List[List]:
     return [i for i, _ in itertools.groupby(sorted(trades, key=itemgetter(0)))]
 
 
-def trades_dict_to_list(trades: List[Dict]) -> List[List]:
+def trades_dict_to_list(trades: List[Dict]) -> TradeList:
     """
     Convert fetch_trades result into a List (to be more memory efficient).
     :param trades: List of trades, as returned by ccxt.fetch_trades.
@@ -177,16 +177,18 @@ def trades_dict_to_list(trades: List[Dict]) -> List[List]:
     return [[t[col] for col in DEFAULT_TRADES_COLUMNS] for t in trades]
 
 
-def trades_to_ohlcv(trades: List, timeframe: str) -> DataFrame:
+def trades_to_ohlcv(trades: TradeList, timeframe: str) -> DataFrame:
     """
     Converts trades list to OHLCV list
-    TODO: This should get a dedicated test
     :param trades: List of trades, as returned by ccxt.fetch_trades.
     :param timeframe: Timeframe to resample data to
     :return: OHLCV Dataframe.
+    :raises: ValueError if no trades are provided
     """
     from freqtrade.exchange import timeframe_to_minutes
     timeframe_minutes = timeframe_to_minutes(timeframe)
+    if not trades:
+        raise ValueError('Trade-list empty.')
     df = pd.DataFrame(trades, columns=DEFAULT_TRADES_COLUMNS)
     df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms',
                                      utc=True,)
@@ -255,7 +257,8 @@ def convert_ohlcv_format(config: Dict[str, Any], convert_from: str, convert_to:
                                   drop_incomplete=False,
                                   startup_candles=0)
             logger.info(f"Converting {len(data)} candles for {pair}")
-            trg.ohlcv_store(pair=pair, timeframe=timeframe, data=data)
-            if erase and convert_from != convert_to:
-                logger.info(f"Deleting source data for {pair} / {timeframe}")
-                src.ohlcv_purge(pair=pair, timeframe=timeframe)
+            if len(data) > 0:
+                trg.ohlcv_store(pair=pair, timeframe=timeframe, data=data)
+                if erase and convert_from != convert_to:
+                    logger.info(f"Deleting source data for {pair} / {timeframe}")
+                    src.ohlcv_purge(pair=pair, timeframe=timeframe)

freqtrade/data/dataprovider.py

@@ -8,7 +8,6 @@ import logging
 from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional, Tuple
 
-from arrow import Arrow
 from pandas import DataFrame
 
 from freqtrade.constants import ListPairsWithTimeframes, PairWithTimeframe
@@ -17,6 +16,7 @@ from freqtrade.exceptions import ExchangeError, OperationalException
 from freqtrade.exchange import Exchange
 from freqtrade.state import RunMode
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -37,7 +37,13 @@ class DataProvider:
         :param timeframe: Timeframe to get data for
         :param dataframe: analyzed dataframe
         """
-        self.__cached_pairs[(pair, timeframe)] = (dataframe, Arrow.utcnow().datetime)
+        self.__cached_pairs[(pair, timeframe)] = (dataframe, datetime.now(timezone.utc))
+
+    def add_pairlisthandler(self, pairlists) -> None:
+        """
+        Allow adding pairlisthandler after initialization
+        """
+        self._pairlists = pairlists
 
     def refresh(self,
                 pairlist: ListPairsWithTimeframes,
@@ -81,7 +87,8 @@ class DataProvider:
         """
         return load_pair_history(pair=pair,
                                  timeframe=timeframe or self._config['timeframe'],
-                                 datadir=self._config['datadir']
+                                 datadir=self._config['datadir'],
+                                 data_format=self._config.get('dataformat_ohlcv', 'json')
                                  )
 
     def get_pair_dataframe(self, pair: str, timeframe: str = None) -> DataFrame:

freqtrade/data/history/__init__.py

@@ -5,10 +5,8 @@ Includes:
 * load data for a pair (or a list of pairs) from disk
 * download data from exchange and store to disk
 """
-
-from .history_utils import (convert_trades_to_ohlcv,  # noqa: F401
-                            get_timerange, load_data, load_pair_history,
-                            refresh_backtest_ohlcv_data,
-                            refresh_backtest_trades_data, refresh_data,
+# flake8: noqa: F401
+from .history_utils import (convert_trades_to_ohlcv, get_timerange, load_data, load_pair_history,
+                            refresh_backtest_ohlcv_data, refresh_backtest_trades_data, refresh_data,
                             validate_backtest_data)
-from .idatahandler import get_datahandler  # noqa: F401
+from .idatahandler import get_datahandler

freqtrade/data/history/hdf5datahandler.py

@@ -0,0 +1,213 @@
+import logging
+import re
+from pathlib import Path
+from typing import List, Optional
+
+import numpy as np
+import pandas as pd
+
+from freqtrade import misc
+from freqtrade.configuration import TimeRange
+from freqtrade.constants import (DEFAULT_DATAFRAME_COLUMNS, DEFAULT_TRADES_COLUMNS,
+                                 ListPairsWithTimeframes, TradeList)
+
+from .idatahandler import IDataHandler
+
+
+logger = logging.getLogger(__name__)
+
+
+class HDF5DataHandler(IDataHandler):
+
+    _columns = DEFAULT_DATAFRAME_COLUMNS
+
+    @classmethod
+    def ohlcv_get_available_data(cls, datadir: Path) -> ListPairsWithTimeframes:
+        """
+        Returns a list of all pairs with ohlcv data available in this datadir
+        :param datadir: Directory to search for ohlcv files
+        :return: List of Tuples of (pair, timeframe)
+        """
+        _tmp = [re.search(r'^([a-zA-Z_]+)\-(\d+\S+)(?=.h5)', p.name)
+                for p in datadir.glob("*.h5")]
+        return [(match[1].replace('_', '/'), match[2]) for match in _tmp
+                if match and len(match.groups()) > 1]
+
+    @classmethod
+    def ohlcv_get_pairs(cls, datadir: Path, timeframe: str) -> List[str]:
+        """
+        Returns a list of all pairs with ohlcv data available in this datadir
+        for the specified timeframe
+        :param datadir: Directory to search for ohlcv files
+        :param timeframe: Timeframe to search pairs for
+        :return: List of Pairs
+        """
+
+        _tmp = [re.search(r'^(\S+)(?=\-' + timeframe + '.h5)', p.name)
+                for p in datadir.glob(f"*{timeframe}.h5")]
+        # Check if regex found something and only return these results
+        return [match[0].replace('_', '/') for match in _tmp if match]
+
+    def ohlcv_store(self, pair: str, timeframe: str, data: pd.DataFrame) -> None:
+        """
+        Store data in hdf5 file.
+        :param pair: Pair - used to generate filename
+        :timeframe: Timeframe - used to generate filename
+        :data: Dataframe containing OHLCV data
+        :return: None
+        """
+        key = self._pair_ohlcv_key(pair, timeframe)
+        _data = data.copy()
+
+        filename = self._pair_data_filename(self._datadir, pair, timeframe)
+
+        ds = pd.HDFStore(filename, mode='a', complevel=9, complib='blosc')
+        ds.put(key, _data.loc[:, self._columns], format='table', data_columns=['date'])
+
+        ds.close()
+
+    def _ohlcv_load(self, pair: str, timeframe: str,
+                    timerange: Optional[TimeRange] = None) -> pd.DataFrame:
+        """
+        Internal method used to load data for one pair from disk.
+        Implements the loading and conversion to a Pandas dataframe.
+        Timerange trimming and dataframe validation happens outside of this method.
+        :param pair: Pair to load data
+        :param timeframe: Timeframe (e.g. "5m")
+        :param timerange: Limit data to be loaded to this timerange.
+                        Optionally implemented by subclasses to avoid loading
+                        all data where possible.
+        :return: DataFrame with ohlcv data, or empty DataFrame
+        """
+        key = self._pair_ohlcv_key(pair, timeframe)
+        filename = self._pair_data_filename(self._datadir, pair, timeframe)
+
+        if not filename.exists():
+            return pd.DataFrame(columns=self._columns)
+        where = []
+        if timerange:
+            if timerange.starttype == 'date':
+                where.append(f"date >= Timestamp({timerange.startts * 1e9})")
+            if timerange.stoptype == 'date':
+                where.append(f"date < Timestamp({timerange.stopts * 1e9})")
+
+        pairdata = pd.read_hdf(filename, key=key, mode="r", where=where)
+
+        if list(pairdata.columns) != self._columns:
+            raise ValueError("Wrong dataframe format")
+        pairdata = pairdata.astype(dtype={'open': 'float', 'high': 'float',
+                                          'low': 'float', 'close': 'float', 'volume': 'float'})
+        return pairdata
+
+    def ohlcv_purge(self, pair: str, timeframe: str) -> bool:
+        """
+        Remove data for this pair
+        :param pair: Delete data for this pair.
+        :param timeframe: Timeframe (e.g. "5m")
+        :return: True when deleted, false if file did not exist.
+        """
+        filename = self._pair_data_filename(self._datadir, pair, timeframe)
+        if filename.exists():
+            filename.unlink()
+            return True
+        return False
+
+    def ohlcv_append(self, pair: str, timeframe: str, data: pd.DataFrame) -> None:
+        """
+        Append data to existing data structures
+        :param pair: Pair
+        :param timeframe: Timeframe this ohlcv data is for
+        :param data: Data to append.
+        """
+        raise NotImplementedError()
+
+    @classmethod
+    def trades_get_pairs(cls, datadir: Path) -> List[str]:
+        """
+        Returns a list of all pairs for which trade data is available in this
+        :param datadir: Directory to search for ohlcv files
+        :return: List of Pairs
+        """
+        _tmp = [re.search(r'^(\S+)(?=\-trades.h5)', p.name)
+                for p in datadir.glob("*trades.h5")]
+        # Check if regex found something and only return these results to avoid exceptions.
+        return [match[0].replace('_', '/') for match in _tmp if match]
+
+    def trades_store(self, pair: str, data: TradeList) -> None:
+        """
+        Store trades data (list of Dicts) to file
+        :param pair: Pair - used for filename
+        :param data: List of Lists containing trade data,
+                     column sequence as in DEFAULT_TRADES_COLUMNS
+        """
+        key = self._pair_trades_key(pair)
+
+        ds = pd.HDFStore(self._pair_trades_filename(self._datadir, pair),
+                         mode='a', complevel=9, complib='blosc')
+        ds.put(key, pd.DataFrame(data, columns=DEFAULT_TRADES_COLUMNS),
+               format='table', data_columns=['timestamp'])
+        ds.close()
+
+    def trades_append(self, pair: str, data: TradeList):
+        """
+        Append data to existing files
+        :param pair: Pair - used for filename
+        :param data: List of Lists containing trade data,
+                     column sequence as in DEFAULT_TRADES_COLUMNS
+        """
+        raise NotImplementedError()
+
+    def _trades_load(self, pair: str, timerange: Optional[TimeRange] = None) -> TradeList:
+        """
+        Load a pair from h5 file.
+        :param pair: Load trades for this pair
+        :param timerange: Timerange to load trades for - currently not implemented
+        :return: List of trades
+        """
+        key = self._pair_trades_key(pair)
+        filename = self._pair_trades_filename(self._datadir, pair)
+
+        if not filename.exists():
+            return []
+        where = []
+        if timerange:
+            if timerange.starttype == 'date':
+                where.append(f"timestamp >= {timerange.startts * 1e3}")
+            if timerange.stoptype == 'date':
+                where.append(f"timestamp < {timerange.stopts * 1e3}")
+
+        trades: pd.DataFrame = pd.read_hdf(filename, key=key, mode="r", where=where)
+        trades[['id', 'type']] = trades[['id', 'type']].replace({np.nan: None})
+        return trades.values.tolist()
+
+    def trades_purge(self, pair: str) -> bool:
+        """
+        Remove data for this pair
+        :param pair: Delete data for this pair.
+        :return: True when deleted, false if file did not exist.
+        """
+        filename = self._pair_trades_filename(self._datadir, pair)
+        if filename.exists():
+            filename.unlink()
+            return True
+        return False
+
+    @classmethod
+    def _pair_ohlcv_key(cls, pair: str, timeframe: str) -> str:
+        return f"{pair}/ohlcv/tf_{timeframe}"
+
+    @classmethod
+    def _pair_trades_key(cls, pair: str) -> str:
+        return f"{pair}/trades"
+
+    @classmethod
+    def _pair_data_filename(cls, datadir: Path, pair: str, timeframe: str) -> Path:
+        pair_s = misc.pair_to_filename(pair)
+        filename = datadir.joinpath(f'{pair_s}-{timeframe}.h5')
+        return filename
+
+    @classmethod
+    def _pair_trades_filename(cls, datadir: Path, pair: str) -> Path:
+        pair_s = misc.pair_to_filename(pair)
+        filename = datadir.joinpath(f'{pair_s}-trades.h5')
+        return filename

freqtrade/data/history/history_utils.py

@@ -9,14 +9,14 @@ from pandas import DataFrame
 
 from freqtrade.configuration import TimeRange
 from freqtrade.constants import DEFAULT_DATAFRAME_COLUMNS
-from freqtrade.data.converter import (ohlcv_to_dataframe,
-                                      trades_remove_duplicates,
-                                      trades_to_ohlcv)
+from freqtrade.data.converter import (clean_ohlcv_dataframe, ohlcv_to_dataframe,
+                                      trades_remove_duplicates, trades_to_ohlcv)
 from freqtrade.data.history.idatahandler import IDataHandler, get_datahandler
 from freqtrade.exceptions import OperationalException
 from freqtrade.exchange import Exchange
 from freqtrade.misc import format_ms_time
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -135,7 +135,6 @@ def _load_cached_data_for_updating(pair: str, timeframe: str, timerange: Optiona
     start = None
     if timerange:
         if timerange.starttype == 'date':
-            # TODO: convert to date for conversion
             start = datetime.fromtimestamp(timerange.startts, tz=timezone.utc)
 
     # Intentionally don't pass timerange in - since we need to load the full dataset.
@@ -202,7 +201,10 @@ def _download_pair_history(datadir: Path,
         if data.empty:
             data = new_dataframe
         else:
-            data = data.append(new_dataframe)
+            # Run cleaning again to ensure there were no duplicate candles
+            # Especially between existing and new data.
+            data = clean_ohlcv_dataframe(data.append(new_dataframe), timeframe, pair,
+                                         fill_missing=False, drop_incomplete=False)
 
         logger.debug("New  Start: %s",
                      f"{data.iloc[0]['date']:%Y-%m-%d %H:%M:%S}" if not data.empty else 'None')
@@ -212,10 +214,9 @@ def _download_pair_history(datadir: Path,
         data_handler.ohlcv_store(pair, timeframe, data=data)
         return True
 
-    except Exception as e:
-        logger.error(
-            f'Failed to download history data for pair: "{pair}", timeframe: {timeframe}. '
-            f'Error: {e}'
+    except Exception:
+        logger.exception(
+            f'Failed to download history data for pair: "{pair}", timeframe: {timeframe}.'
         )
         return False
 
@@ -302,10 +303,9 @@ def _download_trades_history(exchange: Exchange,
         logger.info(f"New Amount of trades: {len(trades)}")
         return True
 
-    except Exception as e:
-        logger.error(
+    except Exception:
+        logger.exception(
             f'Failed to download historic trades for pair: "{pair}". '
-            f'Error: {e}'
         )
         return False
 
@@ -354,9 +354,12 @@ def convert_trades_to_ohlcv(pairs: List[str], timeframes: List[str],
             if erase:
                 if data_handler_ohlcv.ohlcv_purge(pair, timeframe):
                     logger.info(f'Deleting existing data for pair {pair}, interval {timeframe}.')
-            ohlcv = trades_to_ohlcv(trades, timeframe)
-            # Store ohlcv
-            data_handler_ohlcv.ohlcv_store(pair, timeframe, data=ohlcv)
+            try:
+                ohlcv = trades_to_ohlcv(trades, timeframe)
+                # Store ohlcv
+                data_handler_ohlcv.ohlcv_store(pair, timeframe, data=ohlcv)
+            except ValueError:
+                logger.exception(f'Could not convert {pair} to OHLCV.')
 
 
 def get_timerange(data: Dict[str, DataFrame]) -> Tuple[arrow.Arrow, arrow.Arrow]:

freqtrade/data/history/idatahandler.py

@@ -13,15 +13,12 @@ from typing import List, Optional, Type
 from pandas import DataFrame
 
 from freqtrade.configuration import TimeRange
-from freqtrade.constants import ListPairsWithTimeframes
-from freqtrade.data.converter import (clean_ohlcv_dataframe,
-                                      trades_remove_duplicates, trim_dataframe)
+from freqtrade.constants import ListPairsWithTimeframes, TradeList
+from freqtrade.data.converter import clean_ohlcv_dataframe, trades_remove_duplicates, trim_dataframe
 from freqtrade.exchange import timeframe_to_seconds
 
-logger = logging.getLogger(__name__)
 
-# Type for trades list
-TradeList = List[List]
+logger = logging.getLogger(__name__)
 
 
 class IDataHandler(ABC):
@@ -50,9 +47,7 @@ class IDataHandler(ABC):
     @abstractmethod
     def ohlcv_store(self, pair: str, timeframe: str, data: DataFrame) -> None:
         """
-        Store data in json format "values".
-            format looks as follows:
-            [[<date>,<open>,<high>,<low>,<close>]]
+        Store ohlcv data.
         :param pair: Pair - used to generate filename
         :timeframe: Timeframe - used to generate filename
         :data: Dataframe containing OHLCV data
@@ -239,6 +234,9 @@ def get_datahandlerclass(datatype: str) -> Type[IDataHandler]:
     elif datatype == 'jsongz':
         from .jsondatahandler import JsonGzDataHandler
         return JsonGzDataHandler
+    elif datatype == 'hdf5':
+        from .hdf5datahandler import HDF5DataHandler
+        return HDF5DataHandler
     else:
         raise ValueError(f"No datahandler for datatype {datatype} available.")
 

freqtrade/data/history/jsondatahandler.py

@@ -8,11 +8,11 @@ from pandas import DataFrame, read_json, to_datetime
 
 from freqtrade import misc
 from freqtrade.configuration import TimeRange
-from freqtrade.constants import (DEFAULT_DATAFRAME_COLUMNS,
-                                 ListPairsWithTimeframes)
+from freqtrade.constants import DEFAULT_DATAFRAME_COLUMNS, ListPairsWithTimeframes, TradeList
 from freqtrade.data.converter import trades_dict_to_list
 
-from .idatahandler import IDataHandler, TradeList
+from .idatahandler import IDataHandler
+
 
 logger = logging.getLogger(__name__)
 

freqtrade/edge/edge_positioning.py

@@ -9,11 +9,12 @@ import utils_find_1st as utf1st
 from pandas import DataFrame
 
 from freqtrade.configuration import TimeRange
-from freqtrade.constants import UNLIMITED_STAKE_AMOUNT, DATETIME_PRINT_FORMAT
-from freqtrade.exceptions import OperationalException
+from freqtrade.constants import DATETIME_PRINT_FORMAT, UNLIMITED_STAKE_AMOUNT
 from freqtrade.data.history import get_timerange, load_data, refresh_data
+from freqtrade.exceptions import OperationalException
 from freqtrade.strategy.interface import SellType
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -86,7 +87,7 @@ class Edge:
         heartbeat = self.edge_config.get('process_throttle_secs')
 
         if (self._last_updated > 0) and (
-                self._last_updated + heartbeat > arrow.utcnow().timestamp):
+                self._last_updated + heartbeat > arrow.utcnow().int_timestamp):
             return False
 
         data: Dict[str, Any] = {}
@@ -145,7 +146,7 @@ class Edge:
         # Fill missing, calculable columns, profit, duration , abs etc.
         trades_df = self._fill_calculable_fields(DataFrame(trades))
         self._cached_pairs = self._process_expectancy(trades_df)
-        self._last_updated = arrow.utcnow().timestamp
+        self._last_updated = arrow.utcnow().int_timestamp
 
         return True
 
@@ -309,8 +310,10 @@ class Edge:
 
         # Calculating number of losing trades, average win and average loss
         df['nb_loss_trades'] = df['nb_trades'] - df['nb_win_trades']
-        df['average_win'] = df['profit_sum'] / df['nb_win_trades']
-        df['average_loss'] = df['loss_sum'] / df['nb_loss_trades']
+        df['average_win'] = np.where(df['nb_win_trades'] == 0, 0.0,
+                                     df['profit_sum'] / df['nb_win_trades'])
+        df['average_loss'] = np.where(df['nb_loss_trades'] == 0, 0.0,
+                                      df['loss_sum'] / df['nb_loss_trades'])
 
         # Win rate = number of profitable trades / number of trades
         df['winrate'] = df['nb_win_trades'] / df['nb_trades']

freqtrade/exceptions.py

@@ -51,6 +51,13 @@ class RetryableOrderError(InvalidOrderException):
     """
 
 
+class InsufficientFundsError(InvalidOrderException):
+    """
+    This error is used when there are not enough funds available on the exchange
+    to create an order.
+    """
+
+
 class TemporaryError(ExchangeError):
     """
     Temporary network or exchange related error.

freqtrade/exchange/__init__.py

@@ -1,19 +1,16 @@
 # flake8: noqa: F401
+# isort: off
 from freqtrade.exchange.common import MAP_EXCHANGE_CHILDCLASS
 from freqtrade.exchange.exchange import Exchange
-from freqtrade.exchange.exchange import (get_exchange_bad_reason,
-                                         is_exchange_bad,
-                                         is_exchange_known_ccxt,
-                                         is_exchange_officially_supported,
-                                         ccxt_exchanges,
-                                         available_exchanges)
-from freqtrade.exchange.exchange import (timeframe_to_seconds,
-                                         timeframe_to_minutes,
-                                         timeframe_to_msecs,
-                                         timeframe_to_next_date,
-                                         timeframe_to_prev_date)
-from freqtrade.exchange.exchange import (market_is_active)
-from freqtrade.exchange.kraken import Kraken
-from freqtrade.exchange.binance import Binance
+# isort: on
 from freqtrade.exchange.bibox import Bibox
+from freqtrade.exchange.binance import Binance
+from freqtrade.exchange.bittrex import Bittrex
+from freqtrade.exchange.exchange import (available_exchanges, ccxt_exchanges,
+                                         get_exchange_bad_reason, is_exchange_bad,
+                                         is_exchange_known_ccxt, is_exchange_officially_supported,
+                                         market_is_active, timeframe_to_minutes, timeframe_to_msecs,
+                                         timeframe_to_next_date, timeframe_to_prev_date,
+                                         timeframe_to_seconds)
 from freqtrade.exchange.ftx import Ftx
+from freqtrade.exchange.kraken import Kraken

freqtrade/exchange/bibox.py

@@ -4,6 +4,7 @@ from typing import Dict
 
 from freqtrade.exchange import Exchange
 
+
 logger = logging.getLogger(__name__)
 
 

freqtrade/exchange/binance.py

@@ -4,12 +4,12 @@ from typing import Dict
 
 import ccxt
 
-from freqtrade.exceptions import (DDosProtection, ExchangeError,
-                                  InvalidOrderException, OperationalException,
-                                  TemporaryError)
+from freqtrade.exceptions import (DDosProtection, InsufficientFundsError, InvalidOrderException,
+                                  OperationalException, TemporaryError)
 from freqtrade.exchange import Exchange
 from freqtrade.exchange.common import retrier
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -20,20 +20,9 @@ class Binance(Exchange):
         "order_time_in_force": ['gtc', 'fok', 'ioc'],
         "trades_pagination": "id",
         "trades_pagination_arg": "fromId",
+        "l2_limit_range": [5, 10, 20, 50, 100, 500, 1000],
     }
 
-    def fetch_l2_order_book(self, pair: str, limit: int = 100) -> dict:
-        """
-        get order book level 2 from exchange
-
-        20180619: binance support limits but only on specific range
-        """
-        limit_range = [5, 10, 20, 50, 100, 500, 1000]
-        # get next-higher step in the limit_range list
-        limit = min(list(filter(lambda x: limit <= x, limit_range)))
-
-        return super().fetch_l2_order_book(pair, limit)
-
     def stoploss_adjust(self, stop_loss: float, order: Dict) -> bool:
         """
         Verify stop_loss against stoploss-order value (limit or price)
@@ -80,7 +69,7 @@ class Binance(Exchange):
                         'stop price: %s. limit: %s', pair, stop_price, rate)
             return order
         except ccxt.InsufficientFunds as e:
-            raise ExchangeError(
+            raise InsufficientFundsError(
                 f'Insufficient funds to create {ordertype} sell order on market {pair}. '
                 f'Tried to sell amount {amount} at rate {rate}. '
                 f'Message: {e}') from e

freqtrade/exchange/bittrex.py

@@ -0,0 +1,23 @@
+""" Bittrex exchange subclass """
+import logging
+from typing import Dict
+
+from freqtrade.exchange import Exchange
+
+
+logger = logging.getLogger(__name__)
+
+
+class Bittrex(Exchange):
+    """
+    Bittrex exchange class. Contains adjustments needed for Freqtrade to work
+    with this exchange.
+
+    Please note that this exchange is not included in the list of exchanges
+    officially supported by the Freqtrade development team. So some features
+    may still not work as expected.
+    """
+
+    _ft_has: Dict = {
+        "l2_limit_range": [1, 25, 500],
+    }

freqtrade/exchange/common.py

@@ -3,13 +3,17 @@ import logging
 import time
 from functools import wraps
 
-from freqtrade.exceptions import (DDosProtection, RetryableOrderError,
-                                  TemporaryError)
+from freqtrade.exceptions import DDosProtection, RetryableOrderError, TemporaryError
+
 
 logger = logging.getLogger(__name__)
 
 
+# Maximum default retry count.
+# Functions are always called RETRY_COUNT + 1 times (for the original call)
 API_RETRY_COUNT = 4
+API_FETCH_ORDER_RETRY_COUNT = 5
+
 BAD_EXCHANGES = {
     "bitmex": "Various reasons.",
     "bitstamp": "Does not provide history. "

freqtrade/exchange/exchange.py

@@ -8,24 +8,25 @@ import logging
 from copy import deepcopy
 from datetime import datetime, timezone
 from math import ceil
-from random import randint
 from typing import Any, Dict, List, Optional, Tuple
 
 import arrow
 import ccxt
 import ccxt.async_support as ccxt_async
-from ccxt.base.decimal_to_precision import (ROUND_DOWN, ROUND_UP, TICK_SIZE,
-                                            TRUNCATE, decimal_to_precision)
+from ccxt.base.decimal_to_precision import (ROUND_DOWN, ROUND_UP, TICK_SIZE, TRUNCATE,
+                                            decimal_to_precision)
 from pandas import DataFrame
 
 from freqtrade.constants import ListPairsWithTimeframes
 from freqtrade.data.converter import ohlcv_to_dataframe, trades_dict_to_list
-from freqtrade.exceptions import (DDosProtection, ExchangeError,
-                                  InvalidOrderException, OperationalException,
-                                  RetryableOrderError, TemporaryError)
-from freqtrade.exchange.common import BAD_EXCHANGES, retrier, retrier_async
+from freqtrade.exceptions import (DDosProtection, ExchangeError, InsufficientFundsError,
+                                  InvalidOrderException, OperationalException, RetryableOrderError,
+                                  TemporaryError)
+from freqtrade.exchange.common import (API_FETCH_ORDER_RETRY_COUNT, BAD_EXCHANGES, retrier,
+                                       retrier_async)
 from freqtrade.misc import deep_merge_dicts, safe_value_fallback2
 
+
 CcxtModuleType = Any
 
 
@@ -52,7 +53,7 @@ class Exchange:
         "ohlcv_partial_candle": True,
         "trades_pagination": "time",  # Possible are "time" or "id"
         "trades_pagination_arg": "since",
-
+        "l2_limit_range": None,
     }
     _ft_has: Dict = {}
 
@@ -123,7 +124,8 @@ class Exchange:
 
             # Check if all pairs are available
             self.validate_stakecurrency(config['stake_currency'])
-            self.validate_pairs(config['exchange']['pair_whitelist'])
+            if not exchange_config.get('skip_pair_validation'):
+                self.validate_pairs(config['exchange']['pair_whitelist'])
             self.validate_ordertypes(config.get('order_types', {}))
             self.validate_order_time_in_force(config.get('order_time_in_force', {}))
             self.validate_required_startup_candles(config.get('startup_candle_count', 0))
@@ -281,7 +283,7 @@ class Exchange:
                 asyncio.get_event_loop().run_until_complete(
                     self._api_async.load_markets(reload=reload))
 
-        except ccxt.BaseError as e:
+        except (asyncio.TimeoutError, ccxt.BaseError) as e:
             logger.warning('Could not load async markets. Reason: %s', e)
             return
 
@@ -290,7 +292,7 @@ class Exchange:
         try:
             self._api.load_markets()
             self._load_async_markets()
-            self._last_markets_refresh = arrow.utcnow().timestamp
+            self._last_markets_refresh = arrow.utcnow().int_timestamp
         except ccxt.BaseError as e:
             logger.warning('Unable to initialize markets. Reason: %s', e)
 
@@ -299,14 +301,14 @@ class Exchange:
         # Check whether markets have to be reloaded
         if (self._last_markets_refresh > 0) and (
                 self._last_markets_refresh + self.markets_refresh_interval
-                > arrow.utcnow().timestamp):
+                > arrow.utcnow().int_timestamp):
             return None
         logger.debug("Performing scheduled market reload..")
         try:
             self._api.load_markets(reload=True)
             # Also reload async markets to avoid issues with newly listed pairs
             self._load_async_markets(reload=True)
-            self._last_markets_refresh = arrow.utcnow().timestamp
+            self._last_markets_refresh = arrow.utcnow().int_timestamp
         except ccxt.BaseError:
             logger.exception("Could not reload markets.")
 
@@ -487,11 +489,11 @@ class Exchange:
 
     def dry_run_order(self, pair: str, ordertype: str, side: str, amount: float,
                       rate: float, params: Dict = {}) -> Dict[str, Any]:
-        order_id = f'dry_run_{side}_{randint(0, 10**6)}'
+        order_id = f'dry_run_{side}_{datetime.now().timestamp()}'
         _amount = self.amount_to_precision(pair, amount)
         dry_order = {
-            "id": order_id,
-            'pair': pair,
+            'id': order_id,
+            'symbol': pair,
             'price': rate,
             'average': rate,
             'amount': _amount,
@@ -500,6 +502,7 @@ class Exchange:
             'side': side,
             'remaining': _amount,
             'datetime': arrow.utcnow().isoformat(),
+            'timestamp': int(arrow.utcnow().int_timestamp * 1000),
             'status': "closed" if ordertype == "market" else "open",
             'fee': None,
             'info': {}
@@ -521,7 +524,7 @@ class Exchange:
                     'rate': self.get_fee(pair)
                 }
             })
-        if closed_order["type"] in ["stop_loss_limit"]:
+        if closed_order["type"] in ["stop_loss_limit", "stop-loss-limit"]:
             closed_order["info"].update({"stopPrice": closed_order["price"]})
         self._dry_run_open_orders[closed_order["id"]] = closed_order
 
@@ -538,7 +541,7 @@ class Exchange:
                                           amount, rate_for_order, params)
 
         except ccxt.InsufficientFunds as e:
-            raise ExchangeError(
+            raise InsufficientFundsError(
                 f'Insufficient funds to create {ordertype} {side} order on market {pair}. '
                 f'Tried to {side} amount {amount} at rate {rate}.'
                 f'Message: {e}') from e
@@ -676,15 +679,31 @@ class Exchange:
         :param pair: Pair to download
         :param timeframe: Timeframe to get data for
         :param since_ms: Timestamp in milliseconds to get history from
-        :returns List with candle (OHLCV) data
+        :return: List with candle (OHLCV) data
         """
         return asyncio.get_event_loop().run_until_complete(
             self._async_get_historic_ohlcv(pair=pair, timeframe=timeframe,
                                            since_ms=since_ms))
 
+    def get_historic_ohlcv_as_df(self, pair: str, timeframe: str,
+                                 since_ms: int) -> DataFrame:
+        """
+        Minimal wrapper around get_historic_ohlcv - converting the result into a dataframe
+        :param pair: Pair to download
+        :param timeframe: Timeframe to get data for
+        :param since_ms: Timestamp in milliseconds to get history from
+        :return: OHLCV DataFrame
+        """
+        ticks = self.get_historic_ohlcv(pair, timeframe, since_ms=since_ms)
+        return ohlcv_to_dataframe(ticks, timeframe, pair=pair, fill_missing=True,
+                                  drop_incomplete=self._ohlcv_partial_candle)
+
     async def _async_get_historic_ohlcv(self, pair: str,
                                         timeframe: str,
                                         since_ms: int) -> List:
+        """
+        Download historic ohlcv
+        """
 
         one_call = timeframe_to_msecs(timeframe) * self._ohlcv_candle_limit
         logger.debug(
@@ -694,15 +713,20 @@ class Exchange:
         )
         input_coroutines = [self._async_get_candle_history(
             pair, timeframe, since) for since in
-            range(since_ms, arrow.utcnow().timestamp * 1000, one_call)]
+            range(since_ms, arrow.utcnow().int_timestamp * 1000, one_call)]
 
         results = await asyncio.gather(*input_coroutines, return_exceptions=True)
 
         # Combine gathered results
         data: List = []
-        for p, timeframe, res in results:
+        for res in results:
+            if isinstance(res, Exception):
+                logger.warning("Async code raised an exception: %s", res.__class__.__name__)
+                continue
+            # Deconstruct tuple if it's not an exception
+            p, _, new_data = res
             if p == pair:
-                data.extend(res)
+                data.extend(new_data)
         # Sort data again after extending the result - above calls return in "async order"
         data = sorted(data, key=lambda x: x[0])
         logger.info("Downloaded data for %s with length %s.", pair, len(data))
@@ -739,9 +763,8 @@ class Exchange:
             if isinstance(res, Exception):
                 logger.warning("Async code raised an exception: %s", res.__class__.__name__)
                 continue
-            pair = res[0]
-            timeframe = res[1]
-            ticks = res[2]
+            # Deconstruct tuple (has 3 elements)
+            pair, timeframe, ticks = res
             # keeping last candle time as last refreshed time of the pair
             if ticks:
                 self._pairs_last_refresh_time[(pair, timeframe)] = ticks[-1][0] // 1000
@@ -757,7 +780,7 @@ class Exchange:
         interval_in_sec = timeframe_to_seconds(timeframe)
 
         return not ((self._pairs_last_refresh_time.get((pair, timeframe), 0)
-                     + interval_in_sec) >= arrow.utcnow().timestamp)
+                     + interval_in_sec) >= arrow.utcnow().int_timestamp)
 
     @retrier_async
     async def _async_get_candle_history(self, pair: str, timeframe: str,
@@ -973,7 +996,12 @@ class Exchange:
     @retrier
     def cancel_order(self, order_id: str, pair: str) -> Dict:
         if self._config['dry_run']:
-            return {}
+            order = self._dry_run_open_orders.get(order_id)
+            if order:
+                order.update({'status': 'canceled', 'filled': 0.0, 'remaining': order['amount']})
+                return order
+            else:
+                return {}
 
         try:
             return self._api.cancel_order(order_id, pair)
@@ -1022,7 +1050,7 @@ class Exchange:
 
         return order
 
-    @retrier(retries=5)
+    @retrier(retries=API_FETCH_ORDER_RETRY_COUNT)
     def fetch_order(self, order_id: str, pair: str) -> Dict:
         if self._config['dry_run']:
             try:
@@ -1051,6 +1079,27 @@ class Exchange:
     # Assign method to fetch_stoploss_order to allow easy overriding in other classes
     fetch_stoploss_order = fetch_order
 
+    def fetch_order_or_stoploss_order(self, order_id: str, pair: str,
+                                      stoploss_order: bool = False) -> Dict:
+        """
+        Simple wrapper calling either fetch_order or fetch_stoploss_order depending on
+        the stoploss_order parameter
+        :param stoploss_order: If true, uses fetch_stoploss_order, otherwise fetch_order.
+        """
+        if stoploss_order:
+            return self.fetch_stoploss_order(order_id, pair)
+        return self.fetch_order(order_id, pair)
+
+    @staticmethod
+    def get_next_limit_in_list(limit: int, limit_range: Optional[List[int]]):
+        """
+        Get next greater value in the list.
+        Used by fetch_l2_order_book if the api only supports a limited range
+        """
+        if not limit_range:
+            return limit
+        return min([x for x in limit_range if limit <= x] + [max(limit_range)])
+
     @retrier
     def fetch_l2_order_book(self, pair: str, limit: int = 100) -> dict:
         """
@@ -1059,9 +1108,10 @@ class Exchange:
         Returns a dict in the format
         {'asks': [price, volume], 'bids': [price, volume]}
         """
+        limit1 = self.get_next_limit_in_list(limit, self._ft_has['l2_limit_range'])
         try:
 
-            return self._api.fetch_l2_order_book(pair, limit)
+            return self._api.fetch_l2_order_book(pair, limit1)
         except ccxt.NotSupported as e:
             raise OperationalException(
                 f'Exchange {self._api.name} does not support fetching order book.'

freqtrade/exchange/ftx.py

@@ -4,11 +4,11 @@ from typing import Any, Dict
 
 import ccxt
 
-from freqtrade.exceptions import (DDosProtection, ExchangeError,
-                                  InvalidOrderException, OperationalException,
-                                  TemporaryError)
+from freqtrade.exceptions import (DDosProtection, InsufficientFundsError, InvalidOrderException,
+                                  OperationalException, TemporaryError)
 from freqtrade.exchange import Exchange
-from freqtrade.exchange.common import retrier
+from freqtrade.exchange.common import API_FETCH_ORDER_RETRY_COUNT, retrier
+
 
 logger = logging.getLogger(__name__)
 
@@ -71,7 +71,7 @@ class Ftx(Exchange):
                         'stop price: %s.', pair, stop_price)
             return order
         except ccxt.InsufficientFunds as e:
-            raise ExchangeError(
+            raise InsufficientFundsError(
                 f'Insufficient funds to create {ordertype} sell order on market {pair}. '
                 f'Tried to create stoploss with amount {amount} at stoploss {stop_price}. '
                 f'Message: {e}') from e
@@ -88,7 +88,7 @@ class Ftx(Exchange):
         except ccxt.BaseError as e:
             raise OperationalException(e) from e
 
-    @retrier(retries=5)
+    @retrier(retries=API_FETCH_ORDER_RETRY_COUNT)
     def fetch_stoploss_order(self, order_id: str, pair: str) -> Dict:
         if self._config['dry_run']:
             try:

freqtrade/exchange/kraken.py

@@ -4,12 +4,12 @@ from typing import Any, Dict
 
 import ccxt
 
-from freqtrade.exceptions import (DDosProtection, ExchangeError,
-                                  InvalidOrderException, OperationalException,
-                                  TemporaryError)
+from freqtrade.exceptions import (DDosProtection, InsufficientFundsError, InvalidOrderException,
+                                  OperationalException, TemporaryError)
 from freqtrade.exchange import Exchange
 from freqtrade.exchange.common import retrier
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -69,7 +69,8 @@ class Kraken(Exchange):
         Verify stop_loss against stoploss-order value (limit or price)
         Returns True if adjustment is necessary.
         """
-        return order['type'] == 'stop-loss' and stop_loss > float(order['price'])
+        return (order['type'] in ('stop-loss', 'stop-loss-limit')
+                and stop_loss > float(order['price']))
 
     @retrier(retries=0)
     def stoploss(self, pair: str, amount: float, stop_price: float, order_types: Dict) -> Dict:
@@ -77,8 +78,15 @@ class Kraken(Exchange):
         Creates a stoploss market order.
         Stoploss market orders is the only stoploss type supported by kraken.
         """
+        params = self._params.copy()
 
-        ordertype = "stop-loss"
+        if order_types.get('stoploss', 'market') == 'limit':
+            ordertype = "stop-loss-limit"
+            limit_price_pct = order_types.get('stoploss_on_exchange_limit_ratio', 0.99)
+            limit_rate = stop_price * limit_price_pct
+            params['price2'] = self.price_to_precision(pair, limit_rate)
+        else:
+            ordertype = "stop-loss"
 
         stop_price = self.price_to_precision(pair, stop_price)
 
@@ -88,8 +96,6 @@ class Kraken(Exchange):
             return dry_order
 
         try:
-            params = self._params.copy()
-
             amount = self.amount_to_precision(pair, amount)
 
             order = self._api.create_order(symbol=pair, type=ordertype, side='sell',
@@ -98,7 +104,7 @@ class Kraken(Exchange):
                         'stop price: %s.', pair, stop_price)
             return order
         except ccxt.InsufficientFunds as e:
-            raise ExchangeError(
+            raise InsufficientFundsError(
                 f'Insufficient funds to create {ordertype} sell order on market {pair}. '
                 f'Tried to create stoploss with amount {amount} at stoploss {stop_price}. '
                 f'Message: {e}') from e

freqtrade/freqtradebot.py

@@ -4,7 +4,7 @@ Freqtrade is the main module of this bot. It contains the class Freqtrade()
 import copy
 import logging
 import traceback
-from datetime import datetime
+from datetime import datetime, timezone
 from math import isclose
 from threading import Lock
 from typing import Any, Dict, List, Optional
@@ -12,17 +12,17 @@ from typing import Any, Dict, List, Optional
 import arrow
 from cachetools import TTLCache
 
-from freqtrade import __version__, constants, persistence
+from freqtrade import __version__, constants
 from freqtrade.configuration import validate_config_consistency
 from freqtrade.data.converter import order_book_to_dataframe
 from freqtrade.data.dataprovider import DataProvider
 from freqtrade.edge import Edge
-from freqtrade.exceptions import (DependencyException, ExchangeError,
+from freqtrade.exceptions import (DependencyException, ExchangeError, InsufficientFundsError,
                                   InvalidOrderException, PricingError)
-from freqtrade.exchange import timeframe_to_minutes, timeframe_to_next_date
+from freqtrade.exchange import timeframe_to_minutes
 from freqtrade.misc import safe_value_fallback, safe_value_fallback2
 from freqtrade.pairlist.pairlistmanager import PairListManager
-from freqtrade.persistence import Trade
+from freqtrade.persistence import Order, PairLocks, Trade, cleanup_db, init_db
 from freqtrade.resolvers import ExchangeResolver, StrategyResolver
 from freqtrade.rpc import RPCManager, RPCMessageType
 from freqtrade.state import State
@@ -30,6 +30,7 @@ from freqtrade.strategy.interface import IStrategy, SellType
 from freqtrade.strategy.strategy_wrapper import strategy_safe_wrapper
 from freqtrade.wallets import Wallets
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -57,8 +58,8 @@ class FreqtradeBot:
         # Cache values for 1800 to avoid frequent polling of the exchange for prices
         # Caching only applies to RPC methods, so prices for open trades are still
         # refreshed once every iteration.
-        self._sell_rate_cache = TTLCache(maxsize=100, ttl=1800)
-        self._buy_rate_cache = TTLCache(maxsize=100, ttl=1800)
+        self._sell_rate_cache: TTLCache = TTLCache(maxsize=100, ttl=1800)
+        self._buy_rate_cache: TTLCache = TTLCache(maxsize=100, ttl=1800)
 
         self.strategy: IStrategy = StrategyResolver.load_strategy(self.config)
 
@@ -67,10 +68,12 @@ class FreqtradeBot:
 
         self.exchange = ExchangeResolver.load_exchange(self.config['exchange']['name'], self.config)
 
-        persistence.init(self.config.get('db_url', None), clean_open_orders=self.config['dry_run'])
+        init_db(self.config.get('db_url', None), clean_open_orders=self.config['dry_run'])
 
         self.wallets = Wallets(self.config, self.exchange)
 
+        PairLocks.timeframe = self.config['timeframe']
+
         self.pairlists = PairListManager(self.exchange, self.config)
 
         self.dataprovider = DataProvider(self.config, self.exchange, self.pairlists)
@@ -122,7 +125,7 @@ class FreqtradeBot:
         self.check_for_open_trades()
 
         self.rpc.cleanup()
-        persistence.cleanup()
+        cleanup_db()
 
     def startup(self) -> None:
         """
@@ -134,6 +137,10 @@ class FreqtradeBot:
             # Adjust stoploss if it was changed
             Trade.stoploss_reinitialization(self.strategy.stoploss)
 
+        # Only update open orders on startup
+        # This will update the database after the initial migration
+        self.update_open_orders()
+
     def process(self) -> None:
         """
         Queries the persistence layer for open trades and handles them,
@@ -144,6 +151,8 @@ class FreqtradeBot:
         # Check whether markets have to be reloaded and reload them when it's needed
         self.exchange.reload_markets()
 
+        self.update_closed_trades_without_assigned_fees()
+
         # Query trades from persistence layer
         trades = Trade.get_open_trades()
 
@@ -227,6 +236,104 @@ class FreqtradeBot:
         open_trades = len(Trade.get_open_trades())
         return max(0, self.config['max_open_trades'] - open_trades)
 
+    def update_open_orders(self):
+        """
+        Updates open orders based on order list kept in the database.
+        Mainly updates the state of orders - but may also close trades
+        """
+        orders = Order.get_open_orders()
+        logger.info(f"Updating {len(orders)} open orders.")
+        for order in orders:
+            try:
+                fo = self.exchange.fetch_order_or_stoploss_order(order.order_id, order.ft_pair,
+                                                                 order.ft_order_side == 'stoploss')
+
+                self.update_trade_state(order.trade, order.order_id, fo)
+
+            except ExchangeError as e:
+                logger.warning(f"Error updating Order {order.order_id} due to {e}")
+
+    def update_closed_trades_without_assigned_fees(self):
+        """
+        Update closed trades without close fees assigned.
+        Only acts when Orders are in the database, otherwise the last orderid is unknown.
+        """
+        trades: List[Trade] = Trade.get_sold_trades_without_assigned_fees()
+        for trade in trades:
+
+            if not trade.is_open and not trade.fee_updated('sell'):
+                # Get sell fee
+                order = trade.select_order('sell', False)
+                if order:
+                    logger.info(f"Updating sell-fee on trade {trade} for order {order.order_id}.")
+                    self.update_trade_state(trade, order.order_id,
+                                            stoploss_order=order.ft_order_side == 'stoploss')
+
+        trades: List[Trade] = Trade.get_open_trades_without_assigned_fees()
+        for trade in trades:
+            if trade.is_open and not trade.fee_updated('buy'):
+                order = trade.select_order('buy', False)
+                if order:
+                    logger.info(f"Updating buy-fee on trade {trade} for order {order.order_id}.")
+                    self.update_trade_state(trade, order.order_id)
+
+    def handle_insufficient_funds(self, trade: Trade):
+        """
+        Determine if we ever opened a sell order for this trade.
+        If not, try update buy fees - otherwise "refind" the open order we obviously lost.
+        """
+        sell_order = trade.select_order('sell', None)
+        if sell_order:
+            self.refind_lost_order(trade)
+        else:
+            self.reupdate_buy_order_fees(trade)
+
+    def reupdate_buy_order_fees(self, trade: Trade):
+        """
+        Get buy order from database, and try to reupdate.
+        Handles trades where the initial fee-update did not work.
+        """
+        logger.info(f"Trying to reupdate buy fees for {trade}")
+        order = trade.select_order('buy', False)
+        if order:
+            logger.info(f"Updating buy-fee on trade {trade} for order {order.order_id}.")
+            self.update_trade_state(trade, order.order_id)
+
+    def refind_lost_order(self, trade):
+        """
+        Try refinding a lost trade.
+        Only used when InsufficientFunds appears on sell orders (stoploss or sell).
+        Tries to walk the stored orders and sell them off eventually.
+        """
+        logger.info(f"Trying to refind lost order for {trade}")
+        for order in trade.orders:
+            logger.info(f"Trying to refind {order}")
+            fo = None
+            if not order.ft_is_open:
+                logger.debug(f"Order {order} is no longer open.")
+                continue
+            if order.ft_order_side == 'buy':
+                # Skip buy side - this is handled by reupdate_buy_order_fees
+                continue
+            try:
+                fo = self.exchange.fetch_order_or_stoploss_order(order.order_id, order.ft_pair,
+                                                                 order.ft_order_side == 'stoploss')
+                if order.ft_order_side == 'stoploss':
+                    if fo and fo['status'] == 'open':
+                        # Assume this as the open stoploss order
+                        trade.stoploss_order_id = order.order_id
+                elif order.ft_order_side == 'sell':
+                    if fo and fo['status'] == 'open':
+                        # Assume this as the open order
+                        trade.open_order_id = order.order_id
+                if fo:
+                    logger.info(f"Found {order} for trade {trade}.jj")
+                    self.update_trade_state(trade, order.order_id, fo,
+                                            stoploss_order=order.ft_order_side == 'stoploss')
+
+            except ExchangeError:
+                logger.warning(f"Error updating {order.order_id}.")
+
 #
 # BUY / enter positions / open trades logic and methods
 #
@@ -240,27 +347,27 @@ class FreqtradeBot:
         whitelist = copy.deepcopy(self.active_pair_whitelist)
         if not whitelist:
             logger.info("Active pair whitelist is empty.")
-        else:
-            # Remove pairs for currently opened trades from the whitelist
-            for trade in Trade.get_open_trades():
-                if trade.pair in whitelist:
-                    whitelist.remove(trade.pair)
-                    logger.debug('Ignoring %s in pair whitelist', trade.pair)
+            return trades_created
+        # Remove pairs for currently opened trades from the whitelist
+        for trade in Trade.get_open_trades():
+            if trade.pair in whitelist:
+                whitelist.remove(trade.pair)
+                logger.debug('Ignoring %s in pair whitelist', trade.pair)
 
-            if not whitelist:
-                logger.info("No currency pair in active pair whitelist, "
-                            "but checking to sell open trades.")
-            else:
-                # Create entity and execute trade for each pair from whitelist
-                for pair in whitelist:
-                    try:
-                        trades_created += self.create_trade(pair)
-                    except DependencyException as exception:
-                        logger.warning('Unable to create trade for %s: %s', pair, exception)
+        if not whitelist:
+            logger.info("No currency pair in active pair whitelist, "
+                        "but checking to sell open trades.")
+            return trades_created
+        # Create entity and execute trade for each pair from whitelist
+        for pair in whitelist:
+            try:
+                trades_created += self.create_trade(pair)
+            except DependencyException as exception:
+                logger.warning('Unable to create trade for %s: %s', pair, exception)
 
-                if not trades_created:
-                    logger.debug("Found no buy signals for whitelisted currencies. "
-                                 "Trying again...")
+        if not trades_created:
+            logger.debug("Found no buy signals for whitelisted currencies. "
+                         "Trying again...")
 
         return trades_created
 
@@ -528,6 +635,7 @@ class FreqtradeBot:
         order = self.exchange.buy(pair=pair, ordertype=order_type,
                                   amount=amount, rate=buy_limit_requested,
                                   time_in_force=time_in_force)
+        order_obj = Order.parse_from_ccxt_object(order, pair, 'buy')
         order_id = order['id']
         order_status = order.get('status', None)
 
@@ -556,7 +664,6 @@ class FreqtradeBot:
                 stake_amount = order['cost']
                 amount = safe_value_fallback(order, 'filled', 'amount')
                 buy_limit_filled_price = safe_value_fallback(order, 'average', 'price')
-                order_id = None
 
         # in case of FOK the order may be filled immediately and fully
         elif order_status == 'closed':
@@ -581,10 +688,11 @@ class FreqtradeBot:
             strategy=self.strategy.get_strategy_name(),
             timeframe=timeframe_to_minutes(self.config['timeframe'])
         )
+        trade.orders.append(order_obj)
 
         # Update fees if order is closed
         if order_status == 'closed':
-            self.update_trade_state(trade, order)
+            self.update_trade_state(trade, order_id, order)
 
         Trade.session.add(trade)
         Trade.session.flush()
@@ -618,7 +726,7 @@ class FreqtradeBot:
         # Send the message
         self.rpc.send_msg(msg)
 
-    def _notify_buy_cancel(self, trade: Trade, order_type: str) -> None:
+    def _notify_buy_cancel(self, trade: Trade, order_type: str, reason: str) -> None:
         """
         Sends rpc notification when a buy cancel occured.
         """
@@ -637,6 +745,7 @@ class FreqtradeBot:
             'amount': trade.amount,
             'open_date': trade.open_date,
             'current_rate': current_rate,
+            'reason': reason,
         }
 
         # Send the message
@@ -782,8 +891,16 @@ class FreqtradeBot:
             stoploss_order = self.exchange.stoploss(pair=trade.pair, amount=trade.amount,
                                                     stop_price=stop_price,
                                                     order_types=self.strategy.order_types)
+
+            order_obj = Order.parse_from_ccxt_object(stoploss_order, trade.pair, 'stoploss')
+            trade.orders.append(order_obj)
             trade.stoploss_order_id = str(stoploss_order['id'])
             return True
+        except InsufficientFundsError as e:
+            logger.warning(f"Unable to place stoploss order {e}.")
+            # Try to figure out what went wrong
+            self.handle_insufficient_funds(trade)
+
         except InvalidOrderException as e:
             trade.stoploss_order_id = None
             logger.error(f'Unable to place a stoploss order on exchange. {e}')
@@ -813,13 +930,17 @@ class FreqtradeBot:
         except InvalidOrderException as exception:
             logger.warning('Unable to fetch stoploss order: %s', exception)
 
+        if stoploss_order:
+            trade.update_order(stoploss_order)
+
         # We check if stoploss order is fulfilled
         if stoploss_order and stoploss_order['status'] in ('closed', 'triggered'):
             trade.sell_reason = SellType.STOPLOSS_ON_EXCHANGE.value
-            self.update_trade_state(trade, stoploss_order, sl_order=True)
+            self.update_trade_state(trade, trade.stoploss_order_id, stoploss_order,
+                                    stoploss_order=True)
             # Lock pair for one candle to prevent immediate rebuys
-            self.strategy.lock_pair(trade.pair,
-                                    timeframe_to_next_date(self.config['timeframe']))
+            self.strategy.lock_pair(trade.pair, datetime.now(timezone.utc),
+                                    reason='Auto lock')
             self._notify_sell(trade, "stoploss")
             return True
 
@@ -835,7 +956,7 @@ class FreqtradeBot:
             stop_price = trade.open_rate * (1 + stoploss)
 
             if self.create_stoploss_order(trade=trade, stop_price=stop_price):
-                trade.stoploss_last_update = datetime.now()
+                trade.stoploss_last_update = datetime.utcnow()
                 return False
 
         # If stoploss order is canceled for some reason we add it
@@ -868,10 +989,11 @@ class FreqtradeBot:
             update_beat = self.strategy.order_types.get('stoploss_on_exchange_interval', 60)
             if (datetime.utcnow() - trade.stoploss_last_update).total_seconds() >= update_beat:
                 # cancelling the current stoploss on exchange first
-                logger.info('Trailing stoploss: cancelling current stoploss on exchange (id:{%s}) '
-                            'in order to add another one ...', order['id'])
+                logger.info(f"Cancelling current stoploss on exchange for pair {trade.pair} "
+                            f"(orderid:{order['id']}) in order to add another one ...")
                 try:
-                    self.exchange.cancel_stoploss_order(order['id'], trade.pair)
+                    co = self.exchange.cancel_stoploss_order(order['id'], trade.pair)
+                    trade.update_order(co)
                 except InvalidOrderException:
                     logger.exception(f"Could not cancel stoploss order {order['id']} "
                                      f"for pair {trade.pair}")
@@ -926,7 +1048,7 @@ class FreqtradeBot:
                 logger.info('Cannot query order for %s due to %s', trade, traceback.format_exc())
                 continue
 
-            fully_cancelled = self.update_trade_state(trade, order)
+            fully_cancelled = self.update_trade_state(trade, trade.open_order_id, order)
 
             if (order['side'] == 'buy' and (order['status'] == 'open' or fully_cancelled) and (
                     fully_cancelled
@@ -974,7 +1096,6 @@ class FreqtradeBot:
 
         # Cancelled orders may have the status of 'canceled' or 'closed'
         if order['status'] not in ('canceled', 'closed'):
-            reason = constants.CANCEL_REASON['TIMEOUT']
             corder = self.exchange.cancel_order_with_result(trade.open_order_id, trade.pair,
                                                             trade.amount)
             # Avoid race condition where the order could not be cancelled coz its already filled.
@@ -992,13 +1113,12 @@ class FreqtradeBot:
 
         # Using filled to determine the filled amount
         filled_amount = safe_value_fallback2(corder, order, 'filled', 'filled')
-
         if isclose(filled_amount, 0.0, abs_tol=constants.MATH_CLOSE_PREC):
             logger.info('Buy order fully cancelled. Removing %s from database.', trade)
             # if trade is not partially completed, just delete the trade
-            Trade.session.delete(trade)
-            Trade.session.flush()
+            trade.delete()
             was_trade_fully_canceled = True
+            reason += f", {constants.CANCEL_REASON['FULLY_CANCELLED']}"
         else:
             # if trade is partially complete, edit the stake details for the trade
             # and close the order
@@ -1007,17 +1127,15 @@ class FreqtradeBot:
             # we need to fall back to the values from order if corder does not contain these keys.
             trade.amount = filled_amount
             trade.stake_amount = trade.amount * trade.open_rate
-            self.update_trade_state(trade, corder, trade.amount)
+            self.update_trade_state(trade, trade.open_order_id, corder)
 
             trade.open_order_id = None
             logger.info('Partial buy order timeout for %s.', trade)
-            self.rpc.send_msg({
-                'type': RPCMessageType.STATUS_NOTIFICATION,
-                'status': f'Remaining buy order for {trade.pair} cancelled due to timeout'
-            })
+            reason += f", {constants.CANCEL_REASON['PARTIALLY_FILLED']}"
 
         self.wallets.update()
-        self._notify_buy_cancel(trade, order_type=self.strategy.order_types['buy'])
+        self._notify_buy_cancel(trade, order_type=self.strategy.order_types['buy'],
+                                reason=reason)
         return was_trade_fully_canceled
 
     def handle_cancel_sell(self, trade: Trade, order: Dict, reason: str) -> str:
@@ -1048,7 +1166,7 @@ class FreqtradeBot:
             trade.open_order_id = None
         else:
             # TODO: figure out how to handle partially complete sell orders
-            reason = constants.CANCEL_REASON['PARTIALLY_FILLED']
+            reason = constants.CANCEL_REASON['PARTIALLY_FILLED_KEEP_OPEN']
 
         self.wallets.update()
         self._notify_sell_cancel(
@@ -1123,23 +1241,33 @@ class FreqtradeBot:
             logger.info(f"User requested abortion of selling {trade.pair}")
             return False
 
-        # Execute sell and update trade record
-        order = self.exchange.sell(pair=str(trade.pair),
-                                   ordertype=order_type,
-                                   amount=amount, rate=limit,
-                                   time_in_force=time_in_force
-                                   )
+        try:
+            # Execute sell and update trade record
+            order = self.exchange.sell(pair=trade.pair,
+                                       ordertype=order_type,
+                                       amount=amount, rate=limit,
+                                       time_in_force=time_in_force
+                                       )
+        except InsufficientFundsError as e:
+            logger.warning(f"Unable to place order {e}.")
+            # Try to figure out what went wrong
+            self.handle_insufficient_funds(trade)
+            return False
+
+        order_obj = Order.parse_from_ccxt_object(order, trade.pair, 'sell')
+        trade.orders.append(order_obj)
 
         trade.open_order_id = order['id']
         trade.close_rate_requested = limit
         trade.sell_reason = sell_reason.value
         # In case of market sell orders the order can be closed immediately
         if order.get('status', 'unknown') == 'closed':
-            self.update_trade_state(trade, order)
+            self.update_trade_state(trade, trade.open_order_id, order)
         Trade.session.flush()
 
         # Lock pair for one candle to prevent immediate rebuys
-        self.strategy.lock_pair(trade.pair, timeframe_to_next_date(self.config['timeframe']))
+        self.strategy.lock_pair(trade.pair, datetime.now(timezone.utc),
+                                reason='Auto lock')
 
         self._notify_sell(trade, order_type)
 
@@ -1232,30 +1360,35 @@ class FreqtradeBot:
 # Common update trade state methods
 #
 
-    def update_trade_state(self, trade: Trade, action_order: dict = None,
-                           order_amount: float = None, sl_order: bool = False) -> bool:
+    def update_trade_state(self, trade: Trade, order_id: str, action_order: Dict[str, Any] = None,
+                           stoploss_order: bool = False) -> bool:
         """
         Checks trades with open orders and updates the amount if necessary
         Handles closing both buy and sell orders.
+        :param trade: Trade object of the trade we're analyzing
+        :param order_id: Order-id of the order we're analyzing
+        :param action_order: Already aquired order object
         :return: True if order has been cancelled without being filled partially, False otherwise
         """
-        # Get order details for actual price per unit
-        if trade.open_order_id:
-            order_id = trade.open_order_id
-        elif trade.stoploss_order_id and sl_order:
-            order_id = trade.stoploss_order_id
-        else:
+        if not order_id:
+            logger.warning(f'Orderid for trade {trade} is empty.')
             return False
+
         # Update trade with order values
         logger.info('Found open order for %s', trade)
         try:
-            order = action_order or self.exchange.fetch_order(order_id, trade.pair)
+            order = action_order or self.exchange.fetch_order_or_stoploss_order(order_id,
+                                                                                trade.pair,
+                                                                                stoploss_order)
         except InvalidOrderException as exception:
             logger.warning('Unable to fetch order %s: %s', order_id, exception)
             return False
+
+        trade.update_order(order)
+
         # Try update amount (binance-fix)
         try:
-            new_amount = self.get_real_amount(trade, order, order_amount)
+            new_amount = self.get_real_amount(trade, order)
             if not isclose(safe_value_fallback(order, 'filled', 'amount'), new_amount,
                            abs_tol=constants.MATH_CLOSE_PREC):
                 order['amount'] = new_amount
@@ -1293,7 +1426,7 @@ class FreqtradeBot:
             return real_amount
         return amount
 
-    def get_real_amount(self, trade: Trade, order: Dict, order_amount: float = None) -> float:
+    def get_real_amount(self, trade: Trade, order: Dict) -> float:
         """
         Detect and update trade fee.
         Calls trade.update_fee() uppon correct detection.
@@ -1302,8 +1435,7 @@ class FreqtradeBot:
         :return: identical (or new) amount for the trade
         """
         # Init variables
-        if order_amount is None:
-            order_amount = safe_value_fallback(order, 'filled', 'amount')
+        order_amount = safe_value_fallback(order, 'filled', 'amount')
         # Only run for closed orders
         if trade.fee_updated(order.get('side', '')) or order['status'] == 'open':
             return order_amount
@@ -1327,7 +1459,7 @@ class FreqtradeBot:
         """
         fee-detection fallback to Trades. Parses result of fetch_my_trades to get correct fee.
         """
-        trades = self.exchange.get_trades_for_order(trade.open_order_id, trade.pair,
+        trades = self.exchange.get_trades_for_order(order['id'], trade.pair,
                                                     trade.open_date)
 
         if len(trades) == 0:

freqtrade/loggers.py

@@ -1,12 +1,12 @@
 import logging
 import sys
 from logging import Formatter
-from logging.handlers import (BufferingHandler, RotatingFileHandler,
-                              SysLogHandler)
+from logging.handlers import BufferingHandler, RotatingFileHandler, SysLogHandler
 from typing import Any, Dict
 
 from freqtrade.exceptions import OperationalException
 
+
 logger = logging.getLogger(__name__)
 LOGFORMAT = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
 
@@ -37,6 +37,13 @@ def _set_loggers(verbosity: int = 0, api_verbosity: str = 'info') -> None:
     )
 
 
+def get_existing_handlers(handlertype):
+    """
+    Returns Existing handler or None (if the handler has not yet been added to the root handlers).
+    """
+    return next((h for h in logging.root.handlers if isinstance(h, handlertype)), None)
+
+
 def setup_logging_pre() -> None:
     """
     Early setup for logging.
@@ -71,18 +78,24 @@ def setup_logging(config: Dict[str, Any]) -> None:
             # config['logfilename']), which defaults to '/dev/log', applicable for most
             # of the systems.
             address = (s[1], int(s[2])) if len(s) > 2 else s[1] if len(s) > 1 else '/dev/log'
-            handler = SysLogHandler(address=address)
+            handler_sl = get_existing_handlers(SysLogHandler)
+            if handler_sl:
+                logging.root.removeHandler(handler_sl)
+            handler_sl = SysLogHandler(address=address)
             # No datetime field for logging into syslog, to allow syslog
             # to perform reduction of repeating messages if this is set in the
             # syslog config. The messages should be equal for this.
-            handler.setFormatter(Formatter('%(name)s - %(levelname)s - %(message)s'))
-            logging.root.addHandler(handler)
+            handler_sl.setFormatter(Formatter('%(name)s - %(levelname)s - %(message)s'))
+            logging.root.addHandler(handler_sl)
         elif s[0] == 'journald':
             try:
                 from systemd.journal import JournaldLogHandler
             except ImportError:
                 raise OperationalException("You need the systemd python package be installed in "
                                            "order to use logging to journald.")
+            handler_jd = get_existing_handlers(JournaldLogHandler)
+            if handler_jd:
+                logging.root.removeHandler(handler_jd)
             handler_jd = JournaldLogHandler()
             # No datetime field for logging into journald, to allow syslog
             # to perform reduction of repeating messages if this is set in the
@@ -90,6 +103,9 @@ def setup_logging(config: Dict[str, Any]) -> None:
             handler_jd.setFormatter(Formatter('%(name)s - %(levelname)s - %(message)s'))
             logging.root.addHandler(handler_jd)
         else:
+            handler_rf = get_existing_handlers(RotatingFileHandler)
+            if handler_rf:
+                logging.root.removeHandler(handler_rf)
             handler_rf = RotatingFileHandler(logfile,
                                              maxBytes=1024 * 1024 * 10,  # 10Mb
                                              backupCount=10)

freqtrade/main.py

@@ -7,6 +7,7 @@ import logging
 import sys
 from typing import Any, List
 
+
 # check min. python version
 if sys.version_info < (3, 6):
     sys.exit("Freqtrade requires Python version >= 3.6")

freqtrade/misc.py

@@ -12,6 +12,7 @@ from typing.io import IO
 import numpy as np
 import rapidjson
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -41,7 +42,7 @@ def datesarray_to_datetimearray(dates: np.ndarray) -> np.ndarray:
     return dates.dt.to_pydatetime()
 
 
-def file_dump_json(filename: Path, data: Any, is_zip: bool = False) -> None:
+def file_dump_json(filename: Path, data: Any, is_zip: bool = False, log: bool = True) -> None:
     """
     Dump JSON data into a file
     :param filename: file to create
@@ -52,12 +53,14 @@ def file_dump_json(filename: Path, data: Any, is_zip: bool = False) -> None:
     if is_zip:
         if filename.suffix != '.gz':
             filename = filename.with_suffix('.gz')
-        logger.info(f'dumping json to "{filename}"')
+        if log:
+            logger.info(f'dumping json to "{filename}"')
 
-        with gzip.open(filename, 'w') as fp:
-            rapidjson.dump(data, fp, default=str, number_mode=rapidjson.NM_NATIVE)
+        with gzip.open(filename, 'w') as fpz:
+            rapidjson.dump(data, fpz, default=str, number_mode=rapidjson.NM_NATIVE)
     else:
-        logger.info(f'dumping json to "{filename}"')
+        if log:
+            logger.info(f'dumping json to "{filename}"')
         with open(filename, 'w') as fp:
             rapidjson.dump(data, fp, default=str, number_mode=rapidjson.NM_NATIVE)
 

freqtrade/optimize/backtesting.py

@@ -4,31 +4,39 @@
 This module contains the backtesting logic
 """
 import logging
+from collections import defaultdict
 from copy import deepcopy
 from datetime import datetime, timedelta
 from typing import Any, Dict, List, NamedTuple, Optional, Tuple
 
-import arrow
 from pandas import DataFrame
 
-from freqtrade.configuration import (TimeRange, remove_credentials,
-                                     validate_config_consistency)
+from freqtrade.configuration import TimeRange, remove_credentials, validate_config_consistency
 from freqtrade.constants import DATETIME_PRINT_FORMAT
 from freqtrade.data import history
 from freqtrade.data.converter import trim_dataframe
 from freqtrade.data.dataprovider import DataProvider
 from freqtrade.exceptions import OperationalException
 from freqtrade.exchange import timeframe_to_minutes, timeframe_to_seconds
-from freqtrade.optimize.optimize_reports import (generate_backtest_stats,
-                                                 show_backtest_results,
+from freqtrade.optimize.optimize_reports import (generate_backtest_stats, show_backtest_results,
                                                  store_backtest_stats)
 from freqtrade.pairlist.pairlistmanager import PairListManager
 from freqtrade.persistence import Trade
 from freqtrade.resolvers import ExchangeResolver, StrategyResolver
 from freqtrade.strategy.interface import IStrategy, SellCheckTuple, SellType
 
+
 logger = logging.getLogger(__name__)
 
+# Indexes for backtest tuples
+DATE_IDX = 0
+BUY_IDX = 1
+OPEN_IDX = 2
+CLOSE_IDX = 3
+SELL_IDX = 4
+LOW_IDX = 5
+HIGH_IDX = 6
+
 
 class BacktestResult(NamedTuple):
     """
@@ -96,6 +104,7 @@ class Backtesting:
                 "PrecisionFilter not allowed for backtesting multiple strategies."
             )
 
+        dataprovider.add_pairlisthandler(self.pairlists)
         self.pairlists.refresh_pairlist()
 
         if len(self.pairlists.whitelist) == 0:
@@ -115,7 +124,7 @@ class Backtesting:
         """
         Load strategy into backtesting
         """
-        self.strategy = strategy
+        self.strategy: IStrategy = strategy
         # Set stoploss_on_exchange to false for backtesting,
         # since a "perfect" stoploss-sell is assumed anyway
         # And the regular "stoploss" function would not apply to that case
@@ -147,12 +156,14 @@ class Backtesting:
 
         return data, timerange
 
-    def _get_ohlcv_as_lists(self, processed: Dict) -> Dict[str, DataFrame]:
+    def _get_ohlcv_as_lists(self, processed: Dict[str, DataFrame]) -> Dict[str, Tuple]:
         """
         Helper function to convert a processed dataframes into lists for performance reasons.
 
         Used by backtest() - so keep this optimized for performance.
         """
+        # Every change to this headers list must evaluate further usages of the resulting tuple
+        # and eventually change the constants for indexes at the top
         headers = ['date', 'buy', 'open', 'close', 'sell', 'low', 'high']
         data: Dict = {}
         # Create dict with data
@@ -172,10 +183,10 @@ class Backtesting:
 
             # Convert from Pandas to list for performance reasons
             # (Looping Pandas is slow.)
-            data[pair] = [x for x in df_analyzed.itertuples()]
+            data[pair] = [x for x in df_analyzed.itertuples(index=False, name=None)]
         return data
 
-    def _get_close_rate(self, sell_row, trade: Trade, sell: SellCheckTuple,
+    def _get_close_rate(self, sell_row: Tuple, trade: Trade, sell: SellCheckTuple,
                         trade_dur: int) -> float:
         """
         Get close rate for backtesting result
@@ -186,12 +197,12 @@ class Backtesting:
             return trade.stop_loss
         elif sell.sell_type == (SellType.ROI):
             roi_entry, roi = self.strategy.min_roi_reached_entry(trade_dur)
-            if roi is not None:
+            if roi is not None and roi_entry is not None:
                 if roi == -1 and roi_entry % self.timeframe_min == 0:
                     # When forceselling with ROI=-1, the roi time will always be equal to trade_dur.
                     # If that entry is a multiple of the timeframe (so on candle open)
                     # - we'll use open instead of close
-                    return sell_row.open
+                    return sell_row[OPEN_IDX]
 
                 # - (Expected abs profit + open_rate + open_fee) / (fee_close -1)
                 close_rate = - (trade.open_rate * roi + trade.open_rate *
@@ -199,91 +210,79 @@ class Backtesting:
 
                 if (trade_dur > 0 and trade_dur == roi_entry
                         and roi_entry % self.timeframe_min == 0
-                        and sell_row.open > close_rate):
+                        and sell_row[OPEN_IDX] > close_rate):
                     # new ROI entry came into effect.
                     # use Open rate if open_rate > calculated sell rate
-                    return sell_row.open
+                    return sell_row[OPEN_IDX]
 
                 # Use the maximum between close_rate and low as we
                 # cannot sell outside of a candle.
                 # Applies when a new ROI setting comes in place and the whole candle is above that.
-                return max(close_rate, sell_row.low)
+                return max(close_rate, sell_row[LOW_IDX])
 
             else:
                 # This should not be reached...
-                return sell_row.open
+                return sell_row[OPEN_IDX]
         else:
-            return sell_row.open
+            return sell_row[OPEN_IDX]
 
-    def _get_sell_trade_entry(
-            self, pair: str, buy_row: DataFrame,
-            partial_ohlcv: List, trade_count_lock: Dict,
-            stake_amount: float, max_open_trades: int) -> Optional[BacktestResult]:
+    def _get_sell_trade_entry(self, trade: Trade, sell_row: Tuple) -> Optional[BacktestResult]:
 
-        trade = Trade(
-            pair=pair,
-            open_rate=buy_row.open,
-            open_date=buy_row.date,
-            stake_amount=stake_amount,
-            amount=round(stake_amount / buy_row.open, 8),
-            fee_open=self.fee,
-            fee_close=self.fee,
-            is_open=True,
-        )
-        logger.debug(f"{pair} - Backtesting emulates creation of new trade: {trade}.")
-        # calculate win/lose forwards from buy point
-        for sell_row in partial_ohlcv:
-            if max_open_trades > 0:
-                # Increase trade_count_lock for every iteration
-                trade_count_lock[sell_row.date] = trade_count_lock.get(sell_row.date, 0) + 1
+        sell = self.strategy.should_sell(trade, sell_row[OPEN_IDX], sell_row[DATE_IDX],
+                                         sell_row[BUY_IDX], sell_row[SELL_IDX],
+                                         low=sell_row[LOW_IDX], high=sell_row[HIGH_IDX])
+        if sell.sell_flag:
+            trade_dur = int((sell_row[DATE_IDX] - trade.open_date).total_seconds() // 60)
+            closerate = self._get_close_rate(sell_row, trade, sell, trade_dur)
 
-            sell = self.strategy.should_sell(trade, sell_row.open, sell_row.date, sell_row.buy,
-                                             sell_row.sell, low=sell_row.low, high=sell_row.high)
-            if sell.sell_flag:
-                trade_dur = int((sell_row.date - buy_row.date).total_seconds() // 60)
-                closerate = self._get_close_rate(sell_row, trade, sell, trade_dur)
-
-                return BacktestResult(pair=pair,
-                                      profit_percent=trade.calc_profit_ratio(rate=closerate),
-                                      profit_abs=trade.calc_profit(rate=closerate),
-                                      open_date=buy_row.date,
-                                      open_rate=buy_row.open,
-                                      open_fee=self.fee,
-                                      close_date=sell_row.date,
-                                      close_rate=closerate,
-                                      close_fee=self.fee,
-                                      amount=trade.amount,
-                                      trade_duration=trade_dur,
-                                      open_at_end=False,
-                                      sell_reason=sell.sell_type
-                                      )
-        if partial_ohlcv:
-            # no sell condition found - trade stil open at end of backtest period
-            sell_row = partial_ohlcv[-1]
-            bt_res = BacktestResult(pair=pair,
-                                    profit_percent=trade.calc_profit_ratio(rate=sell_row.open),
-                                    profit_abs=trade.calc_profit(rate=sell_row.open),
-                                    open_date=buy_row.date,
-                                    open_rate=buy_row.open,
-                                    open_fee=self.fee,
-                                    close_date=sell_row.date,
-                                    close_rate=sell_row.open,
-                                    close_fee=self.fee,
-                                    amount=trade.amount,
-                                    trade_duration=int((
-                                        sell_row.date - buy_row.date).total_seconds() // 60),
-                                    open_at_end=True,
-                                    sell_reason=SellType.FORCE_SELL
-                                    )
-            logger.debug(f"{pair} - Force selling still open trade, "
-                         f"profit percent: {bt_res.profit_percent}, "
-                         f"profit abs: {bt_res.profit_abs}")
-
-            return bt_res
+            return BacktestResult(pair=trade.pair,
+                                  profit_percent=trade.calc_profit_ratio(rate=closerate),
+                                  profit_abs=trade.calc_profit(rate=closerate),
+                                  open_date=trade.open_date,
+                                  open_rate=trade.open_rate,
+                                  open_fee=self.fee,
+                                  close_date=sell_row[DATE_IDX],
+                                  close_rate=closerate,
+                                  close_fee=self.fee,
+                                  amount=trade.amount,
+                                  trade_duration=trade_dur,
+                                  open_at_end=False,
+                                  sell_reason=sell.sell_type
+                                  )
         return None
 
+    def handle_left_open(self, open_trades: Dict[str, List[Trade]],
+                         data: Dict[str, List[Tuple]]) -> List[BacktestResult]:
+        """
+        Handling of left open trades at the end of backtesting
+        """
+        trades = []
+        for pair in open_trades.keys():
+            if len(open_trades[pair]) > 0:
+                for trade in open_trades[pair]:
+                    sell_row = data[pair][-1]
+                    trade_entry = BacktestResult(pair=trade.pair,
+                                                 profit_percent=trade.calc_profit_ratio(
+                                                     rate=sell_row[OPEN_IDX]),
+                                                 profit_abs=trade.calc_profit(sell_row[OPEN_IDX]),
+                                                 open_date=trade.open_date,
+                                                 open_rate=trade.open_rate,
+                                                 open_fee=self.fee,
+                                                 close_date=sell_row[DATE_IDX],
+                                                 close_rate=sell_row[OPEN_IDX],
+                                                 close_fee=self.fee,
+                                                 amount=trade.amount,
+                                                 trade_duration=int((
+                                                     sell_row[DATE_IDX] - trade.open_date
+                                                 ).total_seconds() // 60),
+                                                 open_at_end=True,
+                                                 sell_reason=SellType.FORCE_SELL
+                                                 )
+                    trades.append(trade_entry)
+        return trades
+
     def backtest(self, processed: Dict, stake_amount: float,
-                 start_date: arrow.Arrow, end_date: arrow.Arrow,
+                 start_date: datetime, end_date: datetime,
                  max_open_trades: int = 0, position_stacking: bool = False) -> DataFrame:
         """
         Implement backtesting functionality
@@ -305,19 +304,21 @@ class Backtesting:
                      f"max_open_trades: {max_open_trades}, position_stacking: {position_stacking}"
                      )
         trades = []
-        trade_count_lock: Dict = {}
 
         # Use dict of lists with data for performance
         # (looping lists is a lot faster than pandas DataFrames)
         data: Dict = self._get_ohlcv_as_lists(processed)
 
-        lock_pair_until: Dict = {}
         # Indexes per pair, so some pairs are allowed to have a missing start.
         indexes: Dict = {}
         tmp = start_date + timedelta(minutes=self.timeframe_min)
 
+        open_trades: Dict[str, List] = defaultdict(list)
+        open_trade_count = 0
+
         # Loop timerange and get candle for each pair at that point in time
-        while tmp < end_date:
+        while tmp <= end_date:
+            open_trade_count_start = open_trade_count
 
             for i, pair in enumerate(data):
                 if pair not in indexes:
@@ -331,42 +332,52 @@ class Backtesting:
                     continue
 
                 # Waits until the time-counter reaches the start of the data for this pair.
-                if row.date > tmp.datetime:
+                if row[DATE_IDX] > tmp:
                     continue
-
                 indexes[pair] += 1
 
-                if row.buy == 0 or row.sell == 1:
-                    continue  # skip rows where no buy signal or that would immediately sell off
+                # without positionstacking, we can only have one open trade per pair.
+                # max_open_trades must be respected
+                # don't open on the last row
+                if ((position_stacking or len(open_trades[pair]) == 0)
+                        and (max_open_trades <= 0 or open_trade_count_start < max_open_trades)
+                        and tmp != end_date
+                        and row[BUY_IDX] == 1 and row[SELL_IDX] != 1):
+                    # Enter trade
+                    trade = Trade(
+                        pair=pair,
+                        open_rate=row[OPEN_IDX],
+                        open_date=row[DATE_IDX],
+                        stake_amount=stake_amount,
+                        amount=round(stake_amount / row[OPEN_IDX], 8),
+                        fee_open=self.fee,
+                        fee_close=self.fee,
+                        is_open=True,
+                    )
+                    # TODO: hacky workaround to avoid opening > max_open_trades
+                    # This emulates previous behaviour - not sure if this is correct
+                    # Prevents buying if the trade-slot was freed in this candle
+                    open_trade_count_start += 1
+                    open_trade_count += 1
+                    # logger.debug(f"{pair} - Backtesting emulates creation of new trade: {trade}.")
+                    open_trades[pair].append(trade)
 
-                if (not position_stacking and pair in lock_pair_until
-                        and row.date <= lock_pair_until[pair]):
-                    # without positionstacking, we can only have one open trade per pair.
-                    continue
-
-                if max_open_trades > 0:
-                    # Check if max_open_trades has already been reached for the given date
-                    if not trade_count_lock.get(row.date, 0) < max_open_trades:
-                        continue
-                    trade_count_lock[row.date] = trade_count_lock.get(row.date, 0) + 1
-
-                # since indexes has been incremented before, we need to go one step back to
-                # also check the buying candle for sell conditions.
-                trade_entry = self._get_sell_trade_entry(pair, row, data[pair][indexes[pair]-1:],
-                                                         trade_count_lock, stake_amount,
-                                                         max_open_trades)
-
-                if trade_entry:
-                    logger.debug(f"{pair} - Locking pair till "
-                                 f"close_date={trade_entry.close_date}")
-                    lock_pair_until[pair] = trade_entry.close_date
-                    trades.append(trade_entry)
-                else:
-                    # Set lock_pair_until to end of testing period if trade could not be closed
-                    lock_pair_until[pair] = end_date.datetime
+                for trade in open_trades[pair]:
+                    # since indexes has been incremented before, we need to go one step back to
+                    # also check the buying candle for sell conditions.
+                    trade_entry = self._get_sell_trade_entry(trade, row)
+                    # Sell occured
+                    if trade_entry:
+                        # logger.debug(f"{pair} - Backtesting sell {trade}")
+                        open_trade_count -= 1
+                        open_trades[pair].remove(trade)
+                        trades.append(trade_entry)
 
             # Move time one configured time_interval ahead.
             tmp += timedelta(minutes=self.timeframe_min)
+
+        trades += self.handle_left_open(open_trades, data=data)
+
         return DataFrame.from_records(trades, columns=BacktestResult._fields)
 
     def start(self) -> None:
@@ -379,12 +390,6 @@ class Backtesting:
         logger.info('Using stake_currency: %s ...', self.config['stake_currency'])
         logger.info('Using stake_amount: %s ...', self.config['stake_amount'])
 
-        # Use max_open_trades in backtesting, except --disable-max-market-positions is set
-        if self.config.get('use_max_market_positions', True):
-            max_open_trades = self.config['max_open_trades']
-        else:
-            logger.info('Ignoring max_open_trades (--disable-max-market-positions was used) ...')
-            max_open_trades = 0
         position_stacking = self.config.get('position_stacking', False)
 
         data, timerange = self.load_bt_data()
@@ -394,6 +399,15 @@ class Backtesting:
             logger.info("Running backtesting for Strategy %s", strat.get_strategy_name())
             self._set_strategy(strat)
 
+            # Use max_open_trades in backtesting, except --disable-max-market-positions is set
+            if self.config.get('use_max_market_positions', True):
+                # Must come from strategy config, as the strategy may modify this setting.
+                max_open_trades = self.strategy.config['max_open_trades']
+            else:
+                logger.info(
+                    'Ignoring max_open_trades (--disable-max-market-positions was used) ...')
+                max_open_trades = 0
+
             # need to reprocess data every time to populate signals
             preprocessed = self.strategy.ohlcvdata_to_dataframe(data)
 
@@ -406,17 +420,21 @@ class Backtesting:
                         f'up to {max_date.strftime(DATETIME_PRINT_FORMAT)} '
                         f'({(max_date - min_date).days} days)..')
             # Execute backtest and print results
-            all_results[self.strategy.get_strategy_name()] = self.backtest(
+            results = self.backtest(
                 processed=preprocessed,
                 stake_amount=self.config['stake_amount'],
-                start_date=min_date,
-                end_date=max_date,
+                start_date=min_date.datetime,
+                end_date=max_date.datetime,
                 max_open_trades=max_open_trades,
                 position_stacking=position_stacking,
             )
+            all_results[self.strategy.get_strategy_name()] = {
+                'results': results,
+                'config': self.strategy.config,
+            }
+
+        stats = generate_backtest_stats(data, all_results, min_date=min_date, max_date=max_date)
 
-        stats = generate_backtest_stats(self.config, data, all_results,
-                                        min_date=min_date, max_date=max_date)
         if self.config.get('export', False):
             store_backtest_stats(self.config['exportfilename'], stats)
 

freqtrade/optimize/default_hyperopt_loss.py

@@ -1,5 +1,5 @@
 """
-DefaultHyperOptLoss
+ShortTradeDurHyperOptLoss
 This module defines the default HyperoptLoss class which is being used for
 Hyperoptimization.
 """
@@ -26,7 +26,7 @@ EXPECTED_MAX_PROFIT = 3.0
 MAX_ACCEPTED_TRADE_DURATION = 300
 
 
-class DefaultHyperOptLoss(IHyperOptLoss):
+class ShortTradeDurHyperOptLoss(IHyperOptLoss):
     """
     Defines the default loss function for hyperopt
     """
@@ -50,3 +50,7 @@ class DefaultHyperOptLoss(IHyperOptLoss):
         duration_loss = 0.4 * min(trade_duration / MAX_ACCEPTED_TRADE_DURATION, 1)
         result = trade_loss + profit_loss + duration_loss
         return result
+
+
+# Create an alias for This to allow the legacy Method to work as well.
+DefaultHyperOptLoss = ShortTradeDurHyperOptLoss