Merge pull request #2205 from freqtrade/master_add_2199

Release 2019.8-1 - hotfix data-dir not including exchange

.dependabot/config.yml

@@ -0,0 +1,17 @@
+version: 1
+
+update_configs:
+  - package_manager: "python"
+    directory: "/"
+    update_schedule: "weekly"
+    allowed_updates:
+    - match:
+        update_type: "all"
+    target_branch: "develop"
+
+  - package_manager: "docker"
+    directory: "/"
+    update_schedule: "daily"
+    allowed_updates:
+    - match:
+        update_type: "all"

.github/ISSUE_TEMPLATE.md

@@ -5,6 +5,7 @@ If it hasn't been reported, please create a new issue.
 
 ## Step 2: Describe your environment
 
+  * Operating system: ____
   * Python Version: _____ (`python -V`)
   * CCXT version: _____ (`pip freeze | grep ccxt`)
   * Branch: Master | Develop

.gitignore

@@ -6,7 +6,10 @@ config*.json
 .hyperopt
 logfile.txt
 hyperopt_trials.pickle
-user_data/
+user_data/*
+!user_data/notebooks
+user_data/notebooks/*
+!user_data/notebooks/*example.ipynb
 freqtrade-plot.html
 freqtrade-profit-plot.html
 
@@ -80,7 +83,7 @@ docs/_build/
 target/
 
 # Jupyter Notebook
-.ipynb_checkpoints
+*.ipynb_checkpoints
 
 # pyenv
 .python-version
@@ -92,3 +95,6 @@ target/
 
 .pytest_cache/
 .mypy_cache/
+
+#exceptions
+!*.gitkeep

.pyup.yml

@@ -1,32 +0,0 @@
-# autogenerated pyup.io config file
-# see https://pyup.io/docs/configuration/ for all available options
-
-# configure updates globally
-# default: all
-# allowed: all, insecure, False
-update: all
-
-# configure dependency pinning globally
-# default: True
-# allowed: True, False
-pin: True
-
-schedule: "every day"
-
-
-search: False
-# Specify requirement files by hand, default is empty
-# default: empty
-# allowed: list
-requirements:
-  - requirements.txt
-  - requirements-dev.txt
-
-
-# configure the branch prefix the bot is using
-# default: pyup-
-branch_prefix: pyup/
-
-# allow to close stale PRs
-# default: True
-close_prs: True

.readthedocs.yml

@@ -0,0 +1,8 @@
+# .readthedocs.yml
+
+build:
+  image: latest
+
+python:
+  version: 3.6
+  setup_py_install: false

.travis.yml

@@ -1,7 +1,7 @@
 sudo: true
 os:
 - linux
-dist: trusty
+dist: xenial
 language: python
 python:
 - 3.6
@@ -10,36 +10,38 @@ services:
 env:
   global:
     - IMAGE_NAME=freqtradeorg/freqtrade
-addons:
-  apt:
-    packages:
-    - libelf-dev
-    - libdw-dev
-    - binutils-dev
 install:
-- ./build_helpers/install_ta-lib.sh
+- cd build_helpers && ./install_ta-lib.sh ${HOME}/dependencies/; cd ..
-- export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH
+- export LD_LIBRARY_PATH=${HOME}/dependencies/lib:$LD_LIBRARY_PATH
-- pip install --upgrade flake8 coveralls pytest-random-order pytest-asyncio mypy
+- export TA_LIBRARY_PATH=${HOME}/dependencies/lib
+- export TA_INCLUDE_PATH=${HOME}/dependencies/lib/include
 - pip install -r requirements-dev.txt
 - pip install -e .
 jobs:
+
   include:
     - stage: tests
       script:
-      - pytest --cov=freqtrade --cov-config=.coveragerc freqtrade/tests/
+      - pytest --random-order --cov=freqtrade --cov-config=.coveragerc freqtrade/tests/
-      - coveralls
+      # Allow failure for coveralls
+      - coveralls || true
       name: pytest
     - script:
       - cp config.json.example config.json
-      - python freqtrade/main.py --datadir freqtrade/tests/testdata backtesting
+      - freqtrade --datadir freqtrade/tests/testdata backtesting
       name: backtest
     - script:
       - cp config.json.example config.json
-      - python freqtrade/main.py --datadir freqtrade/tests/testdata hyperopt -e 5
+      - freqtrade --datadir freqtrade/tests/testdata hyperopt -e 5
       name: hyperopt
-    - script: flake8 freqtrade
+    - script: flake8 freqtrade scripts
       name: flake8
-    - script: mypy freqtrade
+    - script:
+      # Test Documentation boxes -
+      # !!! <TYPE>: is not allowed!
+      - grep -Er '^!{3}\s\S+:' docs/*; test $? -ne 0
+      name: doc syntax
+    - script: mypy freqtrade scripts
       name: mypy
 
     - stage: docker
@@ -48,11 +50,10 @@ jobs:
         - build_helpers/publish_docker.sh
       name: "Build and test and push docker image"
 
-
 notifications:
   slack:
     secure: bKLXmOrx8e2aPZl7W8DA5BdPAXWGpI5UzST33oc1G/thegXcDVmHBTJrBs4sZak6bgAclQQrdZIsRd2eFYzHLalJEaw6pk7hoAw8SvLnZO0ZurWboz7qg2+aZZXfK4eKl/VUe4sM9M4e/qxjkK+yWG7Marg69c4v1ypF7ezUi1fPYILYw8u0paaiX0N5UX8XNlXy+PBlga2MxDjUY70MuajSZhPsY2pDUvYnMY1D/7XN3cFW0g+3O8zXjF0IF4q1Z/1ASQe+eYjKwPQacE+O8KDD+ZJYoTOFBAPllrtpO1jnOPFjNGf3JIbVMZw4bFjIL0mSQaiSUaUErbU3sFZ5Or79rF93XZ81V7uEZ55vD8KMfR2CB1cQJcZcj0v50BxLo0InkFqa0Y8Nra3sbpV4fV5Oe8pDmomPJrNFJnX6ULQhQ1gTCe0M5beKgVms5SITEpt4/Y0CmLUr6iHDT0CUiyMIRWAXdIgbGh1jfaWOMksybeRevlgDsIsNBjXmYI1Sw2ZZR2Eo2u4R6zyfyjOMLwYJ3vgq9IrACv2w5nmf0+oguMWHf6iWi2hiOqhlAN1W74+3HsYQcqnuM3LGOmuCnPprV1oGBqkPXjIFGpy21gNx4vHfO1noLUyJnMnlu2L7SSuN1CdLsnjJ1hVjpJjPfqB4nn8g12x87TqM1bOm+3Q=
 cache:
+  pip: True
   directories:
-    - $HOME/.cache/pip
+    - $HOME/dependencies
-    - ta-lib

CONTRIBUTING.md

@@ -11,9 +11,13 @@ 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).
 
-If you are unsure, discuss the feature on our [Slack](https://join.slack.com/t/highfrequencybot/shared_invite/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE)
+If you are unsure, discuss the feature on our [Slack](https://join.slack.com/t/highfrequencybot/shared_invite/enQtNjU5ODcwNjI1MDU3LWEyODBiNzkzNzcyNzU0MWYyYzE5NjIyOTQxMzBmMGUxOTIzM2YyN2Y4NWY1YTEwZDgwYTRmMzE2NmM5ZmY2MTg)
 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:
 
 ### 1. Run unit tests
@@ -41,12 +45,6 @@ pytest freqtrade/tests/test_<file_name>.py::test_<method_name>
 
 ### 2. Test if your code is PEP8 compliant
 
-#### Install packages
-
-```bash
-pip3.6 install flake8 coveralls
-```
-
 #### Run Flake8
 
 ```bash
@@ -60,22 +58,12 @@ Guide for installing them is [here](http://flake8.pycqa.org/en/latest/user/using
 
 ### 3. Test if all type-hints are correct
 
-#### Install packages 
-
-``` bash
-pip3.6 install mypy
-```
-
 #### Run mypy
 
 ``` bash
 mypy freqtrade
 ```
 
-## Getting started
-
-Best start by reading the [documentation](https://github.com/freqtrade/freqtrade/blob/develop/docs/index.md) to get a feel for what is possible with the bot, or head straight to the [Developer-documentation](https://github.com/freqtrade/freqtrade/blob/develop/docs/developer.md) (WIP) which should help you getting started.
-
 ## (Core)-Committer Guide
 
 ### Process: Pull Requests

Dockerfile

@@ -1,7 +1,7 @@
-FROM python:3.7.0-slim-stretch
+FROM python:3.7.4-slim-stretch
 
 RUN apt-get update \
-    && apt-get -y install curl build-essential \
+    && apt-get -y install curl build-essential libssl-dev \
     && apt-get clean \
     && pip install --upgrade pip
 
@@ -16,7 +16,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 /freqtrade/
+COPY requirements.txt requirements-common.txt /freqtrade/
 RUN pip install numpy --no-cache-dir \
   && pip install -r requirements.txt --no-cache-dir
 

Dockerfile.pi

@@ -0,0 +1,40 @@
+FROM balenalib/raspberrypi3-debian:stretch
+
+RUN [ "cross-build-start" ]
+
+RUN apt-get update \
+ && apt-get -y install wget curl build-essential libssl-dev libffi-dev \
+ && apt-get clean
+
+# Prepare environment
+RUN mkdir /freqtrade
+WORKDIR /freqtrade
+
+# Install TA-lib
+COPY build_helpers/ta-lib-0.4.0-src.tar.gz /freqtrade/
+RUN tar -xzf /freqtrade/ta-lib-0.4.0-src.tar.gz \
+ && cd /freqtrade/ta-lib/ \
+ && ./configure \
+ && make \
+ && make install \
+ && rm /freqtrade/ta-lib-0.4.0-src.tar.gz
+
+ENV LD_LIBRARY_PATH /usr/local/lib
+
+# Install berryconda
+RUN wget https://github.com/jjhelmus/berryconda/releases/download/v2.0.0/Berryconda3-2.0.0-Linux-armv7l.sh \
+ && bash ./Berryconda3-2.0.0-Linux-armv7l.sh -b \
+ && rm Berryconda3-2.0.0-Linux-armv7l.sh
+
+# Install dependencies
+COPY requirements-common.txt /freqtrade/
+RUN ~/berryconda3/bin/conda install -y numpy pandas scipy \
+ && ~/berryconda3/bin/pip install -r requirements-common.txt --no-cache-dir
+
+# Install and execute
+COPY . /freqtrade/
+RUN ~/berryconda3/bin/pip install -e . --no-cache-dir
+
+RUN [ "cross-build-end" ]
+
+ENTRYPOINT ["/root/berryconda3/bin/python","./freqtrade/main.py"]

Dockerfile.technical

@@ -3,4 +3,4 @@ FROM freqtradeorg/freqtrade:develop
 RUN apt-get update \
     && apt-get -y install git \
     && apt-get clean \
-    && pip install git+https://github.com/berlinguyinca/technical
+    && pip install git+https://github.com/freqtrade/technical

README.md

@@ -1,10 +1,11 @@
-# freqtrade
+# Freqtrade
 
 [![Build Status](https://travis-ci.org/freqtrade/freqtrade.svg?branch=develop)](https://travis-ci.org/freqtrade/freqtrade)
 [![Coverage Status](https://coveralls.io/repos/github/freqtrade/freqtrade/badge.svg?branch=develop&service=github)](https://coveralls.io/github/freqtrade/freqtrade?branch=develop)
+[![Documentation](https://readthedocs.org/projects/freqtrade/badge/)](https://www.freqtrade.io)
 [![Maintainability](https://api.codeclimate.com/v1/badges/5737e6d668200b7518ff/maintainability)](https://codeclimate.com/github/freqtrade/freqtrade/maintainability)
 
-Simple High frequency trading bot for crypto currencies designed to support multi exchanges and be controlled via Telegram.
+Freqtrade is a free and open source crypto trading bot written in Python. It is designed to support all major exchanges and be controlled via Telegram. It contains backtesting, plotting and money management tools as well as strategy optimization by machine learning.
 
 ![freqtrade](https://raw.githubusercontent.com/freqtrade/freqtrade/develop/docs/assets/freqtrade-screenshot.png)
 
@@ -27,48 +28,27 @@ hesitate to read the source code and understand the mechanism of this bot.
 - [X] [Binance](https://www.binance.com/) ([*Note for binance users](#a-note-on-binance))
 - [ ] [113 others to tests](https://github.com/ccxt/ccxt/). _(We cannot guarantee they will work)_
 
+## Documentation
+
+We invite you to read the bot documentation to ensure you understand how the bot is working.
+
+Please find the complete documentation on our [website](https://www.freqtrade.io).
+
 ## Features
 
-- [x] **Based on Python 3.6+**: For botting on any operating system - Windows, macOS and Linux
+- [x] **Based on Python 3.6+**: For botting on any operating system - Windows, macOS and Linux.
-- [x] **Persistence**: Persistence is achieved through sqlite
+- [x] **Persistence**: Persistence is achieved through sqlite.
 - [x] **Dry-run**: Run the bot without playing money.
 - [x] **Backtesting**: Run a simulation of your buy/sell strategy.
 - [x] **Strategy Optimization by machine learning**: Use machine learning to optimize your buy/sell strategy parameters with real exchange data.
-- [x] **Edge position sizing** Calculate your win rate, risk reward ratio, the best stoploss and adjust your position size before taking a position for each specific market. [Learn more](https://github.com/freqtrade/freqtrade/blob/develop/docs/edge.md)
+- [x] **Edge position sizing** Calculate your win rate, risk reward ratio, the best stoploss and adjust your position size before taking a position for each specific market. [Learn more](https://www.freqtrade.io/en/latest/edge/).
 - [x] **Whitelist crypto-currencies**: Select which crypto-currency you want to trade or use dynamic whitelists.
 - [x] **Blacklist crypto-currencies**: Select which crypto-currency you want to avoid.
-- [x] **Manageable via Telegram**: Manage the bot with Telegram
+- [x] **Manageable via Telegram**: Manage the bot with Telegram.
 - [x] **Display profit/loss in fiat**: Display your profit/loss in 33 fiat.
 - [x] **Daily summary of profit/loss**: Provide a daily summary of your profit/loss.
 - [x] **Performance status report**: Provide a performance status of your current trades.
 
-
-## Table of Contents
-
-- [Quick start](#quick-start)
-- [Documentations](https://github.com/freqtrade/freqtrade/blob/develop/docs/index.md)
-  - [Installation](https://github.com/freqtrade/freqtrade/blob/develop/docs/installation.md)
-  - [Configuration](https://github.com/freqtrade/freqtrade/blob/develop/docs/configuration.md)
-  - [Strategy Optimization](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-optimization.md)
-  - [Backtesting](https://github.com/freqtrade/freqtrade/blob/develop/docs/backtesting.md)
-  - [Hyperopt](https://github.com/freqtrade/freqtrade/blob/develop/docs/hyperopt.md)
-  - [Sandbox Testing](https://github.com/freqtrade/freqtrade/blob/develop/docs/sandbox-testing.md)
-  - [Edge](https://github.com/freqtrade/freqtrade/blob/develop/docs/edge.md)
-- [Basic Usage](#basic-usage)
-  - [Bot commands](#bot-commands)
-  - [Telegram RPC commands](#telegram-rpc-commands)
-- [Support](#support)
-  - [Help](#help--slack)
-  - [Bugs](#bugs--issues)
-  - [Feature Requests](#feature-requests)
-  - [Pull Requests](#pull-requests)
-- [Requirements](#requirements)
-  - [Min hardware required](#min-hardware-required)
-  - [Software requirements](#software-requirements)
-- [Wanna help?](https://github.com/freqtrade/freqtrade/blob/develop/CONTRIBUTING.md)
-  - [Dev - getting started](https://github.com/freqtrade/freqtrade/blob/develop/docs/developer.md) (WIP)
- 
-
 ## Quick start
 
 Freqtrade provides a Linux/macOS script to install all dependencies and help you to configure the bot.
@@ -80,63 +60,53 @@ git checkout develop
 ./setup.sh --install
 ```
 
-_Windows installation is explained in [Installation doc](https://github.com/freqtrade/freqtrade/blob/develop/docs/installation.md)_
+For any other type of installation please refer to [Installation doc](https://www.freqtrade.io/en/latest/installation/).
 
-## Documentation
-
-We invite you to read the bot documentation to ensure you understand how the bot is working.
-
-- [Index](https://github.com/freqtrade/freqtrade/blob/develop/docs/index.md)
-- [Installation](https://github.com/freqtrade/freqtrade/blob/develop/docs/installation.md)
-- [Configuration](https://github.com/freqtrade/freqtrade/blob/develop/docs/configuration.md)
-- [Bot usage](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md)
-  - [How to run the bot](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md#bot-commands)
-  - [How to use Backtesting](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md#backtesting-commands)
-  - [How to use Hyperopt](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md#hyperopt-commands)
-- [Strategy Optimization](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-optimization.md)
-- [Backtesting](https://github.com/freqtrade/freqtrade/blob/develop/docs/backtesting.md)
-- [Hyperopt](https://github.com/freqtrade/freqtrade/blob/develop/docs/hyperopt.md)
 
 ## Basic Usage
 
 ### Bot commands
 
-```bash
+```
-usage: main.py [-h] [-v] [--version] [-c PATH] [-d PATH] [-s NAME]
+usage: freqtrade [-h] [-v] [--logfile FILE] [--version] [-c PATH] [-d PATH]
-               [--strategy-path PATH] [--dynamic-whitelist [INT]]
+                 [-s NAME] [--strategy-path PATH] [--dynamic-whitelist [INT]]
-               [--dry-run-db]
+                 [--db-url PATH] [--sd-notify]
-               {backtesting,hyperopt} ...
+                 {backtesting,edge,hyperopt} ...
 
-Simple High Frequency Trading Bot for crypto currencies
+Free, open source crypto trading bot
 
 positional arguments:
-  {backtesting,hyperopt}
+  {backtesting,edge,hyperopt}
-    backtesting         backtesting module
+    backtesting         Backtesting module.
-    hyperopt            hyperopt module
+    edge                Edge module.
+    hyperopt            Hyperopt module.
 
 optional arguments:
   -h, --help            show this help message and exit
-  -v, --verbose         be verbose
+  -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
+  --logfile FILE        Log to the file specified
   --version             show program's version number and exit
   -c PATH, --config PATH
-                        specify configuration file (default: config.json)
+                        Specify configuration file (default: None). Multiple
+                        --config options may be used.
   -d PATH, --datadir PATH
-                        path to backtest data (default:
+                        Path to backtest data.
-                        freqtrade/tests/testdata
   -s NAME, --strategy NAME
-                        specify strategy class name (default: DefaultStrategy)
+                        Specify strategy class name (default:
-  --strategy-path PATH  specify additional strategy lookup path
+                        DefaultStrategy).
+  --strategy-path PATH  Specify additional strategy lookup path.
   --dynamic-whitelist [INT]
-                        dynamically generate and update whitelist based on 24h
+                        Dynamically generate and update whitelist based on 24h
-                        BaseVolume (Default 20 currencies)
+                        BaseVolume (default: 20). DEPRECATED.
-  --dry-run-db          Force dry run to use a local DB
+  --db-url PATH         Override trades database URL, this is useful if
-                        "tradesv3.dry_run.sqlite" instead of memory DB. Work
+                        dry_run is enabled or in custom deployments (default:
-                        only if dry_run is enabled.
+                        None).
+  --sd-notify           Notify systemd service manager.
 ```
 
 ### Telegram RPC commands
 
-Telegram is not mandatory. However, this is a great way to control your bot. More details on our [documentation](https://github.com/freqtrade/freqtrade/blob/develop/docs/index.md)
+Telegram is not mandatory. However, this is a great way to control your bot. More details on our [documentation](https://www.freqtrade.io/en/latest/telegram-usage/)
 
 - `/start`: Starts the trader
 - `/stop`: Stops the trader
@@ -159,7 +129,6 @@ The project is currently setup in two main branches:
 - `master` - This branch contains the latest stable release. The bot 'should' be stable on this branch, and 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.
 
-
 ## A note on Binance
 
 For Binance, please add `"BNB/<STAKE>"` to your blacklist to avoid issues.
@@ -172,7 +141,7 @@ Accounts having BNB accounts use this to pay for fees - if your first trade happ
 For any questions not covered by the documentation or for further
 information about the bot, we encourage you to join our slack channel.
 
-- [Click here to join Slack channel](https://join.slack.com/t/highfrequencybot/shared_invite/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE).
+- [Click here to join Slack channel](https://join.slack.com/t/highfrequencybot/shared_invite/enQtNjU5ODcwNjI1MDU3LWEyODBiNzkzNzcyNzU0MWYyYzE5NjIyOTQxMzBmMGUxOTIzM2YyN2Y4NWY1YTEwZDgwYTRmMzE2NmM5ZmY2MTg).
 
 ### [Bugs / Issues](https://github.com/freqtrade/freqtrade/issues?q=is%3Aissue)
 
@@ -203,7 +172,7 @@ to understand the requirements before sending your pull-requests.
 Coding is not a neccessity 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/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE). 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 [Slack](https://join.slack.com/t/highfrequencybot/shared_invite/enQtNjU5ODcwNjI1MDU3LWEyODBiNzkzNzcyNzU0MWYyYzE5NjIyOTQxMzBmMGUxOTIzM2YyN2Y4NWY1YTEwZDgwYTRmMzE2NmM5ZmY2MTg). 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`.
 
@@ -227,4 +196,3 @@ To run this bot we recommend you a cloud instance with a minimum of:
 - [TA-Lib](https://mrjbq7.github.io/ta-lib/install.html)
 - [virtualenv](https://virtualenv.pypa.io/en/stable/installation/) (Recommended)
 - [Docker](https://www.docker.com/products/docker) (Recommended)
-

bin/freqtrade

@@ -1,7 +1,11 @@
 #!/usr/bin/env python3
 
 import sys
+import warnings
 
-from freqtrade.main import main, set_loggers
+from freqtrade.main import main
-set_loggers()
+
+warnings.warn(
+    "Deprecated - To continue to run the bot like this, please run `pip install -e .` again.",
+    DeprecationWarning)
 main(sys.argv[1:])

build_helpers/install_ta-lib.sh

@@ -1,13 +1,17 @@
-if [ ! -f "ta-lib/CHANGELOG.TXT" ]; then
+if [ -z "$1" ]; then
+  INSTALL_LOC=/usr/local
+else
+  INSTALL_LOC=${1}
+fi
+echo "Installing to ${INSTALL_LOC}"
+if [ ! -f "${INSTALL_LOC}/lib/libta_lib.a" ]; then
   tar zxvf ta-lib-0.4.0-src.tar.gz
   cd ta-lib \
   && sed -i.bak "s|0.00000001|0.000000000000000001 |g" src/ta_func/ta_utility.h \
-  && ./configure \
+  && ./configure --prefix=${INSTALL_LOC}/ \
   && make \
   && which sudo && sudo make install || make install \
   && cd ..
 else
-  echo "TA-lib already installed, skipping download and build."
+  echo "TA-lib already installed, skipping installation"
-  cd ta-lib && sudo make install && cd ..
-
 fi

build_helpers/publish_docker.sh

@@ -13,7 +13,7 @@ if [ "${TRAVIS_EVENT_TYPE}" = "cron" ]; then
 else
     echo "event ${TRAVIS_EVENT_TYPE}: building with cache"
     # Pull last build to avoid rebuilding the whole image
-    docker pull ${REPO}:${TAG}
+    docker pull ${IMAGE_NAME}:${TAG}
     docker build --cache-from ${IMAGE_NAME}:${TAG} -t freqtrade:${TAG} .
 fi
 

config.json.example

@@ -30,7 +30,8 @@
         "secret": "your_exchange_secret",
         "ccxt_config": {"enableRateLimit": true},
         "ccxt_async_config": {
-            "enableRateLimit": false
+            "enableRateLimit": true,
+            "rateLimit": 500
         },
         "pair_whitelist": [
             "ETH/BTC",

config_binance.json.example

@@ -11,8 +11,8 @@
         "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,
@@ -30,7 +30,8 @@
         "secret": "your_exchange_secret",
         "ccxt_config": {"enableRateLimit": true},
         "ccxt_async_config": {
-            "enableRateLimit": false
+            "enableRateLimit": true,
+            "rateLimit": 200
         },
         "pair_whitelist": [
             "AST/BTC",

config_full.json.example

@@ -3,11 +3,13 @@
     "stake_currency": "BTC",
     "stake_amount": 0.05,
     "fiat_display_currency": "USD",
+    "amount_reserve_percent" : 0.05,
     "dry_run": false,
     "ticker_interval": "5m",
     "trailing_stop": false,
     "trailing_stop_positive": 0.005,
     "trailing_stop_positive_offset": 0.0051,
+    "trailing_only_offset_is_reached": false,
     "minimal_roi": {
         "40":  0.0,
         "30":  0.01,
@@ -20,8 +22,8 @@
         "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,
@@ -37,26 +39,31 @@
         "buy": "limit",
         "sell": "limit",
         "stoploss": "market",
-        "stoploss_on_exchange": "false"
+        "stoploss_on_exchange": false,
+        "stoploss_on_exchange_interval": 60
     },
     "order_time_in_force": {
         "buy": "gtc",
-        "sell": "gtc",
+        "sell": "gtc"
     },
     "pairlist": {
         "method": "VolumePairList",
         "config": {
             "number_assets": 20,
-            "sort_key": "quoteVolume"
+            "sort_key": "quoteVolume",
+            "precision_filter": false
         }
     },
     "exchange": {
         "name": "bittrex",
+        "sandbox": false,
         "key": "your_exchange_key",
         "secret": "your_exchange_secret",
+        "password": "",
         "ccxt_config": {"enableRateLimit": true},
         "ccxt_async_config": {
             "enableRateLimit": false,
+            "rateLimit": 500,
             "aiohttp_trust_env": false
         },
         "pair_whitelist": [
@@ -74,7 +81,8 @@
         "pair_blacklist": [
             "DOGE/BTC"
         ],
-        "outdated_offset": 5
+        "outdated_offset": 5,
+        "markets_refresh_interval": 60
     },
     "edge": {
         "enabled": false,
@@ -101,6 +109,13 @@
         "token": "your_telegram_token",
         "chat_id": "your_telegram_chat_id"
     },
+    "api_server": {
+        "enabled": false,
+        "listen_ip_address": "127.0.0.1",
+        "listen_port": 8080,
+        "username": "freqtrader",
+        "password": "SuperSecurePassword"
+    },
     "db_url": "sqlite:///tradesv3.sqlite",
     "initial_state": "running",
     "forcebuy_enable": false,
@@ -108,5 +123,5 @@
         "process_throttle_secs": 5
     },
     "strategy": "DefaultStrategy",
-    "strategy_path": "/some/folder/"
+    "strategy_path": "user_data/strategies/"
 }

config_kraken.json.example

@@ -0,0 +1,70 @@
+{
+    "max_open_trades": 5,
+    "stake_currency": "EUR",
+    "stake_amount": 10,
+    "fiat_display_currency": "EUR",
+    "ticker_interval" : "5m",
+    "dry_run": true,
+    "trailing_stop": false,
+    "unfilledtimeout": {
+        "buy": 10,
+        "sell": 30
+    },
+    "bid_strategy": {
+        "use_order_book": false,
+        "ask_last_balance": 0.0,
+        "order_book_top": 1,
+        "check_depth_of_market": {
+            "enabled": false,
+            "bids_to_ask_delta": 1
+        }
+    },
+    "ask_strategy":{
+        "use_order_book": false,
+        "order_book_min": 1,
+        "order_book_max": 9
+    },
+    "exchange": {
+        "name": "kraken",
+        "key": "",
+        "secret": "",
+        "ccxt_config": {"enableRateLimit": true},
+        "ccxt_async_config": {
+            "enableRateLimit": true,
+            "rateLimit": 1000
+        },
+        "pair_whitelist": [
+            "ETH/EUR",
+            "BTC/EUR",
+            "BCH/EUR"
+        ],
+        "pair_blacklist": [
+
+        ]
+    },
+    "edge": {
+        "enabled": false,
+        "process_throttle_secs": 3600,
+        "calculate_since_number_of_days": 7,
+        "capital_available_percentage": 0.5,
+        "allowed_risk": 0.01,
+        "stoploss_range_min": -0.01,
+        "stoploss_range_max": -0.1,
+        "stoploss_range_step": -0.01,
+        "minimum_winrate": 0.60,
+        "minimum_expectancy": 0.20,
+        "min_trade_number": 10,
+        "max_trade_duration_minute": 1440,
+        "remove_pumps": false
+    },
+    "telegram": {
+        "enabled": false,
+        "token": "your_telegram_token",
+        "chat_id": "your_telegram_chat_id"
+    },
+    "initial_state": "running",
+    "forcebuy_enable": false,
+    "internals": {
+        "process_throttle_secs": 5
+    }
+}

docs/backtesting.md

@@ -3,14 +3,43 @@
 This page explains how to validate your strategy performance by using
 Backtesting.
 
-## Table of Contents
+## Getting data for backtesting and hyperopt
 
-- [Test your strategy with Backtesting](#test-your-strategy-with-backtesting)
+To download data (candles / OHLCV) needed for backtesting and hyperoptimization use the `freqtrade download-data` command.
-- [Understand the backtesting result](#understand-the-backtesting-result)
+
+If no additional parameter is specified, freqtrade will download data for `"1m"` and `"5m"` timeframes.
+Exchange and pairs will come from `config.json` (if specified using `-c/--config`). Otherwise `--exchange` becomes mandatory.
+
+Alternatively, a `pairs.json` file can be used.
+
+If you are using Binance for example:
+
+- create a directory `user_data/data/binance` and copy `pairs.json` in that directory.
+- update the `pairs.json` to contain the currency pairs you are interested in.
+
+```bash
+mkdir -p user_data/data/binance
+cp freqtrade/tests/testdata/pairs.json user_data/data/binance
+```
+
+Then run:
+
+```bash
+freqtrade download-data --exchange binance
+```
+
+This will download ticker data for all the currency pairs you defined in `pairs.json`.
+
+- 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 tickers, please use a different configuration file (you'll probably need to adjust ratelimits etc.)
+- To use `pairs.json` from some other directory, use `--pairs-file some_other_dir/pairs.json`.
+- To download ticker data for only 10 days, use `--days 10` (defaults to 30 days).
+- Use `--timeframes` to specify which tickers to download. Default is `--timeframes 1m 5m` which will download 1-minute and 5-minute tickers.
+- 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.
 
 ## Test your strategy with Backtesting
 
-Now you have good Buy and Sell strategies, you want to test it against
+Now you have good Buy and Sell strategies and some historic data, you want to test it against
 real data. This is what we call
 [backtesting](https://en.wikipedia.org/wiki/Backtesting).
 
@@ -18,7 +47,7 @@ Backtesting will use the crypto-currencies (pair) from your config file
 and load static tickers located in
 [/freqtrade/tests/testdata](https://github.com/freqtrade/freqtrade/tree/develop/freqtrade/tests/testdata).
 If the 5 min and 1 min ticker for the crypto-currencies to test is not
-already in the `testdata` folder, backtesting will download them 
+already in the `testdata` directory, backtesting will download them
 automatically. Testdata files will not be updated until you specify it.
 
 The result of backtesting will confirm you if your bot has better odds of making a profit than a loss.
@@ -29,81 +58,52 @@ The backtesting is very easy with freqtrade.
 #### With 5 min tickers (Per default)
 
 ```bash
-python3 ./freqtrade/main.py backtesting
+freqtrade backtesting
 ```
 
 #### With 1 min tickers
 
 ```bash
-python3 ./freqtrade/main.py backtesting --ticker-interval 1m
+freqtrade backtesting --ticker-interval 1m
-```
-
-#### Update cached pairs with the latest data
-
-```bash
-python3 ./freqtrade/main.py backtesting --refresh-pairs-cached
-```
-
-#### With live data (do not alter your testdata files)
-
-```bash
-python3 ./freqtrade/main.py backtesting --live
 ```
 
 #### Using a different on-disk ticker-data source
 
+Assume you downloaded the history data from the Bittrex exchange and kept it in the `user_data/data/bittrex-20180101` directory. 
+You can then use this data for backtesting as follows:
+
 ```bash
-python3 ./freqtrade/main.py backtesting --datadir freqtrade/tests/testdata-20180101
+freqtrade backtesting --datadir user_data/data/bittrex-20180101
 ```
 
 #### With a (custom) strategy file
 
 ```bash
-python3 ./freqtrade/main.py -s TestStrategy backtesting
+freqtrade -s TestStrategy backtesting
 ```
 
-Where `-s TestStrategy` refers to the class name within the strategy file `test_strategy.py` found in the `freqtrade/user_data/strategies` directory
+Where `-s TestStrategy` refers to the class name within the strategy file `test_strategy.py` found in the `freqtrade/user_data/strategies` directory.
+
+#### Comparing multiple Strategies
+
+```bash
+freqtrade backtesting --strategy-list TestStrategy1 AwesomeStrategy --ticker-interval 5m
+```
+
+Where `TestStrategy1` and `AwesomeStrategy` refer to class names of strategies.
 
 #### Exporting trades to file
 
 ```bash
-python3 ./freqtrade/main.py backtesting --export trades
+freqtrade backtesting --export trades
 ```
 
-The exported trades can be read using the following code for manual analysis, or can be used by the plotting script `plot_dataframe.py` in the scripts folder.
+The exported trades can be used for [further analysis](#further-backtest-result-analysis), or can be used by the plotting script `plot_dataframe.py` in the scripts directory.
-
-``` python
-import json
-from pathlib import Path
-import pandas as pd
-
-filename=Path('user_data/backtest_data/backtest-result.json')
-
-with filename.open() as file:
-        data = json.load(file)
-
-columns = ["pair", "profit", "opents", "closets", "index", "duration",
-           "open_rate", "close_rate", "open_at_end", "sell_reason"]
-df = pd.DataFrame(data, columns=columns)
-
-df['opents'] = pd.to_datetime(df['opents'],
-                              unit='s',
-                              utc=True,
-                              infer_datetime_format=True
-                             )
-df['closets'] = pd.to_datetime(df['closets'],
-                               unit='s',
-                               utc=True,
-                               infer_datetime_format=True
-                              )
-```
-
-If you have some ideas for interesting / helpful backtest data analysis, feel free to submit a PR so the community can benefit from it.
 
 #### Exporting trades to file specifying a custom filename
 
 ```bash
-python3 ./freqtrade/main.py backtesting --export trades --export-filename=backtest_teststrategy.json
+freqtrade backtesting --export trades --export-filename=backtest_teststrategy.json
 ```
 
 #### Running backtest with smaller testset
@@ -114,7 +114,7 @@ you want to use. The last N ticks/timeframes will be used.
 Example:
 
 ```bash
-python3 ./freqtrade/main.py backtesting --timerange=-200
+freqtrade backtesting --timerange=-200
 ```
 
 #### Advanced use of timerange
@@ -134,36 +134,6 @@ The full timerange specification:
 - Use tickframes between POSIX timestamps 1527595200 1527618600:
                                                 `--timerange=1527595200-1527618600`
 
-#### Downloading new set of ticker data
-
-To download new set of backtesting ticker data, you can use a download script.
-
-If you are using Binance for example:
-
-- create a folder `user_data/data/binance` and copy `pairs.json` in that folder.
-- update the `pairs.json` to contain the currency pairs you are interested in.
-
-```bash
-mkdir -p user_data/data/binance
-cp freqtrade/tests/testdata/pairs.json user_data/data/binance
-```
-
-Then run:
-
-```bash
-python scripts/download_backtest_data.py --exchange binance
-```
-
-This will download ticker data for all the currency pairs you defined in `pairs.json`.
-
-- To use a different folder than the exchange specific default, use `--export user_data/data/some_directory`.
-- To change the exchange used to download the tickers, use `--exchange`. Default is `bittrex`.
-- To use `pairs.json` from some other folder, use `--pairs-file some_other_dir/pairs.json`.
-- To download ticker data for only 10 days, use `--days 10`.
-- Use `--timeframes` to specify which tickers to download. Default is `--timeframes 1m 5m` which will download 1-minute and 5-minute tickers.
-
-For help about backtesting usage, please refer to [Backtesting commands](#backtesting-commands).
-
 ## Understand the backtesting result
 
 The most important in the backtesting is to understand the result.
@@ -171,53 +141,65 @@ The most important in the backtesting is to understand the result.
 A backtesting result will look like that:
 
 ```
-======================================== BACKTESTING REPORT =========================================
+========================================================= BACKTESTING REPORT ========================================================
-| pair     |   buy count |   avg profit % |   total profit BTC |   avg duration |   profit |   loss |
+| pair     |   buy count |   avg profit % |   cum profit % |   tot profit BTC |   tot profit % | avg duration   |   profit |   loss |
-|:---------|------------:|---------------:|-------------------:|---------------:|---------:|-------:|
+|:---------|------------:|---------------:|---------------:|-----------------:|---------------:|:---------------|---------:|-------:|
-| ETH/BTC  |          44 |           0.18 |         0.00159118 |           50.9 |       44 |      0 |
+| ADA/BTC  |          35 |          -0.11 |          -3.88 |      -0.00019428 |          -1.94 | 4:35:00        |       14 |     21 |
-| LTC/BTC  |          27 |           0.10 |         0.00051931 |          103.1 |       26 |      1 |
+| ARK/BTC  |          11 |          -0.41 |          -4.52 |      -0.00022647 |          -2.26 | 2:03:00        |        3 |      8 |
-| ETC/BTC  |          24 |           0.05 |         0.00022434 |          166.0 |       22 |      2 |
+| BTS/BTC  |          32 |           0.31 |           9.78 |       0.00048938 |           4.89 | 5:05:00        |       18 |     14 |
-| DASH/BTC |          29 |           0.18 |         0.00103223 |          192.2 |       29 |      0 |
+| DASH/BTC |          13 |          -0.08 |          -1.07 |      -0.00005343 |          -0.53 | 4:39:00        |        6 |      7 |
-| ZEC/BTC  |          65 |          -0.02 |        -0.00020621 |          202.7 |       62 |      3 |
+| ENG/BTC  |          18 |           1.36 |          24.54 |       0.00122807 |          12.27 | 2:50:00        |        8 |     10 |
-| XLM/BTC  |          35 |           0.02 |         0.00012877 |          242.4 |       32 |      3 |
+| EOS/BTC  |          36 |           0.08 |           3.06 |       0.00015304 |           1.53 | 3:34:00        |       16 |     20 |
-| BCH/BTC  |          12 |           0.62 |         0.00149284 |           50.0 |       12 |      0 |
+| ETC/BTC  |          26 |           0.37 |           9.51 |       0.00047576 |           4.75 | 6:14:00        |       11 |     15 |
-| POWR/BTC |          21 |           0.26 |         0.00108215 |          134.8 |       21 |      0 |
+| ETH/BTC  |          33 |           0.30 |           9.96 |       0.00049856 |           4.98 | 7:31:00        |       16 |     17 |
-| ADA/BTC  |          54 |          -0.19 |        -0.00205202 |          191.3 |       47 |      7 |
+| IOTA/BTC |          32 |           0.03 |           1.09 |       0.00005444 |           0.54 | 3:12:00        |       14 |     18 |
-| XMR/BTC  |          24 |          -0.43 |        -0.00206013 |          120.6 |       20 |      4 |
+| LSK/BTC  |          15 |           1.75 |          26.26 |       0.00131413 |          13.13 | 2:58:00        |        6 |      9 |
-| TOTAL    |         335 |           0.03 |         0.00175246 |          157.9 |      315 |     20 |
+| LTC/BTC  |          32 |          -0.04 |          -1.38 |      -0.00006886 |          -0.69 | 4:49:00        |       11 |     21 |
-2018-06-13 06:57:27,347 - freqtrade.optimize.backtesting - INFO -
+| NANO/BTC |          17 |           1.26 |          21.39 |       0.00107058 |          10.70 | 1:55:00        |       10 |      7 |
-====================================== LEFT OPEN TRADES REPORT ======================================
+| NEO/BTC  |          23 |           0.82 |          18.97 |       0.00094936 |           9.48 | 2:59:00        |       10 |     13 |
-| pair     |   buy count |   avg profit % |   total profit BTC |   avg duration |   profit |   loss |
+| REQ/BTC  |           9 |           1.17 |          10.54 |       0.00052734 |           5.27 | 3:47:00        |        4 |      5 |
-|:---------|------------:|---------------:|-------------------:|---------------:|---------:|-------:|
+| XLM/BTC  |          16 |           1.22 |          19.54 |       0.00097800 |           9.77 | 3:15:00        |        7 |      9 |
-| ETH/BTC  |           3 |           0.16 |         0.00009619 |           25.0 |        3 |      0 |
+| XMR/BTC  |          23 |          -0.18 |          -4.13 |      -0.00020696 |          -2.07 | 5:30:00        |       12 |     11 |
-| LTC/BTC  |           1 |          -1.00 |        -0.00020118 |         1085.0 |        0 |      1 |
+| XRP/BTC  |          35 |           0.66 |          22.96 |       0.00114897 |          11.48 | 3:49:00        |       12 |     23 |
-| ETC/BTC  |           2 |          -1.80 |        -0.00071933 |         1092.5 |        0 |      2 |
+| ZEC/BTC  |          22 |          -0.46 |         -10.18 |      -0.00050971 |          -5.09 | 2:22:00        |        7 |     15 |
-| DASH/BTC |           0 |         nan    |         0.00000000 |          nan   |        0 |      0 |
+| TOTAL    |         429 |           0.36 |         152.41 |       0.00762792 |          76.20 | 4:12:00        |      186 |    243 |
-| ZEC/BTC  |           3 |          -4.27 |        -0.00256826 |         1301.7 |        0 |      3 |
+========================================================= SELL REASON STATS =========================================================
-| XLM/BTC  |           3 |          -1.11 |        -0.00066744 |          965.0 |        0 |      3 |
+| Sell Reason        |   Count |
-| BCH/BTC  |           0 |         nan    |         0.00000000 |          nan   |        0 |      0 |
+|:-------------------|--------:|
-| POWR/BTC |           0 |         nan    |         0.00000000 |          nan   |        0 |      0 |
+| trailing_stop_loss |     205 |
-| ADA/BTC  |           7 |          -3.58 |        -0.00503604 |          850.0 |        0 |      7 |
+| stop_loss          |     166 |
-| XMR/BTC  |           4 |          -3.79 |        -0.00303456 |          291.2 |        0 |      4 |
+| sell_signal        |      56 |
-| TOTAL    |          23 |          -2.63 |        -0.01213062 |          750.4 |        3 |     20 |
+| force_sell         |       2 |
-
+====================================================== LEFT OPEN TRADES REPORT ======================================================
+| pair     |   buy count |   avg profit % |   cum profit % |   tot profit BTC |   tot profit % | avg duration   |   profit |   loss |
+|:---------|------------:|---------------:|---------------:|-----------------:|---------------:|:---------------|---------:|-------:|
+| ADA/BTC  |           1 |           0.89 |           0.89 |       0.00004434 |           0.44 | 6:00:00        |        1 |      0 |
+| LTC/BTC  |           1 |           0.68 |           0.68 |       0.00003421 |           0.34 | 2:00:00        |        1 |      0 |
+| TOTAL    |           2 |           0.78 |           1.57 |       0.00007855 |           0.78 | 4:00:00        |        2 |      0 |
 ```
 
 The 1st table will contain all trades the bot made.
 
-The 2nd table will contain all trades the bot had to `forcesell` at the end of the backtest period to prsent a full picture.
+The 2nd table will contain a recap of sell reasons.
+
+The 3rd table will contain all trades the bot had to `forcesell` at the end of the backtest period to present a full picture.
 These trades are also included in the first table, but are extracted separately for clarity.
 
 The last line will give you the overall performance of your strategy,
 here:
 
 ```
-TOTAL             419           -0.41         -0.00348593            52.9
+| TOTAL    |         429 |           0.36 |         152.41 |       0.00762792 |          76.20 | 4:12:00        |      186 |    243 |
 ```
 
-We understand the bot has made `419` trades for an average duration of
+We understand the bot has made `429` trades for an average duration of
-`52.9` min, with a performance of `-0.41%` (loss), that means it has 
+`4:12:00`, with a performance of `76.20%` (profit), that means it has
-lost a total of `-0.00348593 BTC`.
+earned a total of `0.00762792 BTC` starting with a capital of 0.01 BTC.
+
+The column `avg profit %` shows the average profit for all trades made while the column `cum profit %` sums all the profits/losses. 
+The column `tot profit %` shows instead the total profit % in relation to allocated capital 
+(`max_open_trades * stake_amount`). In the above results we have `max_open_trades=2 stake_amount=0.005` in config 
+so `(76.20/100) * (0.005 * 2) =~ 0.00762792 BTC`.
 
 As you will see your strategy performance will be influenced by your buy
 strategy, your sell strategy, and also by the `minimal_roi` and
@@ -238,6 +220,12 @@ On the other hand, if you set a too high `minimal_roi` like `"0":  0.55`
 profit. Hence, keep in mind that your performance is a mix of your
 strategies, your configuration, and the crypto-currency you have set up.
 
+### Further backtest-result analysis
+
+To further analyze your backtest results, you can [export the trades](#exporting-trades-to-file).
+You can then load the trades to perform further analysis as shown in our [data analysis](data-analysis.md#backtesting) backtesting section.
+
+
 ## Backtesting multiple strategies
 
 To backtest multiple strategies, a list of Strategies can be provided.
@@ -245,26 +233,26 @@ To backtest multiple strategies, a list of Strategies can be provided.
 This is limited to 1 ticker-interval per run, however, data is only loaded once from disk so if you have multiple
 strategies you'd like to compare, this should give a nice runtime boost.
 
-All listed Strategies need to be in the same folder.
+All listed Strategies need to be in the same directory.
 
 ``` bash
 freqtrade backtesting --timerange 20180401-20180410 --ticker-interval 5m --strategy-list Strategy001 Strategy002 --export trades
 ```
 
-This will save the results to `user_data/backtest_data/backtest-result-<strategy>.json`, injecting the strategy-name into the target filename.
+This will save the results to `user_data/backtest_results/backtest-result-<strategy>.json`, injecting the strategy-name into the target filename.
 There will be an additional table comparing win/losses of the different strategies (identical to the "Total" row in the first table).
 Detailed output for all strategies one after the other will be available, so make sure to scroll up.
 
 ```
-=================================================== Strategy Summary ====================================================
+=========================================================== Strategy Summary ===========================================================
-| Strategy   |   buy count |   avg profit % |   cum profit % |   total profit ETH | avg duration    |   profit |   loss |
+| Strategy    |   buy count |   avg profit % |   cum profit % |   tot profit BTC |   tot profit % | avg duration   |   profit |   loss |
-|:-----------|------------:|---------------:|---------------:|-------------------:|:----------------|---------:|-------:|
+|:------------|------------:|---------------:|---------------:|-----------------:|---------------:|:---------------|---------:|-------:|
-| Strategy1  |          19 |          -0.76 |         -14.39 |        -0.01440287 | 15:48:00        |       15 |      4 |
+| Strategy1   |         429 |           0.36 |         152.41 |       0.00762792 |          76.20 | 4:12:00        |      186 |    243 |
-| Strategy2  |           6 |          -2.73 |         -16.40 |        -0.01641299 | 1 day, 14:12:00 |        3 |      3 |
+| Strategy2   |        1487 |          -0.13 |        -197.58 |      -0.00988917 |         -98.79 | 4:43:00        |      662 |    825 |
 ```
 
 ## Next step
 
 Great, your strategy is profitable. What if the bot can give your the
 optimal parameters to use for your strategy?
-Your next step is to learn [how to find optimal parameters with Hyperopt](https://github.com/freqtrade/freqtrade/blob/develop/docs/hyperopt.md)
+Your next step is to learn [how to find optimal parameters with Hyperopt](hyperopt.md)

docs/bot-usage.md

@@ -1,57 +1,119 @@
-# Bot usage
+# Start the bot
 
-This page explains the difference parameters of the bot and how to run it.
+This page explains the different parameters of the bot and how to run it.
 
-## Table of Contents
+!!! Note
+    If you've used `setup.sh`, don't forget to activate your virtual environment (`source .env/bin/activate`) before running freqtrade commands.
 
-- [Bot commands](#bot-commands)
-- [Backtesting commands](#backtesting-commands)
-- [Hyperopt commands](#hyperopt-commands)
 
 ## Bot commands
 
 ```
-usage: freqtrade [-h] [-v] [--version] [-c PATH] [-d PATH] [-s NAME]
+usage: freqtrade [-h] [-v] [--logfile FILE] [-V] [-c PATH] [-d PATH]
-                 [--strategy-path PATH] [--dynamic-whitelist [INT]]
+                 [--userdir PATH] [-s NAME] [--strategy-path PATH]
-                 [--db-url PATH]
+                 [--db-url PATH] [--sd-notify]
-                 {backtesting,hyperopt} ...
+                 {backtesting,edge,hyperopt,create-userdir,list-exchanges} ...
 
-Simple High Frequency Trading Bot for crypto currencies
+Free, open source crypto trading bot
 
 positional arguments:
-  {backtesting,hyperopt}
+  {backtesting,edge,hyperopt,create-userdir,list-exchanges}
-    backtesting         backtesting module
+    backtesting         Backtesting module.
-    hyperopt            hyperopt module
+    edge                Edge module.
+    hyperopt            Hyperopt module.
+    create-userdir      Create user-data directory.
+    list-exchanges      Print available exchanges.
 
 optional arguments:
   -h, --help            show this help message and exit
-  -v, --verbose         be verbose
+  -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
-  --version             show program's version number and exit
+  --logfile FILE        Log to the file specified.
+  -V, --version         show program's version number and exit
   -c PATH, --config PATH
-                        specify configuration file (default: config.json)
+                        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 backtest data
+                        Path to directory with historical backtesting data.
+  --userdir PATH, --user-data-dir PATH
+                        Path to userdata directory.
   -s NAME, --strategy NAME
-                        specify strategy class name (default: DefaultStrategy)
+                        Specify strategy class name (default:
-  --strategy-path PATH  specify additional strategy lookup path
+                        `DefaultStrategy`).
-  --dynamic-whitelist [INT]
+  --strategy-path PATH  Specify additional strategy lookup path.
-                        dynamically generate and update whitelist based on 24h
+  --db-url PATH         Override trades database URL, this is useful in custom
-                        BaseVolume (default: 20) DEPRECATED
+                        deployments (default: `sqlite:///tradesv3.sqlite` for
-  --db-url PATH         Override trades database URL, this is useful if
+                        Live Run mode, `sqlite://` for Dry Run).
-                        dry_run is enabled or in custom deployments (default:
+  --sd-notify           Notify systemd service manager.
-                        sqlite:///tradesv3.sqlite)
+
 ```
 
-### How to use a different config file?
+### How to specify which configuration file be used?
 
-The bot allows you to select which config file you want to use. Per
+The bot allows you to select which configuration file you want to use by means of
-default, the bot will load the file `./config.json`
+the `-c/--config` command line option:
 
 ```bash
-python3 ./freqtrade/main.py -c path/far/far/away/config.json
+freqtrade -c path/far/far/away/config.json
 ```
 
-### How to use --strategy?
+Per default, the bot loads the `config.json` configuration file from the current
+working directory.
+
+### How to use multiple configuration files?
+
+The bot allows you to use multiple configuration files by specifying multiple
+`-c/--config` options in the command line. Configuration parameters
+defined in the latter configuration files override parameters with the same name
+defined in the previous configuration files specified in the command line earlier.
+
+For example, you can make a separate configuration file with your key and secrete
+for the Exchange you use for trading, specify default configuration file with
+empty key and secrete values while running in the Dry Mode (which does not actually
+require them):
+
+```bash
+freqtrade -c ./config.json
+```
+
+and specify both configuration files when running in the normal Live Trade Mode:
+
+```bash
+freqtrade -c ./config.json -c path/to/secrets/keys.config.json
+```
+
+This could help you hide your private Exchange key and Exchange secrete on you local machine
+by setting appropriate file permissions for the file which contains actual secrets and, additionally,
+prevent unintended disclosure of sensitive private data when you publish examples
+of your configuration in the project issues or in the Internet.
+
+See more details on this technique with examples in the documentation page on
+[configuration](configuration.md).
+
+### Where to store custom data
+
+Freqtrade allows the creation of a user-data directory using `freqtrade create-userdir --userdir someDirectory`.
+This directory will look as follows:
+
+```
+user_data/
+├── backtest_results
+├── data
+├── hyperopts
+├── hyperopts_results
+├── plot
+└── strategies
+```
+
+You can add the entry "user_data_dir" setting to your configuration, to always point your bot to this directory.
+Alternatively, pass in `--userdir` to every command.
+The bot will fail to start if the directory does not exist, but will create necessary subdirectories.
+
+This directory should contain your custom strategies, custom hyperopts and hyperopt loss functions, backtesting historical data (downloaded using either backtesting command or the download script) and plot outputs.
+
+It is recommended to use version control to keep track of changes to your strategies.
+
+### How to use **--strategy**?
 
 This parameter will allow you to load your custom strategy class.
 Per default without `--strategy` or `-s` the bot will load the
@@ -66,54 +128,30 @@ In `user_data/strategies` you have a file `my_awesome_strategy.py` which has
 a strategy class called `AwesomeStrategy` to load it:
 
 ```bash
-python3 ./freqtrade/main.py --strategy AwesomeStrategy
+freqtrade --strategy AwesomeStrategy
 ```
 
 If the bot does not find your strategy file, it will display in an error
 message the reason (File not found, or errors in your code).
 
-Learn more about strategy file in [optimize your bot](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-optimization.md).
+Learn more about strategy file in
+[Strategy Customization](strategy-customization.md).
 
-### How to use --strategy-path?
+### How to use **--strategy-path**?
 
 This parameter allows you to add an additional strategy lookup path, which gets
-checked before the default locations (The passed path must be a folder!):
+checked before the default locations (The passed path must be a directory!):
+
 ```bash
-python3 ./freqtrade/main.py --strategy AwesomeStrategy --strategy-path /some/folder
+freqtrade --strategy AwesomeStrategy --strategy-path /some/directory
 ```
 
 #### How to install a strategy?
 
-This is very simple. Copy paste your strategy file into the folder
+This is very simple. Copy paste your strategy file into the directory
 `user_data/strategies` or use `--strategy-path`. And voila, the bot is ready to use it.
 
-### How to use --dynamic-whitelist?
+### How to use **--db-url**?
-
-> Dynamic-whitelist is deprecated. Please move your configurations to the configuration as outlined [here](docs/configuration.md#Dynamic-Pairlists)
-
-Per default `--dynamic-whitelist` will retrieve the 20 currencies based
-on BaseVolume. This value can be changed when you run the script.
-
-**By Default**
-Get the 20 currencies based on BaseVolume.
-
-```bash
-python3 ./freqtrade/main.py --dynamic-whitelist
-```
-
-**Customize the number of currencies to retrieve**
-Get the 30 currencies based on BaseVolume.
-
-```bash
-python3 ./freqtrade/main.py --dynamic-whitelist 30
-```
-
-**Exception**
-`--dynamic-whitelist` must be greater than 0. If you enter 0 or a
-negative value (e.g -2), `--dynamic-whitelist` will use the default
-value (20).
-
-### How to use --db-url?
 
 When you run the bot in Dry-run mode, per default no transactions are
 stored in a database. If you want to store your bot actions in a DB
@@ -121,7 +159,7 @@ using `--db-url`. This can also be used to specify a custom database
 in production mode. Example command:
 
 ```bash
-python3 ./freqtrade/main.py -c config.json --db-url sqlite:///tradesv3.dry_run.sqlite
+freqtrade -c config.json --db-url sqlite:///tradesv3.dry_run.sqlite
 ```
 
 ## Backtesting commands
@@ -129,59 +167,56 @@ python3 ./freqtrade/main.py -c config.json --db-url sqlite:///tradesv3.dry_run.s
 Backtesting also uses the config specified via `-c/--config`.
 
 ```
-usage: freqtrade backtesting [-h] [-i TICKER_INTERVAL] [--eps] [--dmmp]
+usage: freqtrade backtesting [-h] [-i TICKER_INTERVAL] [--timerange TIMERANGE]
-                             [--timerange TIMERANGE] [-l] [-r]
+                           [--max_open_trades MAX_OPEN_TRADES]
-                             [--strategy-list STRATEGY_LIST [STRATEGY_LIST ...]]
+                           [--stake_amount STAKE_AMOUNT] [-r] [--eps] [--dmmp]
-                             [--export EXPORT] [--export-filename PATH]
+                           [-l]
+                           [--strategy-list STRATEGY_LIST [STRATEGY_LIST ...]]
+                           [--export EXPORT] [--export-filename PATH]
 
 optional arguments:
   -h, --help            show this help message and exit
   -i TICKER_INTERVAL, --ticker-interval TICKER_INTERVAL
-                        specify ticker interval (1m, 5m, 30m, 1h, 1d)
+                        Specify ticker interval (1m, 5m, 30m, 1h, 1d).
+  --timerange TIMERANGE
+                        Specify what timerange of data to use.
+  --max_open_trades MAX_OPEN_TRADES
+                        Specify max_open_trades to use.
+  --stake_amount STAKE_AMOUNT
+                        Specify stake_amount.
+  -r, --refresh-pairs-cached
+                        Refresh the pairs files in tests/testdata with the
+                        latest data from the exchange. Use it if you want to
+                        run your optimization commands with up-to-date data.
   --eps, --enable-position-stacking
                         Allow buying the same pair multiple times (position
-                        stacking)
+                        stacking).
   --dmmp, --disable-max-market-positions
                         Disable applying `max_open_trades` during backtest
                         (same as setting `max_open_trades` to a very high
-                        number)
+                        number).
-  --timerange TIMERANGE
-                        specify what timerange of data to use.
-  -l, --live            using live data
-  -r, --refresh-pairs-cached
-                        refresh the pairs files in tests/testdata with the
-                        latest data from the exchange. Use it if you want to
-                        run your backtesting with up-to-date data.
   --strategy-list STRATEGY_LIST [STRATEGY_LIST ...]
-                        Provide a commaseparated list of strategies to
+                        Provide a space-separated list of strategies to
                         backtest Please note that ticker-interval needs to be
                         set either in config or via command line. When using
                         this together with --export trades, the strategy-name
                         is injected into the filename (so backtest-data.json
                         becomes backtest-data-DefaultStrategy.json
-  --export EXPORT       export backtest results, argument are: trades Example
+  --export EXPORT       Export backtest results, argument are: trades. Example
                         --export=trades
   --export-filename PATH
                         Save backtest results to this filename requires
                         --export to be set as well Example --export-
-                        filename=user_data/backtest_data/backtest_today.json
+                        filename=user_data/backtest_results/backtest_today.json
-                        (default: user_data/backtest_data/backtest-
+                        (default: user_data/backtest_results/backtest-
                         result.json)
-
 ```
 
-### How to use --refresh-pairs-cached parameter?
+### Getting historic data for backtesting
 
-The first time your run Backtesting, it will take the pairs you have
+The first time your run Backtesting, you will need to download some historic data first.
-set in your config file and download data from Bittrex.
+This can be accomplished by using `freqtrade download-data`.  
-
+Check the corresponding [help page section](backtesting.md#Getting-data-for-backtesting-and-hyperopt) for more details
-If for any reason you want to update your data set, you use
-`--refresh-pairs-cached` to force Backtesting to update the data it has.
-**Use it only if you want to update your data set. You will not be able
-to come back to the previous version.**
-
-To test your strategy with latest data, we recommend continuing using
-the parameter `-l` or `--live`.
 
 ## Hyperopt commands
 
@@ -189,65 +224,106 @@ To optimize your strategy, you can use hyperopt parameter hyperoptimization
 to find optimal parameter values for your stategy.
 
 ```
-usage: freqtrade hyperopt [-h] [-i TICKER_INTERVAL] [--eps] [--dmmp]
+usage: freqtrade hyperopt [-h] [-i TICKER_INTERVAL] [--timerange TIMERANGE]
-                          [--timerange TIMERANGE] [-e INT]
+                          [--max_open_trades INT]
-                          [-s {all,buy,roi,stoploss} [{all,buy,roi,stoploss} ...]]
+                          [--stake_amount STAKE_AMOUNT] [-r]
+                          [--customhyperopt NAME] [--hyperopt-path PATH]
+                          [--eps] [-e INT]
+                          [-s {all,buy,sell,roi,stoploss} [{all,buy,sell,roi,stoploss} ...]]
+                          [--dmmp] [--print-all] [--no-color] [-j JOBS]
+                          [--random-state INT] [--min-trades INT] [--continue]
+                          [--hyperopt-loss NAME]
 
 optional arguments:
   -h, --help            show this help message and exit
   -i TICKER_INTERVAL, --ticker-interval TICKER_INTERVAL
-                        specify ticker interval (1m, 5m, 30m, 1h, 1d)
+                        Specify ticker interval (`1m`, `5m`, `30m`, `1h`,
+                        `1d`).
+  --timerange TIMERANGE
+                        Specify what timerange of data to use.
+  --max_open_trades INT
+                        Specify max_open_trades to use.
+  --stake_amount STAKE_AMOUNT
+                        Specify stake_amount.
+  -r, --refresh-pairs-cached
+                        Refresh the pairs files in tests/testdata with the
+                        latest data from the exchange. Use it if you want to
+                        run your optimization commands with up-to-date data.
+  --customhyperopt NAME
+                        Specify hyperopt class name (default:
+                        `DefaultHyperOpts`).
+  --hyperopt-path PATH  Specify additional lookup path for Hyperopts and
+                        Hyperopt Loss functions.
   --eps, --enable-position-stacking
                         Allow buying the same pair multiple times (position
-                        stacking)
+                        stacking).
+  -e INT, --epochs INT  Specify number of epochs (default: 100).
+  -s {all,buy,sell,roi,stoploss} [{all,buy,sell,roi,stoploss} ...], --spaces {all,buy,sell,roi,stoploss} [{all,buy,sell,roi,stoploss} ...]
+                        Specify which parameters to hyperopt. Space-separated
+                        list. Default: `all`.
   --dmmp, --disable-max-market-positions
                         Disable applying `max_open_trades` during backtest
                         (same as setting `max_open_trades` to a very high
-                        number)
+                        number).
-  --timerange TIMERANGE
+  --print-all           Print all results, not only the best ones.
-                        specify what timerange of data to use.
+  --no-color            Disable colorization of hyperopt results. May be
-  --hyperopt PATH       specify hyperopt file (default:
+                        useful if you are redirecting output to a file.
-                        freqtrade/optimize/default_hyperopt.py)
+  -j JOBS, --job-workers JOBS
-  -e INT, --epochs INT  specify number of epochs (default: 100)
+                        The number of concurrently running jobs for
-  -s {all,buy,roi,stoploss} [{all,buy,roi,stoploss} ...], --spaces {all,buy,roi,stoploss} [{all,buy,roi,stoploss} ...]
+                        hyperoptimization (hyperopt worker processes). If -1
-                        Specify which parameters to hyperopt. Space separate
+                        (default), all CPUs are used, for -2, all CPUs but one
-                        list. Default: all
+                        are used, etc. If 1 is given, no parallel computing
-
+                        code is used at all.
+  --random-state INT    Set random state to some positive integer for
+                        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,
+                        OnlyProfitHyperOptLoss, SharpeHyperOptLoss.
+                        (default: `DefaultHyperOptLoss`).
 ```
 
 ## Edge commands
 
-To know your trade expectacny and winrate against historical data, you can use Edge.
+To know your trade expectancy and winrate against historical data, you can use Edge.
 
 ```
-usage: main.py edge [-h] [-i TICKER_INTERVAL] [--timerange TIMERANGE] [-r]
+usage: freqtrade edge [-h] [-i TICKER_INTERVAL] [--timerange TIMERANGE]
+                    [--max_open_trades MAX_OPEN_TRADES]
+                    [--stake_amount STAKE_AMOUNT] [-r]
                     [--stoplosses STOPLOSS_RANGE]
 
 optional arguments:
   -h, --help            show this help message and exit
   -i TICKER_INTERVAL, --ticker-interval TICKER_INTERVAL
-                        specify ticker interval (1m, 5m, 30m, 1h, 1d)
+                        Specify ticker interval (1m, 5m, 30m, 1h, 1d).
   --timerange TIMERANGE
-                        specify what timerange of data to use.
+                        Specify what timerange of data to use.
+  --max_open_trades MAX_OPEN_TRADES
+                        Specify max_open_trades to use.
+  --stake_amount STAKE_AMOUNT
+                        Specify stake_amount.
   -r, --refresh-pairs-cached
-                        refresh the pairs files in tests/testdata with the
+                        Refresh the pairs files in tests/testdata with the
                         latest data from the exchange. Use it if you want to
-                        run your edge with up-to-date data.
+                        run your optimization commands with up-to-date data.
   --stoplosses STOPLOSS_RANGE
-                        defines a range of stoploss against which edge will
+                        Defines a range of stoploss against which edge will
-                        assess the strategythe format is "min,max,step"
+                        assess the strategy the format is "min,max,step"
                         (without any space).example:
                         --stoplosses=-0.01,-0.1,-0.001
 ```
 
 To understand edge and how to read the results, please read the [edge documentation](edge.md).
 
-## A parameter missing in the configuration?
-
-All parameters for `main.py`, `backtesting`, `hyperopt` are referenced
-in [misc.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/misc.py#L84)
-
 ## Next step
 
 The optimal strategy of the bot will change with time depending of the market trends. The next step is to
-[optimize your bot](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-optimization.md).
+[Strategy Customization](strategy-customization.md).

docs/configuration.md

@@ -1,92 +1,142 @@
 # Configure the bot
 
-This page explains how to configure your `config.json` file.
+This page explains how to configure the bot.
 
-## Table of Contents
+## The Freqtrade configuration file
 
-- [Bot commands](#bot-commands)
+The bot uses a set of configuration parameters during its operation that all together conform the bot configuration. It normally reads its configuration from a file (Freqtrade configuration file).
-- [Backtesting commands](#backtesting-commands)
-- [Hyperopt commands](#hyperopt-commands)
 
-## Setup config.json
+Per default, the bot loads configuration from the `config.json` file located in the current working directory.
 
-We recommend to copy and use the `config.json.example` as a template
+You can change the name of the configuration file used by the bot with the `-c/--config` command line option.
+
+In some advanced use cases, multiple configuration files can be specified and used by the bot or the bot can read its configuration parameters from the process standard input stream.
+
+If you used the [Quick start](installation.md/#quick-start) method for installing 
+the bot, the installation script should have already created the default configuration file (`config.json`) for you.
+
+If default configuration file is not created we recommend you to copy and use the `config.json.example` as a template
 for your bot configuration.
 
-The table below will list all configuration parameters.
+The Freqtrade configuration file is to be written in the JSON format.
 
-|  Command | Default | Mandatory | Description |
+Additionally to the standard JSON syntax, you may use one-line `// ...` and multi-line `/* ... */` comments in your configuration files and trailing commas in the lists of parameters.
-|----------|---------|----------|-------------|
-| `max_open_trades` | 3 | Yes | Number of trades open your bot will have. If -1 then it is ignored (i.e. potentially unlimited open trades)
-| `stake_currency` | BTC | Yes | Crypto-currency used for trading.
-| `stake_amount` | 0.05 | Yes | Amount of crypto-currency your bot will use for each trade. Per default, the bot will use (0.05 BTC x 3) = 0.15 BTC in total will be always engaged. Set it to 'unlimited' to allow the bot to use all avaliable balance.
-| `ticker_interval` | [1m, 5m, 30m, 1h, 1d] | No | The ticker interval to use (1min, 5 min, 30 min, 1 hour or 1 day). Default is 5 minutes
-| `fiat_display_currency` | USD | Yes | Fiat currency used to show your profits. More information below.
-| `dry_run` | true | Yes | Define if the bot must be in Dry-run or production mode.
-| `process_only_new_candles` | false | No | If set to true indicators are processed only once a new candle arrives. If false each loop populates the indicators, this will mean the same candle is processed many times creating system load but can be useful of your strategy depends on tick data not only candle. Can be set either in Configuration or in the strategy.
-| `minimal_roi` | See below | No | Set the threshold in percent the bot will use to sell a trade. More information below. If set, this parameter will override `minimal_roi` from your strategy file.
-| `stoploss` | -0.10 | No | Value of the stoploss in percent used by the bot. More information below. If set, this parameter will override `stoploss` from your strategy file.
-| `trailing_stop` | false | No | Enables trailing stop-loss (based on `stoploss` in either configuration or strategy file).
-| `trailing_stop_positve` | 0 | No | Changes stop-loss once profit has been reached.
-| `trailing_stop_positve_offset` | 0 | No | Offset on when to apply `trailing_stop_positive`. Percentage value which should be positive.
-| `unfilledtimeout.buy` | 10 | Yes | How long (in minutes) the bot will wait for an unfilled buy order to complete, after which the order will be cancelled.
-| `unfilledtimeout.sell` | 10 | Yes | How long (in minutes) the bot will wait for an unfilled sell order to complete, after which the order will be cancelled.
-| `bid_strategy.ask_last_balance` | 0.0 | Yes | Set the bidding price. More information below.
-| `bid_strategy.use_order_book` | false | No | Allows buying of pair using the rates in Order Book Bids.
-| `bid_strategy.order_book_top` | 0 | No | Bot will use the top N rate in Order Book Bids. Ie. a value of 2 will allow the bot to pick the 2nd bid rate in Order Book Bids.
-| `bid_strategy. check_depth_of_market.enabled` | false | No | Does not buy if the % difference of buy orders and sell orders is met in Order Book.
-| `bid_strategy. check_depth_of_market.bids_to_ask_delta` | 0 | No | The % difference of buy orders and sell orders found in Order Book. A value lesser than 1 means sell orders is greater, while value greater than 1 means buy orders is higher.
-| `ask_strategy.use_order_book` | false | No | Allows selling of open traded pair using the rates in Order Book Asks.
-| `ask_strategy.order_book_min` | 0 | No | Bot will scan from the top min to max Order Book Asks searching for a profitable rate.
-| `ask_strategy.order_book_max` | 0 | No | Bot will scan from the top min to max Order Book Asks searching for a profitable rate.
-| `order_types` | None | No | Configure order-types depending on the action (`"buy"`, `"sell"`, `"stoploss"`, `"stoploss_on_exchange"`). [More information below](#understand-order_types).
-| `order_time_in_force` | None | No | Configure time in force for buy and sell orders. [More information below](#understand-order_time_in_force).
-| `exchange.name` | bittrex | Yes | Name of the exchange class to use. [List below](#user-content-what-values-for-exchangename).
-| `exchange.key` | key | No | API key to use for the exchange. Only required when you are in production mode.
-| `exchange.secret` | secret | No | API secret to use for the exchange. Only required when you are in production mode.
-| `exchange.pair_whitelist` | [] | No | List of currency to use by the bot. Can be overrided with `--dynamic-whitelist` param.
-| `exchange.pair_blacklist` | [] | No | List of currency the bot must avoid. Useful when using `--dynamic-whitelist` param.
-| `exchange.ccxt_rate_limit` | True | No | DEPRECATED!! Have CCXT handle Exchange rate limits. Depending on the exchange, having this to false can lead to temporary bans from the exchange.
-| `exchange.ccxt_config` | None | No | Additional CCXT parameters passed to the regular 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)
-| `exchange.ccxt_async_config` | None | No | 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)
-| `edge` | false | No | Please refer to [edge configuration document](edge.md) for detailed explanation.
-| `experimental.use_sell_signal` | false | No | Use your sell strategy in addition of the `minimal_roi`.
-| `experimental.sell_profit_only` | false | No | waits until you have made a positive profit before taking a sell decision.
-| `experimental.ignore_roi_if_buy_signal` | false | No | Does not sell if the buy-signal is still active. Takes preference over `minimal_roi` and `use_sell_signal`
-| `pairlist.method` | StaticPairList | No | Use Static whitelist. [More information below](#dynamic-pairlists).
-| `pairlist.config` | None | No | Additional configuration for dynamic pairlists. [More information below](#dynamic-pairlists).
-| `telegram.enabled` | true | Yes | Enable or not the usage of Telegram.
-| `telegram.token` | token | No | Your Telegram bot token. Only required if `telegram.enabled` is `true`.
-| `telegram.chat_id` | chat_id | No | Your personal Telegram account id. Only required if `telegram.enabled` is `true`.
-| `webhook.enabled` | false | No | Enable usage of Webhook notifications
-| `webhook.url` | false | No | URL for the webhook. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details.
-| `webhook.webhookbuy` | false | No | Payload to send on buy. Only required if `webhook.enabled` is `true`. See the [webhook documentationV](webhook-config.md) for more details.
-| `webhook.webhooksell` | false | No | Payload to send on sell. Only required if `webhook.enabled` is `true`. See the [webhook documentationV](webhook-config.md) for more details.
-| `webhook.webhookstatus` | false | No | Payload to send on status calls. Only required if `webhook.enabled` is `true`. See the [webhook documentationV](webhook-config.md) for more details.
-| `db_url` | `sqlite:///tradesv3.sqlite` | No | Declares database URL to use. NOTE: This defaults to `sqlite://` if `dry_run` is `True`.
-| `initial_state` | running | No | Defines the initial application state. More information below.
-| `forcebuy_enable` | false | No | Enables the RPC Commands to force a buy. More information below.
-| `strategy` | DefaultStrategy | No | Defines Strategy class to use.
-| `strategy_path` | null | No | Adds an additional strategy lookup path (must be a folder).
-| `internals.process_throttle_secs` | 5 | Yes | Set the process throttle. Value in second.
 
-The definition of each config parameters is in [misc.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/misc.py#L205).
+Do not worry if you are not familiar with JSON format -- simply open the configuration file with an editor of your choice, make some changes to the parameters you need, save your changes and, finally, restart the bot or, if it was previously stopped, run it again with the changes you made to the configuration. The bot validates syntax of the configuration file at startup and will warn you if you made any errors editing it.
+
+## Configuration parameters
+
+The table below will list all configuration parameters available.
+
+Mandatory parameters are marked as **Required**.
+
+|  Command | Default | Description |
+|----------|---------|-------------|
+| `max_open_trades` | 3 | **Required.** Number of trades open your bot will have. If -1 then it is ignored (i.e. potentially unlimited open trades)
+| `stake_currency` | BTC | **Required.** Crypto-currency used for trading. [Strategy Override](#parameters-in-the-strategy).
+| `stake_amount` | 0.05 | **Required.** Amount of crypto-currency your bot will use for each trade. Per default, the bot will use (0.05 BTC x 3) = 0.15 BTC in total will be always engaged. Set it to `"unlimited"` to allow the bot to use all available balance. [Strategy Override](#parameters-in-the-strategy).
+| `amount_reserve_percent` | 0.05 | Reserve some amount in min pair stake amount. Default is 5%. The bot will reserve `amount_reserve_percent` + stop-loss value when calculating min pair stake amount in order to avoid possible trade refusals.
+| `ticker_interval` | [1m, 5m, 15m, 30m, 1h, 1d, ...] | The ticker interval to use (1min, 5 min, 15 min, 30 min, 1 hour or 1 day). Default is 5 minutes. [Strategy Override](#parameters-in-the-strategy).
+| `fiat_display_currency` | USD | **Required.** Fiat currency used to show your profits. More information below.
+| `dry_run` | true | **Required.** Define if the bot must be in Dry-run or production mode.
+| `dry_run_wallet` | 999.9 | Overrides the default amount of 999.9 stake currency units in the wallet used by the bot running in the Dry Run mode if you need it for any reason.
+| `process_only_new_candles` | false | If set to true indicators are processed only once a new candle arrives. If false each loop populates the indicators, this will mean the same candle is processed many times creating system load but can be useful of your strategy depends on tick data not only candle. [Strategy Override](#parameters-in-the-strategy).
+| `minimal_roi` | See below | Set the threshold in percent the bot will use to sell a trade. More information below. [Strategy Override](#parameters-in-the-strategy).
+| `stoploss` | -0.10 | Value of the stoploss in percent used by the bot. More information below. More details in the [stoploss documentation](stoploss.md). [Strategy Override](#parameters-in-the-strategy).
+| `trailing_stop` | false | Enables trailing stop-loss (based on `stoploss` in either configuration or strategy file). More details in the [stoploss documentation](stoploss.md). [Strategy Override](#parameters-in-the-strategy).
+| `trailing_stop_positive` | 0 | Changes stop-loss once profit has been reached. More details in the [stoploss documentation](stoploss.md). [Strategy Override](#parameters-in-the-strategy).
+| `trailing_stop_positive_offset` | 0 | Offset on when to apply `trailing_stop_positive`. Percentage value which should be positive. More details in the [stoploss documentation](stoploss.md). [Strategy Override](#parameters-in-the-strategy).
+| `trailing_only_offset_is_reached` | false | Only apply trailing stoploss when the offset is reached. [stoploss documentation](stoploss.md). [Strategy Override](#parameters-in-the-strategy).
+| `unfilledtimeout.buy` | 10 | **Required.** How long (in minutes) the bot will wait for an unfilled buy order to complete, after which the order will be cancelled.
+| `unfilledtimeout.sell` | 10 | **Required.** How long (in minutes) the bot will wait for an unfilled sell order to complete, after which the order will be cancelled.
+| `bid_strategy.ask_last_balance` | 0.0 | **Required.** Set the bidding price. More information [below](#understand-ask_last_balance).
+| `bid_strategy.use_order_book` | false | Allows buying of pair using the rates in Order Book Bids.
+| `bid_strategy.order_book_top` | 0 | Bot will use the top N rate in Order Book Bids. Ie. a value of 2 will allow the bot to pick the 2nd bid rate in Order Book Bids.
+| `bid_strategy. check_depth_of_market.enabled` | false | Does not buy if the % difference of buy orders and sell orders is met in Order Book.
+| `bid_strategy. check_depth_of_market.bids_to_ask_delta` | 0 | The % difference of buy orders and sell orders found in Order Book. A value lesser than 1 means sell orders is greater, while value greater than 1 means buy orders is higher.
+| `ask_strategy.use_order_book` | false | Allows selling of open traded pair using the rates in Order Book Asks.
+| `ask_strategy.order_book_min` | 0 | Bot will scan from the top min to max Order Book Asks searching for a profitable rate.
+| `ask_strategy.order_book_max` | 0 | Bot will scan from the top min to max Order Book Asks searching for a profitable rate.
+| `order_types` | None | Configure order-types depending on the action (`"buy"`, `"sell"`, `"stoploss"`, `"stoploss_on_exchange"`). [More information below](#understand-order_types). [Strategy Override](#parameters-in-the-strategy).
+| `order_time_in_force` | None | Configure time in force for buy and sell orders. [More information below](#understand-order_time_in_force). [Strategy Override](#parameters-in-the-strategy).
+| `exchange.name` |  | **Required.** Name of the exchange class to use. [List below](#user-content-what-values-for-exchangename).
+| `exchange.sandbox` | false | Use the 'sandbox' version of the exchange, where the exchange provides a sandbox for risk-free integration. See [here](sandbox-testing.md) in more details.
+| `exchange.key` | '' | API key to use for the exchange. Only required when you are in production mode.
+| `exchange.secret` | '' | API secret to use for the exchange. Only required when you are in production mode.
+| `exchange.pair_whitelist` | [] | List of pairs to use by the bot for trading and to check for potential trades during backtesting. Can be overriden by dynamic pairlists (see [below](#dynamic-pairlists)).
+| `exchange.pair_blacklist` | [] | List of pairs the bot must absolutely avoid for trading and backtesting. Can be overriden by dynamic pairlists (see [below](#dynamic-pairlists)).
+| `exchange.ccxt_config` | None | Additional CCXT parameters passed to the regular 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)
+| `exchange.ccxt_async_config` | None | 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)
+| `exchange.markets_refresh_interval` | 60 | The interval in minutes in which markets are reloaded.
+| `edge` | false | Please refer to [edge configuration document](edge.md) for detailed explanation.
+| `experimental.use_sell_signal` | false | Use your sell strategy in addition of the `minimal_roi`. [Strategy Override](#parameters-in-the-strategy).
+| `experimental.sell_profit_only` | false | Waits until you have made a positive profit before taking a sell decision. [Strategy Override](#parameters-in-the-strategy).
+| `experimental.ignore_roi_if_buy_signal` | false | Does not sell if the buy-signal is still active. Takes preference over `minimal_roi` and `use_sell_signal`. [Strategy Override](#parameters-in-the-strategy).
+| `experimental.block_bad_exchanges` | true | Block exchanges known to not work with freqtrade. Leave on default unless you want to test if that exchange works now.
+| `pairlist.method` | StaticPairList | Use static or dynamic volume-based pairlist. [More information below](#dynamic-pairlists).
+| `pairlist.config` | None | Additional configuration for dynamic pairlists. [More information below](#dynamic-pairlists).
+| `telegram.enabled` | true | **Required.** Enable or not the usage of Telegram.
+| `telegram.token` | token | Your Telegram bot token. Only required if `telegram.enabled` is `true`.
+| `telegram.chat_id` | chat_id | Your personal Telegram account id. Only required if `telegram.enabled` is `true`.
+| `webhook.enabled` | false | Enable usage of Webhook notifications
+| `webhook.url` | false | URL for the webhook. Only required if `webhook.enabled` is `true`. See the [webhook documentation](webhook-config.md) for more details.
+| `webhook.webhookbuy` | false | Payload to send on buy. Only required if `webhook.enabled` is `true`. See the [webhook documentationV](webhook-config.md) for more details.
+| `webhook.webhooksell` | false | Payload to send on sell. Only required if `webhook.enabled` is `true`. See the [webhook documentationV](webhook-config.md) for more details.
+| `webhook.webhookstatus` | false | Payload to send on status calls. Only required if `webhook.enabled` is `true`. See the [webhook documentationV](webhook-config.md) for more details.
+| `db_url` | `sqlite:///tradesv3.sqlite`| Declares database URL to use. NOTE: This defaults to `sqlite://` if `dry_run` is `True`.
+| `initial_state` | running | Defines the initial application state. More information below.
+| `forcebuy_enable` | false | Enables the RPC Commands to force a buy. More information below.
+| `strategy` | DefaultStrategy | Defines Strategy class to use.
+| `strategy_path` | null | Adds an additional strategy lookup path (must be a directory).
+| `internals.process_throttle_secs` | 5 | **Required.** Set the process throttle. Value in second.
+| `internals.sd_notify` | false | Enables use of the sd_notify protocol to tell systemd service manager about changes in the bot state and issue keep-alive pings. See [here](installation.md#7-optional-configure-freqtrade-as-a-systemd-service) for more details.
+| `logfile` | | Specify Logfile. Uses a rolling strategy of 10 files, with 1Mb per file.
+| `user_data_dir` | cwd()/user_data | Directory containing user data. Defaults to `./user_data/`.
+
+### Parameters in the strategy
+
+The following parameters can be set in either configuration file or strategy.
+Values set in the configuration file always overwrite values set in the strategy.
+
+* `stake_currency`
+* `stake_amount`
+* `ticker_interval`
+* `minimal_roi`
+* `stoploss`
+* `trailing_stop`
+* `trailing_stop_positive`
+* `trailing_stop_positive_offset`
+* `process_only_new_candles`
+* `order_types`
+* `order_time_in_force`
+* `use_sell_signal` (experimental)
+* `sell_profit_only` (experimental)
+* `ignore_roi_if_buy_signal` (experimental)
 
 ### Understand stake_amount
 
-`stake_amount` is an amount of crypto-currency your bot will use for each trade.
+The `stake_amount` configuration parameter is an amount of crypto-currency your bot will use for each trade.
 The minimal value is 0.0005. If there is not enough crypto-currency in
 the account an exception is generated.
-To allow the bot to trade all the avaliable `stake_currency` in your account set `stake_amount` = `unlimited`.
+To allow the bot to trade all the available `stake_currency` in your account set
-In this case a trade amount is calclulated as `currency_balanse / (max_open_trades - current_open_trades)`.
+
+```json
+"stake_amount" : "unlimited",
+```
+
+In this case a trade amount is calclulated as:
+
+```python
+currency_balanse / (max_open_trades - current_open_trades)
+```
 
 ### Understand minimal_roi
 
-`minimal_roi` is a JSON object where the key is a duration
+The `minimal_roi` configuration parameter is a JSON object where the key is a duration
 in minutes and the value is the minimum ROI in percent.
 See the example below:
 
-```
+```json
 "minimal_roi": {
     "40": 0.0,    # Sell after 40 minutes if the profit is not negative
     "30": 0.01,   # Sell after 30 minutes if there is at least 1% profit
@@ -95,95 +145,145 @@ See the example below:
 },
 ```
 
-Most of the strategy files already include the optimal `minimal_roi`
+Most of the strategy files already include the optimal `minimal_roi` value.
-value. This parameter is optional. If you use it, it will take over the
+This parameter can be set in either Strategy or Configuration file. If you use it in the configuration file, it will override the
 `minimal_roi` value from the strategy file.
+If it is not set in either Strategy or Configuration, a default of 1000% `{"0": 10}` is used, and minimal roi is disabled unless your trade generates 1000% profit.
 
 ### Understand stoploss
 
-`stoploss` is loss in percentage that should trigger a sale.
+Go to the [stoploss documentation](stoploss.md) for more details.
-For example value `-0.10` will cause immediate sell if the
-profit dips below -10% for a given trade. This parameter is optional.
-
-Most of the strategy files already include the optimal `stoploss`
-value. This parameter is optional. If you use it, it will take over the
-`stoploss` value from the strategy file.
 
 ### Understand trailing stoploss
 
-Go to the [trailing stoploss Documentation](stoploss.md) for details on trailing stoploss.
+Go to the [trailing stoploss Documentation](stoploss.md#trailing-stop-loss) for details on trailing stoploss.
 
 ### Understand initial_state
 
-`initial_state` is an optional field that defines the initial application state.
+The `initial_state` configuration parameter is an optional field that defines the initial application state.
 Possible values are `running` or `stopped`. (default=`running`)
 If the value is `stopped` the bot has to be started with `/start` first.
 
 ### Understand forcebuy_enable
 
-`forcebuy_enable` enables the usage of forcebuy commands via Telegram.
+The `forcebuy_enable` configuration parameter enables the usage of forcebuy commands via Telegram.
 This is disabled for security reasons by default, and will show a warning message on startup if enabled.
-You send `/forcebuy ETH/BTC` to the bot, who buys the pair and holds it until a regular sell-signal appears (ROI, stoploss, /forcesell).
+For example, you can send `/forcebuy ETH/BTC` Telegram command when this feature if enabled to the bot,
+who then buys the pair and holds it until a regular sell-signal (ROI, stoploss, /forcesell) appears.
+
+This can be dangerous with some strategies, so use with care.
 
-Can be dangerous with some strategies, so use with care
 See [the telegram documentation](telegram-usage.md) for details on usage.
 
 ### Understand process_throttle_secs
 
-`process_throttle_secs` is an optional field that defines in seconds how long the bot should wait
+The `process_throttle_secs` configuration parameter is an optional field that defines in seconds how long the bot should wait
 before asking the strategy if we should buy or a sell an asset. After each wait period, the strategy is asked again for
 every opened trade wether or not we should sell, and for all the remaining pairs (either the dynamic list of pairs or
 the static list of pairs) if we should buy.
 
 ### Understand ask_last_balance
 
-`ask_last_balance` sets the bidding price. Value `0.0` will use `ask` price, `1.0` will
+The `ask_last_balance` configuration parameter sets the bidding price. Value `0.0` will use `ask` price, `1.0` will
 use the `last` price and values between those interpolate between ask and last
 price. Using `ask` price will guarantee quick success in bid, but bot will also
 end up paying more then would probably have been necessary.
 
 ### Understand order_types
 
-`order_types` contains a dict mapping order-types to market-types as well as stoploss on or off exchange type. This allows to buy using limit orders, sell using limit-orders, and create stoploss orders using market. It also allows to set the stoploss "on exchange" which means stoploss order would be placed immediately once the buy order is fulfilled.
+The `order_types` configuration parameter contains a dict mapping order-types to
-This can be set in the configuration or in the strategy. Configuration overwrites strategy configurations.
+market-types as well as stoploss on or off exchange type and stoploss on exchange
+update interval in seconds. This allows to buy using limit orders, sell using
+limit-orders, and create stoploss orders using market. It also allows to set the
+stoploss "on exchange" which means stoploss order would be placed immediately once
+the buy order is fulfilled. In case stoploss on exchange and `trailing_stop` are
+both set, then the bot will use `stoploss_on_exchange_interval` to check it periodically
+and update it if necessary (e.x. in case of trailing stoploss).
+This can be set in the configuration file or in the strategy.
+Values set in the configuration file  overwrites values set in the strategy.
 
-If this is configured, all 4 values (`"buy"`, `"sell"`, `"stoploss"`, `"stoploss_on_exchange"`) need to be present, otherwise the bot warn about it and will fail to start.
+If this is configured, all 4 values (`buy`, `sell`, `stoploss` and
-The below is the default which is used if this is not configured in either Strategy or configuration.
+`stoploss_on_exchange`) need to be present, otherwise the bot will warn about it and fail to start.
+The below is the default which is used if this is not configured in either strategy or configuration file.
 
-``` python
+Syntax for Strategy:
-    "order_types": {
+
-        "buy": "limit",
+```python
-        "sell": "limit",
+order_types = {
-        "stoploss": "market",
+    "buy": "limit",
-        "stoploss_on_exchange": False
+    "sell": "limit",
-    },
+    "stoploss": "market",
+    "stoploss_on_exchange": False,
+    "stoploss_on_exchange_interval": 60
+}
 ```
 
-**NOTE**: Not all exchanges support "market" orders.
+Configuration:
-The following message will be shown if your exchange does not support market orders: `"Exchange <yourexchange>  does not support market orders."`
+
+```json
+"order_types": {
+    "buy": "limit",
+    "sell": "limit",
+    "stoploss": "market",
+    "stoploss_on_exchange": false,
+    "stoploss_on_exchange_interval": 60
+}
+```
+
+!!! Note
+    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."`
+
+!!! Note
+    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
+    read [the stoploss documentation](stoploss.md).
+
+!!! Note
+    In case of stoploss on exchange if the stoploss is cancelled manually then
+    the bot would recreate one.
 
 ### Understand order_time_in_force
-Order time in force defines the policy by which the order is executed on the exchange. Three commonly used time in force are:<br/>
+
-**GTC (Goog Till Canceled):**
+The `order_time_in_force` configuration parameter defines the policy by which the order
-This is most of the time the default time in force. It means the order will remain on exchange till it is canceled by user. It can be fully or partially fulfilled. If partially fulfilled, the remaining will stay on the exchange till cancelled.<br/>
+is executed on the exchange. Three commonly used time in force are:
+
+**GTC (Good Till Canceled):**
+
+This is most of the time the default time in force. It means the order will remain
+on exchange till it is canceled by user. It can be fully or partially fulfilled.
+If partially fulfilled, the remaining will stay on the exchange till cancelled.
+
 **FOK (Full Or Kill):**
-It means if the order is not executed immediately AND fully then it is canceled by the exchange.<br/>
+
+It means if the order is not executed immediately AND fully then it is canceled by the exchange.
+
 **IOC (Immediate Or Canceled):**
-It is the same as FOK (above) except it can be partially fulfilled. The remaining part is automatically cancelled by the exchange.
+
-<br/>
+It is the same as FOK (above) except it can be partially fulfilled. The remaining part
-`order_time_in_force` contains a dict buy and sell time in force policy. This can be set in the configuration or in the strategy. Configuration overwrites strategy configurations.<br/>
+is automatically cancelled by the exchange.
-possible values are: `gtc` (default), `fok` or `ioc`.<br/>
+
+The `order_time_in_force` parameter contains a dict with buy and sell time in force policy values.
+This can be set in the configuration file or in the strategy.
+Values set in the configuration file overwrites values set in the strategy.
+
+The possible values are: `gtc` (default), `fok` or `ioc`.
+
 ``` python
-    "order_time_in_force": {
+"order_time_in_force": {
-        "buy": "gtc",
+    "buy": "gtc",
-        "sell": "gtc"
+    "sell": "gtc"
-    },
+},
 ```
-**NOTE**: This is an ongoing work. For now it is supported only for binance and only for buy orders. Please don't change the default value unless you know what you are doing.<br/>
 
-### What values for exchange.name?
+!!! Warning
+    This is an ongoing work. For now it is supported only for binance and only for buy orders.
+    Please don't change the default value unless you know what you are doing.
 
-Freqtrade is based on [CCXT library](https://github.com/ccxt/ccxt) that supports 115 cryptocurrency
+### Exchange configuration
+
+Freqtrade is based on [CCXT library](https://github.com/ccxt/ccxt) that supports over 100 cryptocurrency
 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
 with only Bittrex and Binance.
@@ -195,31 +295,84 @@ The bot was tested with the following exchanges:
 
 Feel free to test other exchanges and submit your PR to improve the bot.
 
-### What values for fiat_display_currency?
+#### Sample exchange configuration
 
-`fiat_display_currency` set the base currency to use for the conversion from coin to fiat in Telegram.
+A exchange configuration for "binance" would look as follows:
-The valid values are: "AUD", "BRL", "CAD", "CHF", "CLP", "CNY", "CZK", "DKK", "EUR", "GBP", "HKD", "HUF", "IDR", "ILS", "INR", "JPY", "KRW", "MXN", "MYR", "NOK", "NZD", "PHP", "PKR", "PLN", "RUB", "SEK", "SGD", "THB", "TRY", "TWD", "ZAR", "USD".
-In addition to central bank currencies, a range of cryto currencies are supported.
-The valid values are: "BTC", "ETH", "XRP", "LTC", "BCH", "USDT".
 
-## Switch to dry-run mode
+```json
+"exchange": {
+    "name": "binance",
+    "key": "your_exchange_key",
+    "secret": "your_exchange_secret",
+    "ccxt_config": {"enableRateLimit": true},
+    "ccxt_async_config": {
+        "enableRateLimit": true,
+        "rateLimit": 200
+    },
+```
 
-We recommend starting the bot in dry-run mode to see how your bot will
+This configuration enables binance, as well as rate limiting to avoid bans from the exchange.
-behave and how is the performance of your strategy. In Dry-run mode the
+`"rateLimit": 200` defines a wait-event of 0.2s between each call. This can also be completely disabled by setting `"enableRateLimit"` to false.
+
+!!! Note
+    Optimal settings for rate limiting depend on the exchange and the size of the whitelist, so an ideal parameter will vary on many other settings.
+    We try to provide sensible defaults per exchange where possible, if you encounter bans please make sure that `"enableRateLimit"` is enabled and increase the `"rateLimit"` parameter step by step.
+
+#### Advanced FreqTrade Exchange configuration
+
+Advanced options can be configured using the `_ft_has_params` setting, which will override Defaults and exchange-specific behaviours.
+
+Available options are listed in the exchange-class as `_ft_has_default`.
+
+For example, to test the order type `FOK` with Kraken, and modify candle_limit to 200 (so you only get 200 candles per call):
+
+```json
+"exchange": {
+    "name": "kraken",
+    "_ft_has_params": {
+        "order_time_in_force": ["gtc", "fok"],
+        "ohlcv_candle_limit": 200
+        }
+```
+
+!!! Warning
+    Please make sure to fully understand the impacts of these settings before modifying them.
+
+### What values can be used for fiat_display_currency?
+
+The `fiat_display_currency` configuration parameter sets the base currency to use for the
+conversion from coin to fiat in the bot Telegram reports.
+
+The valid values are:
+
+```json
+"AUD", "BRL", "CAD", "CHF", "CLP", "CNY", "CZK", "DKK", "EUR", "GBP", "HKD", "HUF", "IDR", "ILS", "INR", "JPY", "KRW", "MXN", "MYR", "NOK", "NZD", "PHP", "PKR", "PLN", "RUB", "SEK", "SGD", "THB", "TRY", "TWD", "ZAR", "USD"
+```
+
+In addition to fiat currencies, a range of cryto currencies are supported.
+
+The valid values are:
+
+```json
+"BTC", "ETH", "XRP", "LTC", "BCH", "USDT"
+```
+
+## Switch to Dry-run mode
+
+We recommend starting the bot in the Dry-run mode to see how your bot will
+behave and what is the performance of your strategy. In the Dry-run mode the
 bot does not engage your money. It only runs a live simulation without
-creating trades.
+creating trades on the exchange.
 
-### To switch your bot in Dry-run mode:
+1. Edit your `config.json` configuration file.
-
+2. Switch `dry-run` to `true` and specify `db_url` for a persistence database.
-1. Edit your `config.json`  file
-2. Switch dry-run to true and specify db_url for a persistent db
 
 ```json
 "dry_run": true,
-"db_url": "sqlite///tradesv3.dryrun.sqlite",
+"db_url": "sqlite:///tradesv3.dryrun.sqlite",
 ```
 
-3. Remove your Exchange API key (change them by fake api credentials)
+3. Remove your Exchange API key and secrete (change them by empty values or fake credentials):
 
 ```json
 "exchange": {
@@ -230,51 +383,59 @@ creating trades.
 }
 ```
 
-Once you will be happy with your bot performance, you can switch it to
+Once you will be happy with your bot performance running in the Dry-run mode,
-production mode.
+you can switch it to production mode.
 
 ### Dynamic Pairlists
 
 Dynamic pairlists select pairs for you based on the logic configured.
-The bot runs against all pairs (with that stake) on the exchange, and a number of assets (`number_assets`) is selected based on the selected criteria.
+The bot runs against all pairs (with that stake) on the exchange, and a number of assets
+(`number_assets`) is selected based on the selected criteria.
 
-By *default*, a Static Pairlist is used (configured as `"pair_whitelist"` under the `"exchange"` section of this configuration).
+By default, the `StaticPairList` method is used.
+The Pairlist method is configured as `pair_whitelist` parameter under the `exchange`
+section of the configuration.
 
-#### Available Pairlist methods
+**Available Pairlist methods:**
 
-* `"StaticPairList"`
+* `StaticPairList`
-  * uses configuration from `exchange.pair_whitelist` and `exchange.pair_blacklist`
+  * It uses configuration from `exchange.pair_whitelist` and `exchange.pair_blacklist`.
-* `"VolumePairList"`
+* `VolumePairList`
-  * Formerly available as `--dynamic-whitelist [<number_assets>]`
+  * It selects `number_assets` top pairs based on `sort_key`, which can be one of
-  * Selects `number_assets` top pairs based on `sort_key`, which can be one of `askVolume`, `bidVolume` and `quoteVolume`, defaults to `quoteVolume`.
+`askVolume`, `bidVolume` and `quoteVolume`, defaults to `quoteVolume`.
+  * There is a possibility to filter low-value coins that would not allow setting a stop loss
+(set `precision_filter` parameter to `true` for this).
+
+Example:
 
 ```json
 "pairlist": {
         "method": "VolumePairList",
         "config": {
             "number_assets": 20,
-            "sort_key": "quoteVolume"
+            "sort_key": "quoteVolume",
+            "precision_filter": false
         }
     },
 ```
 
 ## Switch to production mode
 
-In production mode, the bot will engage your money. Be careful a wrong
+In production mode, the bot will engage your money. Be careful, since a wrong
 strategy can lose all your money. Be aware of what you are doing when
 you run it in production mode.
 
 ### To switch your bot in production mode
 
-1. Edit your `config.json`  file
+**Edit your `config.json`  file.**
 
-2. Switch dry-run to false and don't forget to adapt your database URL if set
+**Switch dry-run to false and don't forget to adapt your database URL if set:**
 
 ```json
 "dry_run": false,
 ```
 
-3. Insert your Exchange API key (change them by fake api keys)
+**Insert your Exchange API key (change them by fake api keys):**
 
 ```json
 "exchange": {
@@ -285,8 +446,8 @@ you run it in production mode.
 }
 
 ```
-
+!!! Note
-If you have not your Bittrex API key yet, [see our tutorial](https://github.com/freqtrade/freqtrade/blob/develop/docs/pre-requisite.md).
+    If you have an exchange API key yet, [see our tutorial](/pre-requisite).
 
 ### Using proxy with FreqTrade
 
@@ -337,4 +498,4 @@ Please ensure that 'NameOfStrategy' is identical to the strategy name!
 
 ## Next step
 
-Now you have configured your config.json, the next step is to [start your bot](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md).
+Now you have configured your config.json, the next step is to [start your bot](bot-usage.md).

docs/data-analysis.md

@@ -0,0 +1,202 @@
+# 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/`.  
+
+## 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.
+
+## 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.
+
+## Recommended workflow  
+
+| Task | Tool |  
+  --- | ---  
+Bot operations | CLI  
+Repetitive tasks | Shell scripts
+Data analysis & visualization | Notebook  
+
+1. Use the CLI to
+    * download historical data
+    * run a backtest
+    * run with real-time data
+    * export results  
+
+1. Collect these actions in shell scripts
+    * save complicated commands with arguments
+    * execute multi-step operations  
+    * automate testing strategies and preparing data for analysis
+
+1. Use a notebook to
+    * visualize data
+    * munge and plot to generate insights
+
+## Example utility snippets  
+
+### Change directory to root  
+
+Jupyter notebooks execute from the notebook directory. The following snippet searches for the project root, so relative paths remain consistent.
+
+```python
+import os
+from pathlib import Path
+
+# Change directory
+# Modify this cell to insure that the output shows the correct path.
+# Define all paths relative to the project root shown in the cell output
+project_root = "somedir/freqtrade"
+i=0
+try:
+    os.chdirdir(project_root)
+    assert Path('LICENSE').is_file()
+except:
+    while i<4 and (not Path('LICENSE').is_file()):
+        os.chdir(Path(Path.cwd(), '../'))
+        i+=1
+    project_root = Path.cwd()
+print(Path.cwd())
+```
+
+## Load existing objects into a Jupyter notebook
+
+These examples assume that you have already generated data using the cli. They will allow you to drill deeper into your results, and perform analysis which otherwise would make the output very difficult to digest due to information overload.
+
+### Load backtest results into a pandas dataframe
+
+```python
+from freqtrade.data.btanalysis import load_backtest_data
+
+# Load backtest results
+df = load_backtest_data("user_data/backtest_results/backtest-result.json")
+
+# Show value-counts per pair
+df.groupby("pair")["sell_reason"].value_counts()
+```
+
+### Load live trading results into a pandas dataframe
+
+``` python
+from freqtrade.data.btanalysis import load_trades_from_db
+
+# Fetch trades from database
+df = load_trades_from_db("sqlite:///tradesv3.sqlite")
+
+# Display results
+df.groupby("pair")["sell_reason"].value_counts()
+```
+
+### Load multiple configuration files
+
+This option can be useful to inspect the results of passing in multiple configs
+
+``` python
+import json
+from freqtrade.configuration import Configuration
+
+# Load config from multiple files
+config = Configuration.from_files(["config1.json", "config2.json"])
+
+# Show the config in memory
+print(json.dumps(config, indent=1))
+```
+
+### Load exchange data to a pandas dataframe
+
+This loads candle data to a dataframe
+
+```python
+from pathlib import Path
+from freqtrade.data.history import load_pair_history
+
+# Load data using values passed to function
+ticker_interval = "5m"
+data_location = Path('user_data', 'data', 'bitrex')
+pair = "BTC_USDT"
+candles = load_pair_history(datadir=data_location,
+                            ticker_interval=ticker_interval,
+                            pair=pair)
+
+# Confirm success
+print(f"Loaded len(candles) rows of data for {pair} from {data_location}")
+candles.head()
+```
+
+## Strategy debugging example  
+
+Debugging a strategy can be time-consuming. FreqTrade offers helper functions to visualize raw data.
+
+### Define variables used in analyses  
+
+You can override strategy settings as demonstrated below.
+
+```python
+# Customize these according to your needs.
+
+# Define some constants
+ticker_interval = "5m"
+# Name of the strategy class
+strategy_name = 'TestStrategy'
+# Path to user data
+user_data_dir = 'user_data'
+# Location of the strategy
+strategy_location = Path(user_data_dir, 'strategies')
+# Location of the data
+data_location = Path(user_data_dir, 'data', 'binance')
+# Pair to analyze - Only use one pair here
+pair = "BTC_USDT"
+```
+
+### Load exchange data
+
+```python
+from pathlib import Path
+from freqtrade.data.history import load_pair_history
+
+# Load data using values set above
+candles = load_pair_history(datadir=data_location,
+                            ticker_interval=ticker_interval,
+                            pair=pair)
+
+# Confirm success
+print(f"Loaded {len(candles)} rows of data for {pair} from {data_location}")
+candles.head()
+```
+
+### Load and run strategy  
+
+* Rerun each time the strategy file is changed
+
+```python
+from freqtrade.resolvers import StrategyResolver
+
+# Load strategy using values set above
+strategy = StrategyResolver({'strategy': strategy_name,
+                            'user_data_dir': user_data_dir,
+                            'strategy_path': strategy_location}).strategy
+
+# Generate buy/sell signals using strategy
+df = strategy.analyze_ticker(candles, {'pair': pair})
+```
+
+### Display the trade details
+
+* Note that using `data.tail()` is preferable to `data.head()` as most indicators have some "startup" data at the top of the dataframe.
+* Some possible problems
+    * Columns with NaN values at the end of the dataframe
+    * Columns used in `crossed*()` functions with completely different units
+* Comparison with full backtest
+    * having 200 buy signals as output for one pair from `analyze_ticker()` does not necessarily mean that 200 trades will be made during backtesting.
+    * Assuming you use only one condition such as, `df['rsi'] < 30` as buy condition, this will generate multiple "buy" signals for each pair in sequence (until rsi returns > 29). The bot will only buy on the first of these signals (and also only if a trade-slot ("max_open_trades") is still available), or on one of the middle signals, as soon as a "slot" becomes available.  
+
+```python
+# Report results
+print(f"Generated {df['buy'].sum()} buy signals")
+data = df.set_index('date', drop=True)
+data.tail()
+```
+
+Feel free to submit an issue or Pull Request enhancing this document if you would like to share ideas on how to best analyze the data.

docs/deprecated.md

@@ -0,0 +1,28 @@
+# Deprecated features
+
+This page contains description of the command line arguments, configuration parameters
+and the bot features that were declared as DEPRECATED by the bot development team
+and are no longer supported. Please avoid their usage in your configuration.
+
+## Deprecated
+
+### the `--refresh-pairs-cached` command line option
+
+`--refresh-pairs-cached` in the context of backtesting, hyperopt and edge allows to refresh candle data for backtesting.
+Since this leads to much confusion, and slows down backtesting (while not being part of backtesting) this has been singled out 
+as a seperate freqtrade subcommand `freqtrade download-data`.
+
+This command line option was deprecated in `2019.7-dev` and will be removed after the next release.
+
+## Removed features
+
+### The **--dynamic-whitelist** command line option
+
+This command line option was deprecated in 2018 and removed freqtrade 2019.6-dev (develop branch)
+and in freqtrade 2019.7 (master branch).
+
+### the `--live` command line option
+
+`--live` in the context of backtesting allowed to download the latest tick data for backtesting.
+Did only download the latest 500 candles, so was ineffective in getting good backtest data.
+Removed in 2019-7-dev (develop branch) and in freqtrade 2019-8 (master branch)

docs/developer.md

@@ -2,10 +2,45 @@
 
 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/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE) 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 in [slack](https://join.slack.com/t/highfrequencybot/shared_invite/enQtNjU5ODcwNjI1MDU3LWEyODBiNzkzNzcyNzU0MWYyYzE5NjIyOTQxMzBmMGUxOTIzM2YyN2Y4NWY1YTEwZDgwYTRmMzE2NmM5ZmY2MTg) where you can ask questions.
 
+## Documentation
 
-## Module 
+Documentation is available at [https://freqtrade.io](https://www.freqtrade.io/) and needs to be provided with every new feature PR.
+
+Special fields for the documentation (like Note boxes, ...) can be found [here](https://squidfunk.github.io/mkdocs-material/extensions/admonition/).
+
+## 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]`.
+
+This will install all required tools for development, including `pytest`, `flake8`, `mypy`, and `coveralls`.
+
+### Tests
+
+New code should be covered by basic unittests. Depending on the complexity of the feature, Reviewers may request more in-depth unittests.
+If necessary, the Freqtrade team can assist and give guidance with writing good tests (however please don't expect anyone to write the tests for you).
+
+#### Checking log content in tests
+
+Freqtrade uses 2 main methods to check log content in tests, `log_has()` and `log_has_re()` (to check using regex, in case of dynamic log-messages).
+These are available from `conftest.py` and can be imported in any test module.
+
+A sample check looks as follows:
+
+``` python
+from freqtrade.tests.conftest import log_has, log_has_re
+
+def test_method_to_test(caplog):
+    method_to_test()
+
+    assert log_has("This event happened", caplog)
+    # Check regex with trailing number ...
+    assert log_has_re(r"This dynamic event happened and produced \d+", caplog)
+```
+
+## Modules
 
 ### Dynamic Pairlist
 
@@ -68,3 +103,90 @@ Please also run `self._validate_whitelist(pairs)` and to check and remove pairs
 
 This is a simple method used by `VolumePairList` - however serves as a good example.
 It implements caching (`@cached(TTLCache(maxsize=1, ttl=1800))`) as well as a configuration option to allow different (but similar) strategies to work with the same PairListProvider.
+
+## Implement a new Exchange (WIP)
+
+!!! Note
+    This section is a Work in Progress and is not a complete guide on how to test a new exchange with FreqTrade.
+
+Most exchanges supported by CCXT should work out of the box.
+
+### Stoploss On Exchange
+
+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.
+
+### Incomplete candles
+
+While fetching OHLCV data, we're may end up getting incomplete candles (Depending on the exchange).
+To demonstrate this, we'll use daily candles (`"1d"`) to keep things simple.
+We query the api (`ct.fetch_ohlcv()`) for the timeframe and look at the date of the last entry. If this entry changes or shows the date of a "incomplete" candle, then we should drop this since having incomplete candles is problematic because indicators assume that only complete candles are passed to them, and will generate a lot of false buy signals. By default, we're therefore removing the last candle assuming it's incomplete.
+
+To check how the new exchange behaves, you can use the following snippet:
+
+``` python
+import ccxt
+from datetime import datetime
+from freqtrade.data.converter import parse_ticker_dataframe
+ct = ccxt.binance()
+timeframe = "1d"
+pair = "XLM/BTC"  # Make sure to use a pair that exists on that exchange!
+raw = ct.fetch_ohlcv(pair, timeframe=timeframe)
+
+# convert to dataframe
+df1 = parse_ticker_dataframe(raw, timeframe, pair=pair, drop_incomplete=False)
+
+print(df1["date"].tail(1))
+print(datetime.utcnow())
+```
+
+``` output
+19   2019-06-08 00:00:00+00:00
+2019-06-09 12:30:27.873327
+```
+
+The output will show the last entry from the Exchange as well as the current UTC date.
+If the day shows the same day, then the last candle can be assumed as incomplete and should be dropped (leave the setting `"ohlcv_partial_candle"` from the exchange-class untouched / True). Otherwise, set `"ohlcv_partial_candle"` to `False` to not drop Candles (shown in the example above).
+
+## Creating a release
+
+This part of the documentation is aimed at maintainers, and shows how to create a release.
+
+### Create release branch
+
+``` bash
+# make sure you're in develop branch
+git checkout develop
+
+# create new branch
+git checkout -b new_release
+```
+
+* 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.
+* Commit this part
+* push that branch to the remote and create a PR against the master branch
+
+### Create changelog from git commits
+
+!!! Note
+    Make sure that both master and develop are up-todate!.
+
+``` bash
+# Needs to be done before merging / pulling that branch.
+git log --oneline --no-decorate --no-merges master..develop
+```
+
+### Create github release / tag
+
+Once the PR against master 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 the above changelog as release comment (as codeblock)
+
+### After-release
+
+* Update version in develop by postfixing that with `-dev` (`2019.6 -> 2019.6-dev`).
+* Create a PR against develop to update that branch.

docs/docker.md

@@ -0,0 +1,208 @@
+# 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/)
+
+Once you have Docker installed, simply prepare the config file (e.g. `config.json`) and run the image for `freqtrade` as explained below.
+
+## Download the official FreqTrade docker image
+
+Pull the image from docker hub.
+
+Branches / tags available can be checked out on [Dockerhub](https://hub.docker.com/r/freqtradeorg/freqtrade/tags/).
+
+```bash
+docker pull freqtradeorg/freqtrade:develop
+# Optionally tag the repository so the run-commands remain shorter
+docker tag freqtradeorg/freqtrade:develop freqtrade
+```
+
+To update the image, simply run the above commands again and restart your running container.
+
+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.
+    In addition to that, every merge to `develop` will trigger a rebuild for `develop` and `latest`.
+
+### Prepare the configuration files
+
+Even though you will use docker, you'll still need some files from the github repository.
+
+#### Clone the git repository
+
+Linux/Mac/Windows with WSL
+
+```bash
+git clone https://github.com/freqtrade/freqtrade.git
+```
+
+Windows with docker
+
+```bash
+git clone --config core.autocrlf=input https://github.com/freqtrade/freqtrade.git
+```
+
+#### Copy `config.json.example` to `config.json`
+
+```bash
+cd freqtrade
+cp -n config.json.example config.json
+```
+
+> To understand the configuration options, please refer to the [Bot Configuration](configuration.md) page.
+
+#### Create your database file
+
+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.
+
+### 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.
+
+```bash
+docker build -t freqtrade -f Dockerfile.technical .
+```
+
+If you are developing using Docker, use `Dockerfile.develop` to build a dev Docker image, which will also set up develop dependencies:
+
+```bash
+docker build -f 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.
+
+#### Verify the Docker image
+
+After the build process you can verify that the image was created with:
+
+```bash
+docker images
+```
+
+The output should contain the freqtrade image.
+
+### Run the Docker image
+
+You can run a one-off container that is immediately deleted upon exiting with the following command (`config.json` must be in the current working directory):
+
+```bash
+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.
+
+#### Adjust timezone
+
+By default, the container will use UTC timezone.
+Should you find this irritating please add the following to your docker commands:
+
+##### Linux
+
+``` 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
+```
+
+##### 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).
+
+### 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
+
+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.
+
+```bash
+mkdir ~/.freqtrade
+mv config.json ~/.freqtrade
+mv tradesv3.sqlite ~/.freqtrade
+```
+
+#### Run the docker image
+
+```bash
+docker run -d \
+  --name freqtrade \
+  -v ~/.freqtrade/config.json:/freqtrade/config.json \
+  -v ~/.freqtrade/user_data/:/freqtrade/user_data \
+  -v ~/.freqtrade/tradesv3.sqlite:/freqtrade/tradesv3.sqlite \
+  freqtrade --db-url sqlite:///tradesv3.sqlite --strategy MyAwesomeStrategy
+```
+
+!!! Note
+    db-url defaults to `sqlite:///tradesv3.sqlite` but it defaults to `sqlite://` if `dry_run=True` is being used.
+    To override this behaviour use a custom db-url value: i.e.: `--db-url sqlite:///tradesv3.dryrun.sqlite`
+
+!!! Note
+    All available bot command line parameters can be added to the end of the `docker run` command.
+
+### Monitor your Docker instance
+
+You can use the following commands to monitor and manage your container:
+
+```bash
+docker logs freqtrade
+docker logs -f freqtrade
+docker restart freqtrade
+docker stop freqtrade
+docker start freqtrade
+```
+
+For more information on how to operate Docker, please refer to the [official Docker documentation](https://docs.docker.com/).
+
+!!! Note
+    You do not need to rebuild the image for configuration changes, it will suffice to edit `config.json` and restart the container.
+
+### Backtest with docker
+
+The following assumes that the download/setup of the docker image have been completed successfully.
+Also, backtest-data should be available at `~/.freqtrade/user_data/`.
+
+```bash
+docker run -d \
+  --name freqtrade \
+  -v /etc/localtime:/etc/localtime:ro \
+  -v ~/.freqtrade/config.json:/freqtrade/config.json \
+  -v ~/.freqtrade/tradesv3.sqlite:/freqtrade/tradesv3.sqlite \
+  -v ~/.freqtrade/user_data/:/freqtrade/user_data/ \
+  freqtrade --strategy AwsomelyProfitableStrategy backtesting
+```
+
+Head over to the [Backtesting Documentation](backtesting.md) for more details.
+
+!!! Note
+    Additional bot command line parameters can be appended after the image name (`freqtrade` in the above example).

docs/edge.md

@@ -2,170 +2,214 @@
 
 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.
 
-**NOTICE:** Edge positioning is not compatible with dynamic whitelist. it overrides dynamic whitelist.
+!!! Warning
-**NOTICE2:** Edge won't consider anything else than buy/sell/stoploss signals. So trailing stoploss, ROI, and everything else will be ignored in its calculation.
+    Edge positioning is not compatible with dynamic (volume-based) whitelist.
 
-## Table of Contents
+!!! Note
-
+    Edge does not consider anything else than buy/sell/stoploss signals. So trailing stoploss, ROI, and everything else are ignored in its calculation.
-- [Introduction](#introduction)
-- [How does it work?](#how-does-it-work?)
-- [Configurations](#configurations)
-- [Running Edge independently](#running-edge-independently)
 
 ## 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.<br/><br/>
+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.
-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 is quite boring, isn't it?<br/><br/>
+
-But let's say the probability that we have heads is 80%, and the probability that we have tails is 20%. Now it is becoming interesting ...
+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?
-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.<br/><br/>
+
-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% * 2$ versus 20% * 8$. It is becoming boring again because overtime you win $1.6$ (80% x 2$) and me $1.6 (20% * 8$) too.<br/><br/>
+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...
-The question is: How do you calculate that? how do you know if you wanna play?
+
+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.
+
+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.
+
+The question is: How do you calculate that? How do you know if you wanna play?
+
 The answer comes to two factors:
 - Win Rate
 - Risk Reward Ratio
 
-
 ### Win Rate
-Means over X trades 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).
+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).
 
+    W = (Number of winning trades) / (Total number of trades) = (Number of winning trades) / N
 
-`W = (Number of winning trades) / (Number of losing trades)`
+Complementary Loss Rate (*L*) is defined as
+
+    L = (Number of losing trades) / (Total number of trades) = (Number of losing trades) / N
+
+or, which is the same, as
+
+    L = 1 – W
 
 ### Risk Reward Ratio
-Risk Reward Ratio 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:
 
-`R = Profit / Loss`
+    R = Profit / 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:
 
-`Average profit = (Sum of profits) / (Number of winning trades)`
+    Average profit = (Sum of profits) / (Number of winning trades)
 
-`Average loss = (Sum of losses) / (Number of losing trades)`
+    Average loss = (Sum of losses) / (Number of losing trades)
 
-`R = (Average profit) / (Average loss)`
+    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:
 
-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:
+    Expectancy Ratio = (Risk Reward Ratio X Win Rate) – Loss Rate = (R X W) – L
-
-Expectancy Ratio = (Risk Reward Ratio x Win Rate) – Loss Rate
 
 So lets say your Win rate is 28% and your Risk Reward Ratio is 5:
 
-`Expectancy = (5 * 0.28) - 0.72 = 0.68`
+    Expectancy = (5 X 0.28) – 0.72 = 0.68
 
-Superficially, this means that on average you expect this strategy’s trades to return .68 times the size of your losers. 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.
+Superficially, this means that on average you expect this strategy’s trades to return .68 times the size of your loses. 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 number to evaluate the effectiveness of modifications to this system.
+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.
+**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.
 
 ## How does it work?
-If enabled in config, Edge will go through historical data with a range of stoplosses in order to find buy and sell/stoploss signals. It then calculates win rate and expectancy over X trades for each stoploss. Here is an example:
+If enabled in config, Edge will go through historical data with a range of stoplosses in order to find buy and sell/stoploss signals. It then calculates win rate and expectancy over *N* trades for each stoploss. Here is an example:
 
 | Pair   |      Stoploss      |  Win Rate | Risk Reward Ratio | Expectancy |
 |----------|:-------------:|-------------:|------------------:|-----------:|
-| XZC/ETH  |  -0.03        |   0.52       |1.359670           | 0.228      |
 | XZC/ETH  |  -0.01        |   0.50       |1.176384           | 0.088      |
 | XZC/ETH  |  -0.02        |   0.51       |1.115941           | 0.079      |
+| 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.
 
-Edge then forces stoploss to your strategy dynamically.
+Edge module then forces stoploss value it evaluated to your strategy dynamically.
 
 ### Position size
-Edge dictates the stake amount for each trade to the bot according to the following factors:
+Edge also dictates the stake amount for each trade to the bot according to the following factors:
 
 - Allowed capital at risk
 - Stoploss
 
 Allowed capital at risk is calculated as follows:
 
-**allowed capital at risk** = **capital_available_percentage** X **allowed risk per trade**
+    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 against historical data.
 
 Your position size then will be:
 
-**position size** = **allowed capital at risk** / **stoploss**
+    Position size = (Allowed capital at risk) / Stoploss
 
-Example:<br/>
+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**. <br/>
+
-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.5ETH**.<br/>
+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**.
-Bot takes a position of 2.5ETH 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.25ETH (call it trade 2).<br/>
+
-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.<br/>
+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**.
-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 = 5ETH**. But there are already 4ETH blocked in two previous trades. So the position size for this third trade would be 1ETH.<br/>
+
-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 1ETH. Your total capital on exchange would be 11 ETH and the available capital for trading becomes 5.5ETH. <br/>
+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).
-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**.
+
+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.
+
+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**.
+
+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.
+
+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**.
 
 ## Configurations
-Edge has following configurations:
+Edge module has following configuration options:
 
 #### enabled
-If true, then Edge will run periodically.<br/>
+If true, then Edge will run periodically.
-(default to false)
+
+(defaults to false)
 
 #### process_throttle_secs
-How often should Edge run in seconds? <br/>
+How often should Edge run in seconds?
-(default to 3600 so one hour)
+
+(defaults to 3600 so one hour)
 
 #### calculate_since_number_of_days
 Number of days of data against which Edge calculates Win Rate, Risk Reward and Expectancy
-Note that it downloads historical data so increasing this number would lead to slowing down the bot.<br/>
+Note that it downloads historical data so increasing this number would lead to slowing down the bot.
-(default to 7)
+
+(defaults to 7)
 
 #### capital_available_percentage
-This is the percentage of the total capital on exchange in stake currency. <br/>
+This is the percentage of the total capital on exchange in stake currency.
-As an example if you have 10 ETH available in your wallet on the exchange and this value is 0.5 (which is 50%), then the bot will use a maximum amount of 5 ETH for trading and considers it as available capital.<br/>
+
-(default to 0.5)
+As an example if you have 10 ETH available in your wallet on the exchange and this value is 0.5 (which is 50%), then the bot will use a maximum amount of 5 ETH for trading and considers it as available capital.
+
+(defaults to 0.5)
 
 #### allowed_risk
-Percentage of allowed risk per trade.<br/>
+Percentage of allowed risk per trade.
-(default to 0.01 [1%])
+
+(defaults to 0.01 so 1%)
 
 #### stoploss_range_min
-Minimum stoploss.<br/>
+
-(default to -0.01)
+Minimum stoploss.
+
+(defaults to -0.01)
 
 #### stoploss_range_max
-Maximum stoploss.<br/>
+
-(default to -0.10)
+Maximum stoploss.
+
+(defaults to -0.10)
 
 #### stoploss_range_step
-As an example if this is set to -0.01 then Edge will test the strategy for [-0.01, -0,02, -0,03 ..., -0.09, -0.10] ranges.
+
-Note than having a smaller step means having a bigger range which could lead to slow calculation. <br/>
+As an example if this is set to -0.01 then Edge will test the strategy for \[-0.01, -0,02, -0,03 ..., -0.09, -0.10\] ranges.
-if you set this parameter to -0.001, you then slow down the Edge calculation by a factor of 10. <br/>
+Note than having a smaller step means having a bigger range which could lead to slow calculation.
-(default to -0.01)
+
+If you set this parameter to -0.001, you then slow down the Edge calculation by a factor of 10.
+
+(defaults to -0.01)
 
 #### minimum_winrate
-It filters pairs which don't have at least minimum_winrate.
+
-This comes handy if you want to be conservative and don't comprise win rate in favor of risk reward ratio.<br/>
+It filters out pairs which don't have at least minimum_winrate.
-(default to 0.60)
+
+This comes handy if you want to be conservative and don't comprise win rate in favour of risk reward ratio.
+
+(defaults to 0.60)
 
 #### minimum_expectancy
-It filters paris which have an expectancy lower than this number .
+
-Having an expectancy of 0.20 means if you put 10$ on a trade you expect a 12$ return.<br/>
+It filters out pairs which have the expectancy lower than this number.
-(default to 0.20)
+
+Having an expectancy of 0.20 means if you put 10$ on a trade you expect a 12$ return.
+
+(defaults to 0.20)
 
 #### min_trade_number
-When calculating W and R and E (expectancy) against historical data, you always want to have a minimum number of trades. The more this number is the more Edge is reliable. Having a win rate of 100% on a single trade doesn't mean anything at all. But having a win rate of 70% over past 100 trades means clearly something. <br/>
+
-(default to 10, it is highly recommended not to decrease this number)
+When calculating *W*, *R* and *E* (expectancy) against historical data, you always want to have a minimum number of trades. The more this number is the more Edge is reliable.
+
+Having a win rate of 100% on a single trade doesn't mean anything at all. But having a win rate of 70% over past 100 trades means clearly something.
+
+(defaults to 10, it is highly recommended not to decrease this number)
 
 #### max_trade_duration_minute
-Edge will filter out trades with long duration. If a trade is profitable after 1 month, it is hard to evaluate the strategy based on it. But if most of trades are profitable and they have maximum duration of 30 minutes, then it is clearly a good sign.<br/>
+
-**NOTICE:** While configuring this value, you should take into consideration your ticker interval. as an example filtering out trades having duration less than one day for a strategy which has 4h interval does not make sense. default value is set assuming your strategy interval is relatively small (1m or 5m, etc).<br/>
+Edge will filter out trades with long duration. If a trade is profitable after 1 month, it is hard to evaluate the strategy based on it. But if most of trades are profitable and they have maximum duration of 30 minutes, then it is clearly a good sign.
-(default to 1 day, 1440 = 60 * 24)
+
+**NOTICE:** While configuring this value, you should take into consideration your ticker interval. As an example filtering out trades having duration less than one day for a strategy which has 4h interval does not make sense. Default value is set assuming your strategy interval is relatively small (1m or 5m, etc.).
+
+(defaults to 1 day, i.e. to 60 * 24 = 1440 minutes)
 
 #### remove_pumps
-Edge will remove sudden pumps in a given market while going through historical data. However, given that pumps happen very often in crypto markets, we recommend you keep this off.<br/>
-(default to false)
 
+Edge will remove sudden pumps in a given market while going through historical data. However, given that pumps happen very often in crypto markets, we recommend you keep this off.
+
+(defaults to false)
 
 ## Running Edge independently
+
 You can run Edge independently in order to see in details the result. Here is an example:
+
 ```bash
-python3 ./freqtrade/main.py edge
+freqtrade edge
 ```
 
 An example of its output:
@@ -189,28 +233,30 @@ An example of its output:
 | NEBL/BTC  |      -0.03 |       0.63 |                1.29 |                   0.58 |         0.44 |                       19 |                       59 |
 
 ### Update cached pairs with the latest data
-```bash
+
-python3 ./freqtrade/main.py edge --refresh-pairs-cached
+Edge requires historic data the same way as backtesting does.
-```
+Please refer to the [download section](backtesting.md#Getting-data-for-backtesting-and-hyperopt) of the documentation for details.
 
 ### Precising stoploss range
+
 ```bash
-python3 ./freqtrade/main.py edge --stoplosses=-0.01,-0.1,-0.001 #min,max,step
+freqtrade edge --stoplosses=-0.01,-0.1,-0.001 #min,max,step
 ```
 
 ### Advanced use of timerange
+
 ```bash
-python3 ./freqtrade/main.py edge --timerange=20181110-20181113
+freqtrade edge --timerange=20181110-20181113
 ```
 
-Doing --timerange=-200 will get the last 200 timeframes from your inputdata. You can also specify specific dates, or a range span indexed by start and stop.
+Doing `--timerange=-200` will get the last 200 timeframes from your inputdata. You can also specify specific dates, or a range span indexed by start and stop.
 
 The full timerange specification:
 
-* Use last 123 tickframes of data: --timerange=-123
+* Use last 123 tickframes of data: `--timerange=-123`
-* Use first 123 tickframes of data: --timerange=123-
+* Use first 123 tickframes of data: `--timerange=123-`
-* Use tickframes from line 123 through 456: --timerange=123-456
+* Use tickframes from line 123 through 456: `--timerange=123-456`
-* Use tickframes till 2018/01/31: --timerange=-20180131
+* Use tickframes till 2018/01/31: `--timerange=-20180131`
-* Use tickframes since 2018/01/31: --timerange=20180131-
+* Use tickframes since 2018/01/31: `--timerange=20180131-`
-* Use tickframes since 2018/01/31 till 2018/03/01 : --timerange=20180131-20180301
+* Use tickframes since 2018/01/31 till 2018/03/01 : `--timerange=20180131-20180301`
-* Use tickframes between POSIX timestamps 1527595200 1527618600: --timerange=1527595200-1527618600
+* Use tickframes between POSIX timestamps 1527595200 1527618600: `--timerange=1527595200-1527618600`

docs/faq.md

@@ -1,12 +1,25 @@
-# freqtrade FAQ
+# Freqtrade FAQ
 
-#### I have waited 5 minutes, why hasn't the bot made any trades yet?!
+## Freqtrade common issues
+
+### The bot does not start
+
+Running the bot with `freqtrade --config config.json` does show the output `freqtrade: command not found`.
+
+This could have the following reasons:
+
+* The virtual environment is not active
+  * run `source .env/bin/activate` to activate the virtual environment
+* The installation did not work correctly.
+  * Please check the [Installation documentation](installation.md).
+
+### I have waited 5 minutes, why hasn't the bot made any trades yet?!
 
 Depending on the buy strategy, the amount of whitelisted coins, the
 situation of the market etc, it can take up to hours to find good entry
 position for a trade. Be patient!
 
-#### I have made 12 trades already, why is my total profit negative?!
+### I have made 12 trades already, why is my total profit negative?!
 
 I understand your disappointment but unfortunately 12 trades is just
 not enough to say anything. If you run backtesting, you can see that our
@@ -17,55 +30,82 @@ of course constantly aim to improve the bot but it will _always_ be a
 gamble, which should leave you with modest wins on monthly basis but
 you can't say much from few trades.
 
-#### I’d like to change the stake amount. Can I just stop the bot with 
+### I’d like to change the stake amount. Can I just stop the bot with /stop and then change the config.json and run it again?
-/stop and then change the config.json and run it again?
 
 Not quite. Trades are persisted to a database but the configuration is
 currently only read when the bot is killed and restarted. `/stop` more
 like pauses. You can stop your bot, adjust settings and start it again.
 
-#### I want to improve the bot with a new strategy
+### I want to improve the bot with a new strategy
 
 That's great. We have a nice backtesting and hyperoptimizing setup. See
-the tutorial [here|Testing-new-strategies-with-Hyperopt](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md#hyperopt-commands).
+the tutorial [here|Testing-new-strategies-with-Hyperopt](bot-usage.md#hyperopt-commands).
 
-#### Is there a setting to only SELL the coins being held and not 
+### Is there a setting to only SELL the coins being held and not perform anymore BUYS?
-perform anymore BUYS?
 
 You can use the `/forcesell all` command from Telegram.
 
+### I get the message "RESTRICTED_MARKET"
+
+Currently known to happen for US Bittrex users.  
+Bittrex split its exchange into US and International versions.
+The International version has more pairs available, however the API always returns all pairs, so there is currently no automated way to detect if you're affected by the restriction.
+
+If you have restricted pairs in your whitelist, you'll get a warning message in the log on FreqTrade startup for each restricted pair.
+If you're an "International" Customer on the Bittrex exchange, then this warning will probably not impact you.
+If you're a US customer, the bot will fail to create orders for these pairs, and you should remove them from your Whitelist.
+
+## Hyperopt module
+
 ### How many epoch do I need to get a good Hyperopt result?
+
 Per default Hyperopts without `-e` or `--epochs` parameter will only
-run 100 epochs, means 100 evals of your triggers, guards, .... Too few 
+run 100 epochs, means 100 evals of your triggers, guards, ... Too few
 to find a great result (unless if you are very lucky), so you probably
 have to run it for 10.000 or more. But it will take an eternity to
 compute.
 
 We recommend you to run it at least 10.000 epochs:
+
 ```bash
-python3 ./freqtrade/main.py hyperopt -e 10000
+freqtrade hyperopt -e 10000
 ```
 
 or if you want intermediate result to see
+
 ```bash
-for i in {1..100}; do python3 ./freqtrade/main.py hyperopt -e 100; done
+for i in {1..100}; do freqtrade hyperopt -e 100; done
 ```
 
-#### Why it is so long to run hyperopt?
+### Why it is so long to run hyperopt?
+
 Finding a great Hyperopt results takes time.
 
 If you wonder why it takes a while to find great hyperopt results
 
-This answer was written during the under the release 0.15.1, when we had
+This answer was written during the under the release 0.15.1, when we had:
-:
+
 - 8 triggers
 - 9 guards: let's say we evaluate even 10 values from each
-- 1 stoploss calculation: let's say we want 10 values from that too to 
+- 1 stoploss calculation: let's say we want 10 values from that too to be evaluated
-be evaluated
 
 The following calculation is still very rough and not very precise
 but it will give the idea. With only these triggers and guards there is
-already 8*10^9*10 evaluations. A roughly total of 80 billion evals. 
+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.
 
+## Edge module
+
+### Edge implements interesting approach for controlling position size, is there any theory behind it?
+
+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:
+
+- https://www.tradeciety.com/ultimate-math-guide-for-traders/
+- http://www.vantharp.com/tharp-concepts/expectancy.asp
+- https://samuraitradingacademy.com/trading-expectancy/
+- https://www.learningmarkets.com/determining-expectancy-in-your-trading/
+- http://www.lonestocktrader.com/make-money-trading-positive-expectancy/
+- https://www.babypips.com/trading/trade-expectancy-matter

docs/hyperopt.md

@@ -6,43 +6,55 @@ algorithms included in the `scikit-optimize` package to accomplish this. The
 search will burn all your CPU cores, make your laptop sound like a fighter jet
 and still take a long time.
 
-*Note:* Hyperopt will crash when used with only 1 CPU Core as found out in [Issue #1133](https://github.com/freqtrade/freqtrade/issues/1133)
+!!! Bug
-
+    Hyperopt will crash when used with only 1 CPU Core as found out in [Issue #1133](https://github.com/freqtrade/freqtrade/issues/1133)
-## Table of Contents
-
-- [Prepare your Hyperopt](#prepare-hyperopt)
-- [Configure your Guards and Triggers](#configure-your-guards-and-triggers)
-- [Solving a Mystery](#solving-a-mystery)
-- [Adding New Indicators](#adding-new-indicators)
-- [Execute Hyperopt](#execute-hyperopt)
-- [Understand the hyperopt result](#understand-the-hyperopt-result)
 
 ## Prepare Hyperopting
 
-Before we start digging in Hyperopt, we recommend you to take a look at 
+Before we start digging into Hyperopt, we recommend you to take a look at
-an example hyperopt file located into [user_data/hyperopts/](https://github.com/gcarq/freqtrade/blob/develop/user_data/hyperopts/test_hyperopt.py)
+an example hyperopt file located into [user_data/hyperopts/](https://github.com/freqtrade/freqtrade/blob/develop/user_data/hyperopts/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.
+
+### Checklist on all tasks / possibilities in hyperopt
+
+Depending on the space you want to optimize, only some of the below are required:
+
+* fill `populate_indicators` - probably a copy from your strategy
+* fill `buy_strategy_generator` - for buy signal optimization
+* fill `indicator_space` - for buy signal optimzation
+* fill `sell_strategy_generator` - for sell signal optimization
+* fill `sell_indicator_space` - for sell signal optimzation
+
+Optional, but recommended:
+
+* 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
+
+Rarely you may also need to override:
+
+* `roi_space` - for custom ROI optimization (if you need the ranges for the ROI parameters in the optimization hyperspace that differ from default)
+* `generate_roi_table` - for custom ROI optimization (if you need more than 4 entries in the ROI table)
+* `stoploss_space` - for custom stoploss optimization (if you need the range for the stoploss parameter in the optimization hyperspace that differs from default)
 
 ### 1. Install a Custom Hyperopt File
-This is very simple. Put your hyperopt file into the folder 
+
-`user_data/hyperopts`.
+Put your hyperopt file into the directory `user_data/hyperopts`.
 
 Let assume you want a hyperopt file `awesome_hyperopt.py`:  
-1. Copy the file `user_data/hyperopts/sample_hyperopt.py` into `user_data/hyperopts/awesome_hyperopt.py`
+Copy the file `user_data/hyperopts/sample_hyperopt.py` into `user_data/hyperopts/awesome_hyperopt.py`
-
 
 ### 2. 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:
+There are two places you need to change in your hyperopt file to add a new buy hyperopt for testing:
-- Inside [populate_buy_trend()](https://github.com/freqtrade/freqtrade/blob/develop/user_data/hyperopts/test_hyperopt.py#L230-L251).
+
-- Inside [indicator_space()](https://github.com/freqtrade/freqtrade/blob/develop/user_data/hyperopts/test_hyperopt.py#L207-L223).
+- Inside `indicator_space()` - the parameters hyperopt shall be optimizing.
+- Inside `populate_buy_trend()` - applying the parameters.
 
 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 
+1. Guards are conditions like "never buy if ADX < 10", or never buy if current price is over EMA10.
-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".
-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
@@ -53,6 +65,22 @@ If you have updated the buy strategy, ie. changed the contents of
 `populate_buy_trend()` method you have to update the `guards` and
 `triggers` hyperopts must use.
 
+#### Sell optimization
+
+Similar to the buy-signal above, sell-signals can also be optimized.
+Place the corresponding settings into the following methods
+
+* Inside `sell_indicator_space()` - the parameters hyperopt shall be optimizing.
+* Inside `populate_sell_trend()` - applying the parameters.
+
+The configuration and rules are the same than for buy signals.
+To avoid naming collisions in the search-space, please prefix all sell-spaces with `sell-`.
+
+#### Using ticker-interval as part of the Strategy
+
+The Strategy exposes the ticker-interval as `self.ticker_interval`. The same value is available as class-attribute `HyperoptName.ticker_interval`.
+In the case of the linked sample-value this would be `SampleHyperOpts.ticker_interval`.
+
 ## Solving a Mystery
 
 Let's say you are curious: should you use MACD crossings or lower Bollinger
@@ -63,7 +91,7 @@ mystery.
 
 We will start by defining a search space:
 
-```
+```python
     def indicator_space() -> List[Dimension]:
         """
         Define your Hyperopt space for searching strategy parameters
@@ -86,7 +114,7 @@ one we call `trigger` and use it to decide which buy trigger we want to use.
 
 So let's write the buy strategy using these values:
 
-```
+``` python
         def populate_buy_trend(dataframe: DataFrame) -> DataFrame:
             conditions = []
             # GUARDS AND TRENDS
@@ -96,16 +124,18 @@ So let's write the buy strategy using these values:
                 conditions.append(dataframe['rsi'] < params['rsi-value'])
 
             # TRIGGERS
-            if params['trigger'] == 'bb_lower':
+            if 'trigger' in params:
-                conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
+                if params['trigger'] == 'bb_lower':
-            if params['trigger'] == 'macd_cross_signal':
+                    conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
-                conditions.append(qtpylib.crossed_above(
+                if params['trigger'] == 'macd_cross_signal':
-                    dataframe['macd'], dataframe['macdsignal']
+                    conditions.append(qtpylib.crossed_above(
-                ))
+                        dataframe['macd'], dataframe['macdsignal']
+                    ))
 
-            dataframe.loc[
+            if conditions:
-                reduce(lambda x, y: x & y, conditions),
+                dataframe.loc[
-                'buy'] = 1
+                    reduce(lambda x, y: x & y, conditions),
+                    'buy'] = 1
 
             return dataframe
 
@@ -119,29 +149,109 @@ it will end with telling you which paramter combination produced the best profit
 
 The search for best parameters starts with a few random combinations and then uses a
 regressor algorithm (currently ExtraTreesRegressor) to quickly find a parameter combination
-that minimizes the value of the objective function `calculate_loss` in `hyperopt.py`.
+that minimizes the value of the [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 `hyperopt.py`.
 
+## 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.
+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)
+* `OnlyProfitHyperOptLoss` (which takes only amount of profit into consideration)
+* `SharpeHyperOptLoss` (optimizes Sharpe Ratio calculated on the trade returns)
+
+### Creating and using a custom loss function
+
+To use a custom loss function class, make sure that the function `hyperopt_loss_function` is defined in your custom hyperopt loss class.
+For the sample below, you then need to add the command line parameter `--hyperopt-loss SuperDuperHyperOptLoss` to your hyperopt call so this fuction is being used.
+
+A sample of this can be found below, which is identical to the Default Hyperopt loss implementation. A full sample can be found [user_data/hyperopts/](https://github.com/freqtrade/freqtrade/blob/develop/user_data/hyperopts/sample_hyperopt_loss.py)
+
+``` python
+from freqtrade.optimize.hyperopt import IHyperOptLoss
+
+TARGET_TRADES = 600
+EXPECTED_MAX_PROFIT = 3.0
+MAX_ACCEPTED_TRADE_DURATION = 300
+
+class SuperDuperHyperOptLoss(IHyperOptLoss):
+    """
+    Defines the default loss function for hyperopt
+    """
+
+    @staticmethod
+    def hyperopt_loss_function(results: DataFrame, trade_count: int,
+                               min_date: datetime, max_date: datetime,
+                               *args, **kwargs) -> float:
+        """
+        Objective function, returns smaller number for better results
+        This is the legacy algorithm (used until now in freqtrade).
+        Weights are distributed as follows:
+        * 0.4 to trade duration
+        * 0.25: Avoiding trade loss
+        * 1.0 to total profit, compared to the expected value (`EXPECTED_MAX_PROFIT`) defined above
+        """
+        total_profit = results.profit_percent.sum()
+        trade_duration = results.trade_duration.mean()
+
+        trade_loss = 1 - 0.25 * exp(-(trade_count - TARGET_TRADES) ** 2 / 10 ** 5.8)
+        profit_loss = max(0, 1 - total_profit / EXPECTED_MAX_PROFIT)
+        duration_loss = 0.4 * min(trade_duration / MAX_ACCEPTED_TRADE_DURATION, 1)
+        result = trade_loss + profit_loss + duration_loss
+        return result
+```
+
+Currently, the arguments are:
+
+* `results`: DataFrame containing the result  
+    The following columns are available in results (corresponds to the output-file of backtesting when used with `--export trades`):  
+    `pair, profit_percent, profit_abs, open_time, close_time, open_index, close_index, trade_duration, open_at_end, open_rate, close_rate, sell_reason`
+* `trade_count`: Amount of trades (identical to `len(results)`)
+* `min_date`: Start date of the hyperopting TimeFrame
+* `min_date`: End date of the hyperopting TimeFrame
+
+This function needs to return a floating point number (`float`). Smaller numbers will be interpreted as better results. The parameters and balancing for this is up to you.
+
+!!! Note
+    This function is called once per iteration - so please make sure to have this as optimized as possible to not slow hyperopt down unnecessarily.
+
+!!! Note
+    Please keep the arguments `*args` and `**kwargs` in the interface to allow us to extend this interface later.
+
 ## Execute Hyperopt
 
 Once you have updated your hyperopt configuration you can run it.
-Because hyperopt tries a lot of combinations to find the best parameters it will take time you will have the result (more than 30 mins).
+Because hyperopt tries a lot of combinations to find the best parameters it will take time to get a good result. More time usually results in better results.
 
 We strongly recommend to use `screen` or `tmux` to prevent any connection loss.
 
 ```bash
-python3 ./freqtrade/main.py -s <strategyname> --hyperopt <hyperoptname> -c config.json hyperopt -e 5000
+freqtrade -c config.json hyperopt --customhyperopt <hyperoptname> -e 5000 --spaces all
 ```
 
-Use `<strategyname>` and `<hyperoptname>` as the names of the custom strategy 
+Use  `<hyperoptname>` as the name of the custom hyperopt used.
-(only required for generating sells) and the custom hyperopt used.
 
 The `-e` flag will set how many evaluations hyperopt will do. We recommend
 running at least several thousand evaluations.
 
+The `--spaces all` flag 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.
+
 ### Execute Hyperopt with Different Ticker-Data Source
 
 If you would like to hyperopt parameters using an alternate ticker data that
@@ -150,12 +260,11 @@ use data from directory `user_data/data`.
 
 ### Running Hyperopt with Smaller Testset
 
-Use the `--timerange` argument to change how much of the testset
+Use the `--timerange` argument to change how much of the testset you want to use.
-you want to use. The last N ticks/timeframes will be used.
+For example, to use one month of data, pass the following parameter to the hyperopt call:
-Example:
 
 ```bash
-python3 ./freqtrade/main.py hyperopt --timerange -200
+freqtrade hyperopt --timerange 20180401-20180501
 ```
 
 ### Running Hyperopt with Smaller Search Space
@@ -168,11 +277,33 @@ new buy strategy you have.
 
 Legal values are:
 
-- `all`: optimize everything
+* `all`: optimize everything
-- `buy`: just search for a new buy strategy
+* `buy`: just search for a new buy strategy
-- `roi`: just optimize the minimal profit table for your strategy
+* `sell`: just search for a new sell strategy
-- `stoploss`: search for the best stoploss value
+* `roi`: just optimize the minimal profit table for your strategy
-- space-separated list of any of the above values for example `--spaces roi stoploss`
+* `stoploss`: search for the best stoploss value
+* space-separated list of any of the above values for example `--spaces roi stoploss`
+
+### Position stacking and disabling max market positions
+
+In some situations, you may need to run Hyperopt (and Backtesting) with the 
+`--eps`/`--enable-position-staking` and `--dmmp`/`--disable-max-market-positions` arguments.
+
+By default, hyperopt emulates the behavior of the Freqtrade Live Run/Dry Run, where only one
+open trade is allowed for every traded pair. The total number of trades open for all pairs 
+is also limited by the `max_open_trades` setting. During Hyperopt/Backtesting this may lead to
+some potential trades to be hidden (or masked) by previosly open trades.
+
+The `--eps`/`--enable-position-stacking` argument allows emulation of buying the same pair multiple times,
+while `--dmmp`/`--disable-max-market-positions` disables applying `max_open_trades` 
+during Hyperopt/Backtesting (which is equal to setting `max_open_trades` to a very high
+number).
+
+!!! Note
+    Dry/live runs will **NOT** use position stacking - therefore it does make sense to also validate the strategy without this as it's closer to reality.
+
+You can also enable position stacking in the configuration file by explicitly setting 
+`"position_stacking"=true`.
 
 ## Understand the Hyperopt Result
 
@@ -181,9 +312,15 @@ Given the following result from hyperopt:
 
 ```
 Best result:
-   135 trades. Avg profit  0.57%. Total profit  0.03871918 BTC (0.7722Σ%). Avg duration 180.4 mins.
+
-with values:
+    44/100:    135 trades. Avg profit  0.57%. Total profit  0.03871918 BTC (0.7722Σ%). Avg duration 180.4 mins. Objective: 1.94367
-{'adx-value': 44, 'rsi-value': 29, 'adx-enabled': False, 'rsi-enabled': True, 'trigger': 'bb_lower'}
+
+Buy hyperspace params:
+{    'adx-value': 44,
+     'rsi-value': 29,
+     'adx-enabled': False,
+     'rsi-enabled': True,
+     'trigger': 'bb_lower'}
 ```
 
 You should understand this result like:
@@ -197,7 +334,7 @@ method, what those values match to.
 
 So for example you had `rsi-value: 29.0` so we would look at `rsi`-block, that translates to the following code block:
 
-```
+``` python
 (dataframe['rsi'] < 29.0)
 ```
 
@@ -215,39 +352,85 @@ def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
     return dataframe
 ```
 
+By default, hyperopt prints colorized results -- epochs with positive profit are printed in the green color. This highlighting helps you find epochs that can be interesting for later analysis. Epochs with zero total profit or with negative profits (losses) are printed in the normal color. If you do not need colorization of results (for instance, when you are redirecting hyperopt output to a file) you can switch colorization off by specifying the `--no-color` option in the command line.
+
+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.
+
 ### Understand Hyperopt ROI results
 
-If you are optimizing ROI, you're result will look as follows and include a ROI table.
+If you are optimizing ROI (i.e. if optimization search-space contains 'all' or 'roi'), your result will look as follows and include a ROI table:
 
 ```
 Best result:
-   135 trades. Avg profit  0.57%. Total profit  0.03871918 BTC (0.7722Σ%). Avg duration 180.4 mins.
+
-with values:
+    44/100:    135 trades. Avg profit  0.57%. Total profit  0.03871918 BTC (0.7722Σ%). Avg duration 180.4 mins. Objective: 1.94367
-{'adx-value': 44, 'rsi-value': 29, 'adx-enabled': False, 'rsi-enabled': True, 'trigger': 'bb_lower', 'roi_t1': 40, 'roi_t2': 57, 'roi_t3': 21, 'roi_p1': 0.03634636907306948, 'roi_p2': 0.055237357937802885, 'roi_p3': 0.015163796015548354, 'stoploss': -0.37996664668703606}
+
+Buy hyperspace params:
+{   'adx-value': 44,
+    'rsi-value': 29,
+    'adx-enabled': False,
+    'rsi-enabled': True,
+    'trigger': 'bb_lower'}
 ROI table:
-{0: 0.10674752302642071, 21: 0.09158372701087236, 78: 0.03634636907306948, 118: 0}
+{   0: 0.10674752302642071,
+    21: 0.09158372701087236,
+    78: 0.03634636907306948,
+    118: 0}
 ```
 
 This would translate to the following ROI table:
 
 ``` python
- minimal_roi = {
+minimal_roi = {
         "118": 0,
-        "78": 0.0363463,
+        "78": 0.0363,
         "21": 0.0915,
         "0": 0.106
     }
 ```
 
-### Validate backtest result
+If you are optimizing ROI, Freqtrade creates the 'roi' optimization hyperspace for you -- it's the hyperspace of components for the ROI tables. By default, each ROI table generated by the Freqtrade consists of 4 rows (steps) with the values that can vary in the following ranges:
+
+| # | minutes | ROI percentage |
+|---|---|---|
+| 1 | always 0 | 0.03...0.31 |
+| 2 | 10...40 | 0.02...0.11 |
+| 3 | 20...100 | 0.01...0.04 |
+| 4 | 30...220 | always 0 |
+
+This structure of the ROI table is sufficient in most cases. Override the `roi_space()` method defining the ranges desired 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 in these methods if you need a different structure of the ROI table or other amount of rows (steps) in the ROI tables.
+
+### Understand Hyperopt Stoploss results
+
+If you are optimizing stoploss values (i.e. if optimization search-space contains 'all' or 'stoploss'), your result will look as follows and include stoploss:
+
+```
+Best result:
+
+    44/100:    135 trades. Avg profit  0.57%. Total profit  0.03871918 BTC (0.7722Σ%). Avg duration 180.4 mins. Objective: 1.94367
+
+Buy hyperspace params:
+{   'adx-value': 44,
+    'rsi-value': 29,
+    'adx-enabled': False,
+    'rsi-enabled': True,
+    'trigger': 'bb_lower'}
+Stoploss: -0.37996664668703606
+```
+
+If you are optimizing stoploss values, Freqtrade creates the 'stoploss' optimization hyperspace for you. By default, the stoploss values in that hyperspace can vary in the range -0.5...-0.02, which is sufficient in most cases.
+
+Override the `stoploss_space()` method and define the desired range in it if you need stoploss values to vary in other range during hyperoptimization.
+
+### 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 archive the same results (number of trades, ...) than during hyperopt, please use the command line flag `--disable-max-market-positions`.
-This setting is the default for hyperopt for speed reasons. You can overwrite this in the configuration by setting `"position_stacking"=false` or by changing the relevant line in your hyperopt file [here](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/optimize/hyperopt.py#L283).
 
-Dry/live runs will **NOT** use position stacking - therefore it does make sense to also validate the strategy without this as it's closer to reality. 
+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.
 
 ## Next Step
 
 Now you have a perfect bot and want to control it from Telegram. Your
-next step is to learn the [Telegram usage](https://github.com/freqtrade/freqtrade/blob/develop/docs/telegram-usage.md).
+next step is to learn the [Telegram usage](telegram-usage.md).

docs/index.md

@@ -1,39 +1,71 @@
-# freqtrade documentation
+# Freqtrade
+[![Build Status](https://travis-ci.org/freqtrade/freqtrade.svg?branch=develop)](https://travis-ci.org/freqtrade/freqtrade)
+[![Coverage Status](https://coveralls.io/repos/github/freqtrade/freqtrade/badge.svg?branch=develop&service=github)](https://coveralls.io/github/freqtrade/freqtrade?branch=develop)
+[![Maintainability](https://api.codeclimate.com/v1/badges/5737e6d668200b7518ff/maintainability)](https://codeclimate.com/github/freqtrade/freqtrade/maintainability)
 
-Welcome to freqtrade documentation. Please feel free to contribute to
+<!-- Place this tag where you want the button to render. -->
-this documentation if you see it became outdated by sending us a
+<a class="github-button" href="https://github.com/freqtrade/freqtrade" data-icon="octicon-star" data-size="large" aria-label="Star freqtrade/freqtrade on GitHub">Star</a>
-Pull-request. Do not hesitate to reach us on
+<!-- Place this tag where you want the button to render. -->
-[Slack](https://join.slack.com/t/highfrequencybot/shared_invite/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE)
+<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>
- if you do not find the answer to your questions.
+<!-- 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>
+<!-- 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>
+## Introduction
+Freqtrade is a cryptocurrency trading bot written in Python.
 
-## Table of Contents
+!!! Danger "DISCLAIMER"
+    This software is for educational purposes only. Do not risk money which you are afraid to lose. USE THE SOFTWARE AT YOUR OWN RISK. THE AUTHORS AND ALL AFFILIATES ASSUME NO RESPONSIBILITY FOR YOUR TRADING RESULTS.
 
-- [Pre-requisite](https://github.com/freqtrade/freqtrade/blob/develop/docs/pre-requisite.md)
+    Always start by running a trading bot in Dry-run and do not engage money before you understand how it works and what profit/loss you should expect.
-	- [Setup your Bittrex account](https://github.com/freqtrade/freqtrade/blob/develop/docs/pre-requisite.md#setup-your-bittrex-account)
+
-	- [Setup your Telegram bot](https://github.com/freqtrade/freqtrade/blob/develop/docs/pre-requisite.md#setup-your-telegram-bot)
+    We strongly recommend you to have basic coding skills and Python knowledge. Do not hesitate to read the source code and understand the mechanisms of this bot, algorithms and techniques implemented in it.
-- [Bot Installation](https://github.com/freqtrade/freqtrade/blob/develop/docs/installation.md)
+
-    - [Install with Docker (all platforms)](https://github.com/freqtrade/freqtrade/blob/develop/docs/installation.md#docker)
+## Features
-    - [Install on Linux Ubuntu](https://github.com/freqtrade/freqtrade/blob/develop/docs/installation.md#21-linux---ubuntu-1604)
+
-    - [Install on MacOS](https://github.com/freqtrade/freqtrade/blob/develop/docs/installation.md#23-macos-installation)
+ - Based on Python 3.6+: For botting on any operating system — Windows, macOS and Linux.
-    - [Install on Windows](https://github.com/freqtrade/freqtrade/blob/develop/docs/installation.md#windows)
+ - Persistence: Persistence is achieved through sqlite database.
-- [Bot Configuration](https://github.com/freqtrade/freqtrade/blob/develop/docs/configuration.md)
+ - Dry-run mode: Run the bot without playing money.
-- [Bot usage (Start your bot)](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md)
+ - Backtesting: Run a simulation of your buy/sell strategy with historical data.
-    - [Bot commands](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md#bot-commands)
+ - Strategy Optimization by machine learning: Use machine learning to optimize your buy/sell strategy parameters with real exchange data.
-    - [Backtesting commands](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md#backtesting-commands)
+ - Edge position sizing: Calculate your win rate, risk reward ratio, the best stoploss and adjust your position size before taking a position for each specific market.
-    - [Hyperopt commands](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md#hyperopt-commands)
+ - Whitelist crypto-currencies: Select which crypto-currency you want to trade or use dynamic whitelists based on market (pair) trade volume.
-    - [Edge commands](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md#edge-commands)
+ - Blacklist crypto-currencies: Select which crypto-currency you want to avoid.
-- [Bot Optimization](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-optimization.md)
+ - Manageable via Telegram or REST APi: Manage the bot with Telegram or via the builtin REST API.
-	- [Change your strategy](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-optimization.md#change-your-strategy)
+ - Display profit/loss in fiat: Display your profit/loss in any of 33 fiat currencies supported.
-    - [Add more Indicator](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-optimization.md#add-more-indicator)
+ - Daily summary of profit/loss: Receive the daily summary of your profit/loss.
-    - [Test your strategy with Backtesting](https://github.com/freqtrade/freqtrade/blob/develop/docs/backtesting.md)
+ - Performance status report: Receive the performance status of your current trades.
-    - [Edge positioning](https://github.com/freqtrade/freqtrade/blob/develop/docs/edge.md)
+
-    - [Find optimal parameters with Hyperopt](https://github.com/freqtrade/freqtrade/blob/develop/docs/hyperopt.md)
+## Requirements
-- [Control the bot with telegram](https://github.com/freqtrade/freqtrade/blob/develop/docs/telegram-usage.md)
+
-- [Receive notifications via webhook](https://github.com/freqtrade/freqtrade/blob/develop/docs/webhook-config.md)
+### Up to date clock
-- [Contribute to the project](https://github.com/freqtrade/freqtrade/blob/develop/CONTRIBUTING.md)
+
-	- [How to contribute](https://github.com/freqtrade/freqtrade/blob/develop/CONTRIBUTING.md)
+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.
-	- [Run tests & Check PEP8 compliance](https://github.com/freqtrade/freqtrade/blob/develop/CONTRIBUTING.md)
+
-- [FAQ](https://github.com/freqtrade/freqtrade/blob/develop/docs/faq.md)
+### Hardware requirements
-    - [SQL cheatsheet](https://github.com/freqtrade/freqtrade/blob/develop/docs/sql_cheatsheet.md)
+
-- [Sandbox Testing](https://github.com/freqtrade/freqtrade/blob/develop/docs/sandbox-testing.md)
+To run this bot we recommend you a cloud instance with a minimum of:
-- [Developer Docs](https://github.com/freqtrade/freqtrade/blob/develop/docs/developer.md)
+
+- 2GB RAM
+- 1GB disk space
+- 2vCPU
+
+### Software requirements
+
+- Python 3.6.x
+- pip (pip3)
+- git
+- TA-Lib
+- virtualenv (Recommended)
+- Docker (Recommended)
+
+## Support
+
+Help / Slack
+For any questions not covered by the documentation or for further information about the bot, we encourage you to join our Slack channel.
+
+Click [here](https://join.slack.com/t/highfrequencybot/shared_invite/enQtNjU5ODcwNjI1MDU3LWEyODBiNzkzNzcyNzU0MWYyYzE5NjIyOTQxMzBmMGUxOTIzM2YyN2Y4NWY1YTEwZDgwYTRmMzE2NmM5ZmY2MTg) to join Slack channel.
+
+## Ready to try?
+
+Begin by reading our installation guide [here](installation).

docs/installation.md

@@ -2,27 +2,48 @@
 
 This page explains how to prepare your environment for running the bot.
 
-To understand how to set up the bot please read the [Bot Configuration](https://github.com/freqtrade/freqtrade/blob/develop/docs/configuration.md) page.
+## Prerequisite
 
-## Table of Contents
+### Requirements
 
-* [Table of Contents](#table-of-contents)
+Click each one for install guide:
-* [Easy Installation - Linux Script](#easy-installation---linux-script)
-* [Automatic Installation - Docker](#automatic-installation---docker)
-* [Custom Linux MacOS Installation](#custom-installation)
-	- [Requirements](#requirements)
-	- [Linux - Ubuntu 16.04](#linux---ubuntu-1604)
-	- [MacOS](#macos)
-	- [Setup Config and virtual env](#setup-config-and-virtual-env)
-* [Windows](#windows)
 
-<!-- /TOC -->
+* [Python >= 3.6.x](http://docs.python-guide.org/en/latest/starting/installation/)
+* [pip](https://pip.pypa.io/en/stable/installing/)
+* [git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
+* [virtualenv](https://virtualenv.pypa.io/en/stable/installation/) (Recommended)
+* [TA-Lib](https://mrjbq7.github.io/ta-lib/install.html) (install instructions below)
 
-------
+### API keys
+
+Before running your bot in production you will need to setup few
+external API. In production mode, the bot will require valid Exchange API
+credentials. We also recommend a [Telegram bot](telegram-usage.md#setup-your-telegram-bot) (optional but recommended).
+
+### Setup your exchange account
+
+You will need to create API Keys (Usually you get `key` and `secret`) from the Exchange website and insert this into the appropriate fields in the configuration or when asked by the installation script.
+
+## Quick start
+
+Freqtrade provides a Linux/MacOS script to install all dependencies and help you to configure the bot.
+
+!!! Note
+    Python3.6 or higher and the corresponding pip are assumed to be available. The install-script will warn and stop if that's not the case.
+
+```bash
+git clone git@github.com:freqtrade/freqtrade.git
+cd freqtrade
+git checkout develop
+./setup.sh --install
+```
+
+!!! Note
+    Windows installation is explained [here](#windows).
 
 ## Easy Installation - Linux Script
 
-If you are on Debian, Ubuntu or MacOS a freqtrade provides a script to Install, Update, Configure, and Reset your bot.
+If you are on Debian, Ubuntu or MacOS freqtrade provides a script to Install, Update, Configure, and Reset your bot.
 
 ```bash
 $ ./setup.sh
@@ -33,227 +54,45 @@ usage:
 	-c,--config     Easy config generator (Will override your existing file).
 ```
 
-### --install
+** --install **
 
 This script will install everything you need to run the bot:
 
-* Mandatory software as: `Python3`, `ta-lib`, `wget`
+* Mandatory software as: `ta-lib`
 * Setup your virtualenv
 * Configure your `config.json` file
 
 This script is a combination of `install script` `--reset`, `--config`
 
-### --update
+** --update **
 
 Update parameter will pull the last version of your current branch and update your virtualenv.
 
-### --reset
+** --reset **
 
 Reset parameter will hard reset your branch (only if you are on `master` or `develop`) and recreate your virtualenv.
 
-### --config
+** --config **
 
 Config parameter is a `config.json` configurator. This script will ask you questions to setup your bot and create your `config.json`.
 
 ------
 
-## Automatic Installation - Docker
-
-Start by downloading Docker for your platform:
-
-* [Mac](https://www.docker.com/products/docker#/mac)
-* [Windows](https://www.docker.com/products/docker#/windows)
-* [Linux](https://www.docker.com/products/docker#/linux)
-
-Once you have Docker installed, simply create the config file (e.g. `config.json`) and then create a Docker image for `freqtrade` using the Dockerfile in this repo.
-
-### 1. Prepare the Bot
-
-#### 1.1. Clone the git repository
-
-```bash
-git clone https://github.com/freqtrade/freqtrade.git
-```
-
-#### 1.2. (Optional) Checkout the develop branch
-
-```bash
-git checkout develop
-```
-
-#### 1.3. Go into the new directory
-
-```bash
-cd freqtrade
-```
-
-#### 1.4. Copy `config.json.example` to `config.json`
-
-```bash
-cp -n config.json.example config.json
-```
-
-> To edit the config please refer to the [Bot Configuration](https://github.com/freqtrade/freqtrade/blob/develop/docs/configuration.md) page.
-
-#### 1.5. Create your database file *(optional - the bot will create it if it is missing)*
-
-Production
-
-```bash
-touch tradesv3.sqlite
-````
-
-Dry-Run
-
-```bash
-touch tradesv3.dryrun.sqlite
-```
-
-### 2. Download or build the docker image
-
-Either use the prebuilt image from docker hub - or build the image yourself if you would like more control on which version is used.
-
-Branches / tags available can be checked out on [Dockerhub](https://hub.docker.com/r/freqtradeorg/freqtrade/tags/).
-
-#### 2.1. Download the docker image
-
-Pull the image from docker hub and (optionally) change the name of the image
-
-```bash
-docker pull freqtradeorg/freqtrade:develop
-# Optionally tag the repository so the run-commands remain shorter
-docker tag freqtradeorg/freqtrade:develop freqtrade
-```
-
-To update the image, simply run the above commands again and restart your running container.
-
-#### 2.2. Build the Docker image
-
-```bash
-cd freqtrade
-docker build -t freqtrade .
-```
-
-If you are developing using Docker, use `Dockerfile.develop` to build a dev Docker image, which will also set up develop dependencies:
-
-```bash
-docker build -f ./Dockerfile.develop -t freqtrade-dev .
-```
-
-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.
-
-### 3. Verify the Docker image
-
-After the build process you can verify that the image was created with:
-
-```bash
-docker images
-```
-
-### 4. Run the Docker image
-
-You can run a one-off container that is immediately deleted upon exiting with the following command (`config.json` must be in the current working directory):
-
-```bash
-docker run --rm -v /etc/localtime:/etc/localtime:ro -v `pwd`/config.json:/freqtrade/config.json -it freqtrade
-```
-
-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)
-
-In this example, the database will be created inside the docker instance and will be lost when you will refresh your image.
-
-### 5. 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).
-
-#### 5.1. Move your config file and database
-
-```bash
-mkdir ~/.freqtrade
-mv config.json ~/.freqtrade
-mv tradesv3.sqlite ~/.freqtrade
-```
-
-#### 5.2. Run the docker image
-
-```bash
-docker run -d \
-  --name freqtrade \
-  -v /etc/localtime:/etc/localtime:ro \
-  -v ~/.freqtrade/config.json:/freqtrade/config.json \
-  -v ~/.freqtrade/tradesv3.sqlite:/freqtrade/tradesv3.sqlite \
-  freqtrade --db-url sqlite:///tradesv3.sqlite
-```
-
-*Note*: db-url defaults to `sqlite:///tradesv3.sqlite` but it defaults to `sqlite://` if `dry_run=True` is being used.
-To override this behaviour use a custom db-url value: i.e.: `--db-url sqlite:///tradesv3.dryrun.sqlite`
-
-### 6. Monitor your Docker instance
-
-You can then use the following commands to monitor and manage your container:
-
-```bash
-docker logs freqtrade
-docker logs -f freqtrade
-docker restart freqtrade
-docker stop freqtrade
-docker start freqtrade
-```
-
-For more information on how to operate Docker, please refer to the [official Docker documentation](https://docs.docker.com/).
-
-*Note*: You do not need to rebuild the image for configuration changes, it will suffice to edit `config.json` and restart the container.
-
-### 7. Backtest with docker
-
-The following assumes that the above steps (1-4) have been completed successfully.
-Also, backtest-data should be available at `~/.freqtrade/user_data/`.
-
-``` bash
-docker run -d \
-  --name freqtrade \
-  -v /etc/localtime:/etc/localtime:ro \
-  -v ~/.freqtrade/config.json:/freqtrade/config.json \
-  -v ~/.freqtrade/tradesv3.sqlite:/freqtrade/tradesv3.sqlite \
-  -v ~/.freqtrade/user_data/:/freqtrade/user_data/ \
-  freqtrade --strategy AwsomelyProfitableStrategy backtesting
-```
-
-Head over to the [Backtesting Documentation](https://github.com/freqtrade/freqtrade/blob/develop/docs/backtesting.md) for more details.
-
-*Note*: Additional parameters can be appended after the image name (`freqtrade` in the above example).
-
-------
-
 ## Custom Installation
 
 We've included/collected install instructions for Ubuntu 16.04, MacOS, and Windows. These are guidelines and your success may vary with other distros.
-OS Specific steps are listed first, the [common](#common) section below is necessary for all systems.
+OS Specific steps are listed first, the [Common](#common) section below is necessary for all systems.
 
-### Requirements
+!!! Note
-
+    Python3.6 or higher and the corresponding pip are assumed to be available.
-Click each one for install guide:
-
-* [Python >= 3.6.x](http://docs.python-guide.org/en/latest/starting/installation/)
-* [pip](https://pip.pypa.io/en/stable/installing/)
-* [git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
-* [virtualenv](https://virtualenv.pypa.io/en/stable/installation/) (Recommended)
-* [TA-Lib](https://mrjbq7.github.io/ta-lib/install.html)
 
 ### Linux - Ubuntu 16.04
 
-#### Install Python 3.6, Git, and wget
+#### Install necessary dependencies
 
 ```bash
-sudo add-apt-repository ppa:jonathonf/python-3.6
 sudo apt-get update
-sudo apt-get install python3.6 python3.6-venv python3.6-dev build-essential autoconf libtool pkg-config make wget git
+sudo apt-get install build-essential git
 ```
 
 #### Raspberry Pi / Raspbian
@@ -262,7 +101,6 @@ Before installing FreqTrade on a Raspberry Pi running the official Raspbian Imag
 
 The following assumes that miniconda3 is installed and available in your environment. Last miniconda3 installation file use python 3.4, we will update to python 3.6 on this installation.
 It's recommended to use (mini)conda for this as installation/compilation of `numpy`, `scipy` and `pandas` takes a long time.
-If you have installed it from (mini)conda, you can remove `numpy`, `scipy`, and `pandas` from `requirements.txt` before you install it with `pip`.
 
 Additional package to install on your Raspbian, `libffi-dev` required by cryptography (from python-telegram-bot).
 
@@ -274,19 +112,11 @@ conda activate freqtrade
 conda install scipy pandas numpy
 
 sudo apt install libffi-dev
-python3 -m pip install -r requirements.txt
+python3 -m pip install -r requirements-common.txt
 python3 -m pip install -e .
 ```
 
-### MacOS
+### Common
-
-#### Install Python 3.6, git and wget
-
-```bash
-brew install python3 git wget
-```
-
-### common
 
 #### 1. Install TA-Lib
 
@@ -304,11 +134,13 @@ cd ..
 rm -rf ./ta-lib*
 ```
 
-*Note*: An already downloaded version of ta-lib is included in the repository, as the sourceforge.net source seems to have problems frequently.
+!!! Note
+    An already downloaded version of ta-lib is included in the repository, as the sourceforge.net source seems to have problems frequently.
 
 #### 2. Setup your Python virtual environment (virtualenv)
 
-*Note*: This step is optional but strongly recommended to keep your system organized
+!!! Note
+    This step is optional but strongly recommended to keep your system organized
 
 ```bash
 python3 -m venv .env
@@ -324,7 +156,7 @@ git clone https://github.com/freqtrade/freqtrade.git
 
 ```
 
-Optionally checkout the stable/master branch:
+Optionally checkout the master branch to get the latest stable release:
 
 ```bash
 git checkout master
@@ -337,14 +169,14 @@ cd freqtrade
 cp config.json.example config.json
 ```
 
-> *To edit the config please refer to [Bot Configuration](https://github.com/freqtrade/freqtrade/blob/develop/docs/configuration.md).*
+> *To edit the config please refer to [Bot Configuration](configuration.md).*
 
 #### 5. Install python dependencies
 
 ``` bash
-pip3 install --upgrade pip
+python3 -m pip install --upgrade pip
-pip3 install -r requirements.txt
+python3 -m pip install -r requirements.txt
-pip3 install -e .
+python3 -m pip install -e .
 ```
 
 #### 6. Run the Bot
@@ -352,10 +184,10 @@ pip3 install -e .
 If this is the first time you run the bot, ensure you are running it in Dry-run `"dry_run": true,` otherwise it will start to buy and sell coins.
 
 ```bash
-python3.6 ./freqtrade/main.py -c config.json
+freqtrade -c config.json
 ```
 
-*Note*: If you run the bot on a server, you should consider using [Docker](#automatic-installation---docker) a terminal multiplexer like `screen` or [`tmux`](https://en.wikipedia.org/wiki/Tmux) to avoid that the bot is stopped on logout.
+*Note*: If you run the bot on a server, you should consider using [Docker](docker.md) or a terminal multiplexer like `screen` or [`tmux`](https://en.wikipedia.org/wiki/Tmux) to avoid that the bot is stopped on logout.
 
 #### 7. [Optional] Configure `freqtrade` as a `systemd` service
 
@@ -373,11 +205,34 @@ For this to be persistent (run when user is logged out) you'll need to enable `l
 sudo loginctl enable-linger "$USER"
 ```
 
+If you run the bot as a service, you can use systemd service manager as a software watchdog monitoring freqtrade bot 
+state and restarting it in the case of failures. If the `internals.sd_notify` parameter is set to true in the 
+configuration or the `--sd-notify` command line option is used, the bot will send keep-alive ping messages to systemd 
+using the sd_notify (systemd notifications) protocol and will also tell systemd its current state (Running or Stopped) 
+when it changes. 
+
+The `freqtrade.service.watchdog` file contains an example of the service unit configuration file which uses systemd 
+as the watchdog.
+
+!!! Note
+    The sd_notify communication between the bot and the systemd service manager will not work if the bot runs in a Docker container.
+
 ------
 
+## Using Conda
+
+Freqtrade can also be installed using Anaconda (or Miniconda).
+
+``` 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) as this will work much easier and smoother (also more secure).
+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.
@@ -390,13 +245,11 @@ If that is not available on your system, feel free to try the instructions below
 git clone https://github.com/freqtrade/freqtrade.git
 ```
 
-copy paste `config.json` to ``\path\freqtrade-develop\freqtrade`
-
 #### 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 inofficial 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.17‑cp36‑cp36m‑win32.whl` (make sure to use the version matching your python version)
+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.17‑cp36‑cp36m‑win32.whl` (make sure to use the version matching your python version)
 
 ```cmd
 >cd \path\freqtrade-develop
@@ -421,9 +274,9 @@ error: Microsoft Visual C++ 14.0 is required. Get it with "Microsoft Visual C++
 
 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 first.
+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](https://github.com/freqtrade/freqtrade/blob/develop/docs/configuration.md)...
+[Bot Configuration](configuration.md).

docs/partials/header.html

@@ -0,0 +1,52 @@
+<header class="md-header" data-md-component="header">
+    <nav class="md-header-nav md-grid">
+        <div class="md-flex">
+            <div class="md-flex__cell md-flex__cell--shrink">
+                <a href="{{ config.site_url | default(nav.homepage.url, true) | url }}" title="{{ config.site_name }}"
+                    class="md-header-nav__button md-logo">
+                    {% if config.theme.logo.icon %}
+                    <i class="md-icon">{{ config.theme.logo.icon }}</i>
+                    {% else %}
+                    <img src="{{ config.theme.logo | url }}" width="24" height="24">
+                    {% endif %}
+                </a>
+            </div>
+            <div class="md-flex__cell md-flex__cell--shrink">
+                <label class="md-icon md-icon--menu md-header-nav__button" for="__drawer"></label>
+            </div>
+            <div class="md-flex__cell md-flex__cell--stretch">
+                <div class="md-flex__ellipsis md-header-nav__title" data-md-component="title">
+                    {% block site_name %}
+                    {% if config.site_name == page.title %}
+                    {{ config.site_name }}
+                    {% else %}
+                    <span class="md-header-nav__topic">
+                        {{ config.site_name }}
+                    </span>
+                    <span class="md-header-nav__topic">
+                        {{ page.title }}
+                    </span>
+                    {% endif %}
+                    {% endblock %}
+                </div>
+            </div>
+            <div class="md-flex__cell md-flex__cell--shrink">
+                {% block search_box %}
+                {% if "search" in config["plugins"] %}
+                <label class="md-icon md-icon--search md-header-nav__button" for="__search"></label>
+                {% include "partials/search.html" %}
+                {% endif %}
+                {% endblock %}
+            </div>
+            {% if config.repo_url %}
+            <div class="md-flex__cell md-flex__cell--shrink">
+                <div class="md-header-nav__source">
+                    {% include "partials/source.html" %}
+                </div>
+            </div>
+            {% endif %}
+        </div>
+    </nav>
+    <!-- Place this tag in your head or just before your close body tag. -->
+    <script async defer src="https://buttons.github.io/buttons.js"></script>
+</header>

docs/plotting.md

@@ -1,62 +1,75 @@
 # Plotting
-This page explains how to plot prices, indicator, profits.
 
-## Table of Contents
+This page explains how to plot prices, indicators and profits.
-- [Plot price and indicators](#plot-price-and-indicators)
-- [Plot profit](#plot-profit)
 
 ## Installation
 
 Plotting scripts use Plotly library. Install/upgrade it with:
 
+``` bash
+pip install -U -r requirements-plot.txt
 ```
-pip install --upgrade plotly
-```
-
-At least version 2.3.0 is required.
 
 ## Plot price and indicators
+
 Usage for the price plotter:
 
-```
+``` bash
-script/plot_dataframe.py [-h] [-p pair] [--live]
+python3 script/plot_dataframe.py [-h] [-p pairs]
 ```
 
 Example
-```
+
-python scripts/plot_dataframe.py -p BTC/ETH
+``` bash
+python3 scripts/plot_dataframe.py -p BTC/ETH
 ```
 
-The `-p` pair argument, can be used to specify what
+The `-p` pairs argument can be used to specify pairs you would like to plot.
-pair you would like to plot.
 
-**Advanced use**
+Specify custom indicators.
+Use `--indicators1` for the main plot and `--indicators2` for the subplot below (if values are in a different range than prices).
 
-To plot the current live price use the `--live` flag:
+``` bash
+python3 scripts/plot_dataframe.py -p BTC/ETH --indicators1 sma,ema --indicators2 macd
 ```
-python scripts/plot_dataframe.py -p BTC/ETH --live
+
+### Advanced use
+
+To plot multiple pairs, separate them with a comma:
+
+``` bash
+python3 scripts/plot_dataframe.py -p BTC/ETH,XRP/ETH
 ```
 
 To plot a timerange (to zoom in):
+
+``` bash
+python3 scripts/plot_dataframe.py -p BTC/ETH --timerange=20180801-20180805
 ```
-python scripts/plot_dataframe.py -p BTC/ETH --timerange=100-200
-```
-Timerange doesn't work with live data.
 
 To plot trades stored in a database use `--db-url` argument:
-```
+
-python scripts/plot_dataframe.py --db-url sqlite:///tradesv3.dry_run.sqlite -p BTC/ETH
+``` bash
+python3 scripts/plot_dataframe.py --db-url sqlite:///tradesv3.dry_run.sqlite -p BTC/ETH --trade-source DB
 ```
 
-To plot a test strategy the strategy should have first be backtested. 
+To plot trades from a backtesting result, use `--export-filename <filename>`
-The results may then be plotted with the -s argument:
+
+``` bash
+python3 scripts/plot_dataframe.py --export-filename user_data/backtest_results/backtest-result.json -p BTC/ETH
 ```
-python scripts/plot_dataframe.py -s Strategy_Name -p BTC/ETH --datadir user_data/data/<exchange_name>/
+
+To plot a custom strategy the strategy should have first be backtested.
+The results may then be plotted with the -s argument:
+
+``` bash
+python3 scripts/plot_dataframe.py -s Strategy_Name -p BTC/ETH --datadir user_data/data/<exchange_name>/
 ```
 
 ## Plot profit
 
-The profit plotter show a picture with three plots:
+The profit plotter shows a picture with three plots:
+
 1) Average closing price for all pairs
 2) The summarized profit made by backtesting.
    Note that this is not the real-world profit, but
@@ -66,7 +79,7 @@ The profit plotter show a picture with three plots:
 The first graph is good to get a grip of how the overall market
 progresses.
 
-The second graph will show how you algorithm works or doesnt.
+The second graph will show how your algorithm works or doesn't.
 Perhaps you want an algorithm that steadily makes small profits,
 or one that acts less seldom, but makes big swings.
 
@@ -75,13 +88,14 @@ that makes profit spikes.
 
 Usage for the profit plotter:
 
-```
+``` bash
-script/plot_profit.py [-h] [-p pair] [--datadir directory] [--ticker_interval num]
+python3 script/plot_profit.py [-h] [-p pair] [--datadir directory] [--ticker_interval num]
 ```
 
 The `-p` pair argument, can be used to plot a single pair
 
 Example
-```
+
-python3 scripts/plot_profit.py --datadir ../freqtrade/freqtrade/tests/testdata-20171221/ -p BTC_LTC
+``` bash
+python3 scripts/plot_profit.py --datadir ../freqtrade/freqtrade/tests/testdata-20171221/ -p LTC/BTC
 ```

docs/pre-requisite.md

@@ -1,48 +0,0 @@
-# Pre-requisite
-Before running your bot in production you will need to setup few
-external API. In production mode, the bot required valid Bittrex API
-credentials and a Telegram bot (optional but recommended).
-
-## Table of Contents
-- [Setup your Bittrex account](#setup-your-bittrex-account)
-- [Backtesting commands](#setup-your-telegram-bot)
-
-## Setup your Bittrex account
-*To be completed, please feel free to complete this section.*
-
-## Setup your Telegram bot
-The only things you need is a working Telegram bot and its API token.
-Below we explain how to create your Telegram Bot, and how to get your
-Telegram user id.
-
-### 1. Create your Telegram bot
-**1.1. Start a chat with https://telegram.me/BotFather**  
-**1.2. Send the message** `/newbot`  
-*BotFather response:*
-```
-Alright, a new bot. How are we going to call it? Please choose a name for your bot.
-```
-**1.3. Choose the public name of your bot (e.g "`Freqtrade bot`")**  
-*BotFather response:*
-```
-Good. Now let's choose a username for your bot. It must end in `bot`. Like this, for example: TetrisBot or tetris_bot.
-```
-**1.4. Choose the name id of your bot (e.g "`My_own_freqtrade_bot`")**  
-**1.5. Father bot will return you the token (API key)**  
-Copy it and keep it you will use it for the config parameter `token`.  
-*BotFather response:*
-```
-Done! Congratulations on your new bot. You will find it at t.me/My_own_freqtrade_bot. You can now add a description, about section and profile picture for your bot, see /help for a list of commands. By the way, when you've finished creating your cool bot, ping our Bot Support if you want a better username for it. Just make sure the bot is fully operational before you do this.
-
-Use this token to access the HTTP API:
-521095879:AAEcEZEL7ADJ56FtG_qD0bQJSKETbXCBCi0
-
-For a description of the Bot API, see this page: https://core.telegram.org/bots/api
-```
-**1.6. Don't forget to start the conversation with your bot, by clicking /START button**  
-
-### 2. Get your user id
-**2.1. Talk to https://telegram.me/userinfobot**  
-**2.2. Get your "Id", you will use it for the config parameter 
-`chat_id`.**
-

docs/requirements-docs.txt

@@ -0,0 +1 @@
+mkdocs-material==4.4.0

docs/rest-api.md

@@ -0,0 +1,193 @@
+# REST API Usage
+
+## Configuration
+
+Enable the rest API by adding the api_server section to your configuration and setting `api_server.enabled` to `true`.
+
+Sample configuration:
+
+``` json
+    "api_server": {
+        "enabled": true,
+        "listen_ip_address": "127.0.0.1",
+        "listen_port": 8080,
+        "username": "Freqtrader",
+        "password": "SuperSecret1!"
+    },
+```
+
+!!! Danger Security warning
+  By default, the configuration listens on localhost only (so it's not reachable from other systems). We strongly recommend to not expose this API to the internet and choose a strong, unique password, since others will potentially be able to control your bot.
+
+!!! Danger Password selection
+  Please make sure to select a very strong, unique password to protect your bot from unauthorized access.
+
+You can then access the API by going to `http://127.0.0.1:8080/api/v1/version` to check if the API is running correctly.
+
+To generate a secure password, either use a password manager, or use the below code snipped.
+
+``` python
+import secrets
+secrets.token_hex()
+```
+
+### Configuration with docker
+
+If you run your bot using docker, you'll need to have the bot listen to incomming connections. The security is then handled by docker.
+
+``` json
+    "api_server": {
+        "enabled": true,
+        "listen_ip_address": "0.0.0.0",
+        "listen_port": 8080
+    },
+```
+
+Add the following to your docker command:
+
+``` bash
+  -p 127.0.0.1:8080:8080
+```
+
+A complete sample-command may then look as follows:
+
+```bash
+docker run -d \
+  --name freqtrade \
+  -v ~/.freqtrade/config.json:/freqtrade/config.json \
+  -v ~/.freqtrade/user_data/:/freqtrade/user_data \
+  -v ~/.freqtrade/tradesv3.sqlite:/freqtrade/tradesv3.sqlite \
+  -p 127.0.0.1:8080:8080 \
+  freqtrade --db-url sqlite:///tradesv3.sqlite --strategy MyAwesomeStrategy
+```
+
+!!! Danger "Security warning"
+    By using `-p 8080:8080` the API is available to everyone connecting to the server under the correct port, so others may be able to control your bot.
+
+## Consuming the API
+
+You can consume the API by using the script `scripts/rest_client.py`.
+The client script only requires the `requests` module, so FreqTrade does not need to be installed on the system.
+
+``` bash
+python3 scripts/rest_client.py <command> [optional parameters]
+```
+
+By default, the script assumes `127.0.0.1` (localhost) and port `8080` to be used, however you can specify a configuration file to override this behaviour.
+
+### Minimalistic client config
+
+``` json
+{
+    "api_server": {
+        "enabled": true,
+        "listen_ip_address": "0.0.0.0",
+        "listen_port": 8080
+    }
+}
+```
+
+``` bash
+python3 scripts/rest_client.py --config rest_config.json <command> [optional parameters]
+```
+
+## Available commands
+
+|  Command | Default | Description |
+|----------|---------|-------------|
+| `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_conf` | | Reloads the configuration file
+| `status` | | Lists all open trades
+| `status table` | | List all open trades in a table format
+| `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
+| `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>` | 7 | Shows profit or loss per day, over the last n days
+| `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
+
+Possible commands can be listed from the rest-client script using the `help` command.
+
+``` bash
+python3 scripts/rest_client.py help
+```
+
+``` output
+Possible commands:
+balance
+        Get the account balance
+        :returns: json object
+
+blacklist
+        Show the current blacklist
+        :param add: List of coins to add (example: "BNB/BTC")
+        :returns: json object
+
+count
+        Returns the amount of open trades
+        :returns: json object
+
+daily
+        Returns the amount of open trades
+        :returns: json object
+
+edge
+        Returns information about edge
+        :returns: json object
+
+forcebuy
+        Buy an asset
+        :param pair: Pair to buy (ETH/BTC)
+        :param price: Optional - price to buy
+        :returns: json object of the trade
+
+forcesell
+        Force-sell a trade
+        :param tradeid: Id of the trade (can be received via status command)
+        :returns: json object
+
+performance
+        Returns the performance of the different coins
+        :returns: json object
+
+profit
+        Returns the profit summary
+        :returns: json object
+
+reload_conf
+        Reload configuration
+        :returns: json object
+
+start
+        Start the bot if it's in stopped state.
+        :returns: json object
+
+status
+        Get the status of open trades
+        :returns: json object
+
+stop
+        Stop the bot. Use start to restart
+        :returns: json object
+
+stopbuy
+        Stop buying (but handle sells gracefully).
+        use reload_conf to reset
+        :returns: json object
+
+version
+        Returns the version of the bot
+        :returns: json object containing the version
+
+whitelist
+        Show the current whitelist
+        :returns: json object
+```

docs/sql_cheatsheet.md

@@ -1,5 +1,5 @@
 # SQL Helper
-This page constains some help if you want to edit your sqlite db.
+This page contains some help if you want to edit your sqlite db.
 
 ## Install sqlite3
 **Ubuntu/Debian installation**
@@ -44,6 +44,14 @@ CREATE TABLE trades (
 	open_date DATETIME NOT NULL,
 	close_date DATETIME,
 	open_order_id VARCHAR,
+	stop_loss FLOAT,
+	initial_stop_loss FLOAT,
+	stoploss_order_id VARCHAR,
+	stoploss_last_update DATETIME,
+	max_rate FLOAT,
+	sell_reason VARCHAR,
+	strategy VARCHAR,
+	ticker_interval INTEGER,
 	PRIMARY KEY (id),
 	CHECK (is_open IN (0, 1))
 );
@@ -55,38 +63,45 @@ CREATE TABLE trades (
 SELECT * FROM trades;
 ```
 
-## Fix trade still open after a /forcesell
+## 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.
+
+!!! Note
+  	This should not be necessary after /forcesell, as forcesell orders are closed automatically by the bot on the next iteration.
 
 ```sql
 UPDATE trades
-SET is_open=0, close_date=<close_date>, close_rate=<close_rate>, close_profit=close_rate/open_rate-1  
+SET is_open=0, close_date=<close_date>, close_rate=<close_rate>, close_profit=close_rate/open_rate-1, sell_reason=<sell_reason>  
 WHERE id=<trade_ID_to_update>;
 ```
 
-**Example:**
+##### Example
+
 ```sql
 UPDATE trades
-SET is_open=0, close_date='2017-12-20 03:08:45.103418', close_rate=0.19638016, close_profit=0.0496  
+SET is_open=0, close_date='2017-12-20 03:08:45.103418', close_rate=0.19638016, close_profit=0.0496, sell_reason='force_sell'  
 WHERE id=31;
 ```
 
 ## Insert manually a new trade
 
 ```sql
-INSERT 
+INSERT INTO trades (exchange, pair, is_open, fee_open, fee_close, open_rate, stake_amount, amount, open_date)
-INTO trades (exchange, pair, is_open, fee_open, fee_close, open_rate, stake_amount, amount, open_date) 
+VALUES ('bittrex', 'ETH/BTC', 1, 0.0025, 0.0025, <open_rate>, <stake_amount>, <amount>, '<datetime>')
-VALUES ('BITTREX', 'BTC_<COIN>', 1, 0.0025, 0.0025, <open_rate>, <stake_amount>, <amount>, '<datetime>')
 ```
 
-**Example:**
+##### Example:
+
 ```sql
-INSERT INTO trades (exchange, pair, is_open, fee_open, fee_close, open_rate, stake_amount, amount, open_date) VALUES ('BITTREX', 'BTC_ETC', 1, 0.0025, 0.0025, 0.00258580, 0.002, 0.7715262081, '2017-11-28 12:44:24.000000')
+INSERT INTO trades (exchange, pair, is_open, fee_open, fee_close, open_rate, stake_amount, amount, open_date)
+VALUES ('bittrex', 'ETH/BTC', 1, 0.0025, 0.0025, 0.00258580, 0.002, 0.7715262081, '2017-11-28 12:44:24.000000')
 ```
 
 ## Fix wrong fees in the table
-If your DB was created before 
+If your DB was created before [PR#200](https://github.com/freqtrade/freqtrade/pull/200) was merged (before 12/23/17).
-[PR#200](https://github.com/freqtrade/freqtrade/pull/200) was merged
-(before 12/23/17).
 
 ```sql
 UPDATE trades SET fee=0.0025 WHERE fee=0.005;

docs/stoploss.md

@@ -1,17 +1,36 @@
-# Stop Loss support
+# Stop Loss
+
+The `stoploss` configuration parameter is loss in percentage that should trigger a sale.
+For example, value `-0.10` will cause immediate sell if the profit dips below -10% for a given trade. This parameter is optional.
+
+Most of the strategy files already include the optimal `stoploss`
+value. This parameter is optional. If you use it in the configuration file, it will take over the
+`stoploss` value from the strategy file.
+
+## Stop Loss support
 
 At this stage the bot contains the following stoploss support modes:
 
-1. static stop loss, defined in either the strategy or configuration
+1. static stop loss, defined in either the strategy or configuration.
-2. trailing stop loss, defined in the configuration
+2. trailing stop loss, defined in the configuration.
-3. trailing stop loss, custom positive loss, defined in configuration
+3. trailing stop loss, custom positive loss, defined in configuration.
+
+!!! Note
+    All stoploss properties can be configured in either Strategy or configuration. Configuration values override strategy values.
+
+Those stoploss modes can be *on exchange* or *off exchange*. If the stoploss is *on exchange* it means a stoploss limit order is placed on the exchange immediately after buy order happens successfuly. 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.
+
+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. As an example in case of trailing stoploss if the order is on the exchange and the market is going up then the bot automatically cancels the previous stoploss order and put a new one with a stop value higher than previous one. It is clear that the bot cannot do it every 5 seconds otherwise it gets banned. So this parameter will tell the bot how often it should update the stoploss order. The default value is 60 (1 minute).
+
+!!! Note
+    Stoploss on exchange is only supported for Binance as of now.
 
 ## Static Stop Loss
 
 This is very simple, basically you define a stop loss of x in your strategy file or alternative in the configuration, which
 will overwrite the strategy definition. This will basically try to sell your asset, the second the loss exceeds the defined loss.
 
-## Trail Stop Loss
+## Trailing Stop Loss
 
 The initial value for this stop loss, is defined in your strategy or configuration. Just as you would define your Stop Loss normally.
 To enable this Feauture all you have to do is to define the configuration element:
@@ -44,8 +63,21 @@ Both values can be configured in the main configuration file and requires `"trai
 ``` json
     "trailing_stop_positive":  0.01,
     "trailing_stop_positive_offset":  0.011,
+    "trailing_only_offset_is_reached": false
 ```
 
 The 0.01 would translate to a 1% stop loss, once you hit 1.1% profit.
 
 You should also make sure to have this value (`trailing_stop_positive_offset`) lower than your minimal ROI, otherwise minimal ROI will apply first and sell your trade.
+
+If `"trailing_only_offset_is_reached": true` then the trailing stoploss is only activated once the offset is reached. Until then, the stoploss remains at the configured`stoploss`.
+
+## Changing stoploss on open trades
+
+A stoploss on an open trade can be changed by changing the value in the configuration or strategy and use the `/reload_conf` command (alternatively, completely stopping and restarting the bot also works).
+
+The new stoploss value will be applied to open trades (and corresponding log-messages will be generated).
+
+### Limitations
+
+Stoploss values cannot be changed if `trailing_stop` is enabled and the stoploss has already been adjusted, or if [Edge](edge.md) is enabled (since Edge would recalculate stoploss based on the current market situation).

docs/strategy-customization.md

@@ -1,32 +1,11 @@
-# Bot Optimization
+# Optimization
 
 This page explains where to customize your strategies, and add new
 indicators.
 
-## Table of Contents
-
-- [Install a custom strategy file](#install-a-custom-strategy-file)
-- [Customize your strategy](#change-your-strategy)
-  - [Anatomy of a strategy](#anatomy-of-a-strategy)
-  - [Customize indicators](#customize-indicators)
-  - [Buy signal rules](#buy-signal-rules)
-  - [Sell signal rules](#sell-signal-rules)
-  - [Minimal ROI](#minimal-roi)
-  - [Stoploss](#stoploss)
-  - [Ticker interval](#ticker-interval)
-  - [Metadata dict](#metadata-dict)
-  - [Where is the default strategy](#where-is-the-default-strategy)
-  - [Specify custom strategy location](#specify-custom-strategy-location)
-  - [Further strategy ideas](#further-strategy-ideas)
-
-- [Where is the default strategy](#where-is-the-default-strategy)
-
-Since the version `0.16.0` the bot allows using custom strategy file.
-
 ## Install a custom strategy file
 
-This is very simple. Copy paste your strategy file into the folder
+This is very simple. Copy paste your strategy file into the directory `user_data/strategies`.
-`user_data/strategies`.
 
 Let assume you have a class called `AwesomeStrategy` in the file `awesome-strategy.py`:
 
@@ -34,7 +13,7 @@ Let assume you have a class called `AwesomeStrategy` in the file `awesome-strate
 2. Start the bot with the param `--strategy AwesomeStrategy` (the parameter is the class name)
 
 ```bash
-python3 ./freqtrade/main.py --strategy AwesomeStrategy
+freqtrade --strategy AwesomeStrategy
 ```
 
 ## Change your strategy
@@ -42,7 +21,7 @@ python3 ./freqtrade/main.py --strategy AwesomeStrategy
 The bot includes a default strategy file. However, we recommend you to
 use your own file to not have to lose your parameters every time the default
 strategy file will be updated on Github. Put your custom strategy file
-into the folder `user_data/strategies`.
+into the directory `user_data/strategies`.
 
 Best copy the test-strategy and modify this copy to avoid having bot-updates override your changes.
 `cp  user_data/strategies/test_strategy.py user_data/strategies/awesome-strategy.py`
@@ -60,13 +39,25 @@ A strategy file contains all the information needed to build a good strategy:
 The bot also include a sample strategy called `TestStrategy` you can update: `user_data/strategies/test_strategy.py`.
 You can test it with the parameter: `--strategy TestStrategy`
 
-``` bash
+```bash
-python3 ./freqtrade/main.py --strategy AwesomeStrategy
+freqtrade --strategy AwesomeStrategy
 ```
 
 **For the following section we will use the [user_data/strategies/test_strategy.py](https://github.com/freqtrade/freqtrade/blob/develop/user_data/strategies/test_strategy.py)
 file as reference.**
 
+!!! Note Strategies and Backtesting
+    To avoid problems and unexpected differences between Backtesting and dry/live modes, please be aware
+    that during backtesting the full time-interval is passed to the `populate_*()` methods at once.
+    It is therefore best to use vectorized operations (across the whole dataframe, not loops) and
+    avoid index referencing (`df.iloc[-1]`), but instead use `df.shift()` to get to the previous candle.
+
+!!! Warning Using future data
+    Since backtesting passes the full time interval to the `populate_*()` methods, the strategy author
+    needs to take care to avoid having the strategy utilize data from the future.
+    Samples for usage of future data are `dataframe.shift(-1)`, `dataframe.resample("1h")` (this uses the left border of the interval, so moves data from an hour to the start of the hour).
+    They all use data which is not available during regular operations, so these strategies will perform well during backtesting, but will fail / perform badly in dry-runs.
+
 ### Customize Indicators
 
 Buy and sell strategies need indicators. You can add more indicators by extending the list contained in the method `populate_indicators()` from your strategy file.
@@ -118,10 +109,10 @@ def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame
     return dataframe
 ```
 
-#### Want more indicator examples
 
-Look into the [user_data/strategies/test_strategy.py](https://github.com/freqtrade/freqtrade/blob/develop/user_data/strategies/test_strategy.py).
+!!! Note "Want more indicator examples?"
-Then uncomment indicators you need.
+    Look into the [user_data/strategies/test_strategy.py](https://github.com/freqtrade/freqtrade/blob/develop/user_data/strategies/test_strategy.py).<br/>
+    Then uncomment indicators you need.
 
 ### Buy signal rules
 
@@ -199,10 +190,9 @@ minimal_roi = {
 The above configuration would therefore mean:
 
 - Sell whenever 4% profit was reached
-- Sell after 20 minutes when 2% profit was reached
+- Sell when 2% profit was reached (in effect after 20 minutes)
-- Sell after 20 minutes when 2% profit was reached
+- Sell when 1% profit was reached (in effect after 30 minutes)
-- Sell after 30 minutes when 1% profit was reached
+- Sell when trade is non-loosing (in effect after 40 minutes)
-- Sell after 40 minutes when the trade is non-loosing (no profit)
 
 The calculation does include fees.
 
@@ -227,9 +217,12 @@ stoploss = -0.10
 ```
 
 This would signify a stoploss of -10%.
+
+For the full documentation on stoploss features, look at the dedicated [stoploss page](stoploss.md).
+
 If your exchange supports it, it's recommended to also set `"stoploss_on_exchange"` in the order dict, so your stoploss is on the exchange and cannot be missed for network-problems (or other problems).
 
-For more information on order_types please look [here](https://github.com/freqtrade/freqtrade/blob/develop/docs/configuration.md#understand-order_types).
+For more information on order_types please look [here](configuration.md#understand-order_types).
 
 ### Ticker interval
 
@@ -237,12 +230,164 @@ This is the set of candles the bot should download and use for the analysis.
 Common values are `"1m"`, `"5m"`, `"15m"`, `"1h"`, however all values supported by your exchange should work.
 
 Please note that the same buy/sell signals may work with one interval, but not the other.
+This setting is accessible within the strategy by using `self.ticker_interval`.
 
 ### Metadata dict
 
 The metadata-dict (available for `populate_buy_trend`, `populate_sell_trend`, `populate_indicators`) contains additional information.
 Currently this is `pair`, which can be accessed using `metadata['pair']` - and will return a pair in the format `XRP/BTC`.
 
+The Metadata-dict should not be modified and does not persist information across multiple calls.
+Instead, have a look at the section [Storing information](#Storing-information)
+
+### Storing information
+
+Storing information can be accomplished by crating a new dictionary within the strategy class.
+
+The name of the variable can be choosen at will, but should be prefixed with `cust_` to avoid naming collisions with predefined strategy variables.
+
+```python
+class Awesomestrategy(IStrategy):
+    # Create custom dictionary
+    cust_info = {}
+    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        # Check if the entry already exists
+        if "crosstime" in self.cust_info[metadata["pair"]:
+            self.cust_info[metadata["pair"]["crosstime"] += 1
+        else:
+            self.cust_info[metadata["pair"]["crosstime"] = 1
+```
+
+!!! Warning
+  The data is not persisted after a bot-restart (or config-reload). Also, the amount of data should be kept smallish (no DataFrames and such), otherwise the bot will start to consume a lot of memory and eventually run out of memory and crash.
+
+!!! Note
+  If the data is pair-specific, make sure to use pair as one of the keys in the dictionary.
+
+### Additional data (DataProvider)
+
+The strategy provides access to the `DataProvider`. This allows you to get additional data to use in your strategy.
+
+All methods return `None` in case of failure (do not raise an exception).
+
+Please always check the mode of operation to select the correct method to get data (samples see below).
+
+#### Possible options for DataProvider
+
+- `available_pairs` - Property with tuples listing cached pairs with their intervals (pair, interval).
+- `ohlcv(pair, ticker_interval)` - Currently cached ticker data for the pair, returns DataFrame or empty DataFrame.
+- `historic_ohlcv(pair, ticker_interval)` - Returns historical data stored on disk.
+- `get_pair_dataframe(pair, ticker_interval)` - This is a universal method, which returns either historical data (for backtesting) or cached live data (for the Dry-Run and Live-Run modes).
+- `runmode` - Property containing the current runmode.
+
+#### Example: fetch live ohlcv / historic data for the first informative pair
+
+``` python
+if self.dp:
+    inf_pair, inf_timeframe = self.informative_pairs()[0]
+    informative = self.dp.get_pair_dataframe(pair=inf_pair,
+                                             ticker_interval=inf_timeframe)
+```
+
+!!! Warning Warning about backtesting
+    Be carefull when using dataprovider in backtesting. `historic_ohlcv()` (and `get_pair_dataframe()`
+    for the backtesting runmode) provides the full time-range in one go,
+    so please be aware of it and make sure to not "look into the future" to avoid surprises when running in dry/live mode).
+
+!!! Warning Warning in hyperopt
+    This option cannot currently be used during hyperopt.
+
+#### Orderbook
+
+``` python
+if self.dp:
+    if self.dp.runmode in ('live', 'dry_run'):
+        ob = self.dp.orderbook(metadata['pair'], 1)
+        dataframe['best_bid'] = ob['bids'][0][0]
+        dataframe['best_ask'] = ob['asks'][0][0]
+```
+
+!!! Warning
+    The order book is not part of the historic data which means backtesting and hyperopt will not work if this
+    method is used.
+
+#### Available Pairs
+
+``` python
+if self.dp:
+    for pair, ticker in self.dp.available_pairs:
+        print(f"available {pair}, {ticker}")
+```
+
+#### Get data for non-tradeable pairs
+
+Data for additional, informative pairs (reference pairs) can be beneficial for some strategies.
+Ohlcv data for these pairs will be downloaded as part of the regular whitelist refresh process and is available via `DataProvider` just as other pairs (see above).
+These parts will **not** be traded unless they are also specified in the pair whitelist, or have been selected by Dynamic Whitelisting.
+
+The pairs need to be specified as tuples in the format `("pair", "interval")`, with pair as the first and time interval as the second argument.
+
+Sample:
+
+``` python
+def informative_pairs(self):
+    return [("ETH/USDT", "5m"),
+            ("BTC/TUSD", "15m"),
+            ]
+```
+
+!!! Warning
+    As these pairs will be refreshed as part of the regular whitelist refresh, it's best to keep this list short.
+    All intervals and all pairs can be specified as long as they are available (and active) on the used exchange.
+    It is however better to use resampling to longer time-intervals when possible
+    to avoid hammering the exchange with too many requests and risk beeing blocked.
+
+### Additional data - Wallets
+
+The strategy provides access to the `Wallets` object. This contains the current balances on the exchange.
+
+!!! Note
+    Wallets is not available during backtesting / hyperopt.
+
+Please always check if `Wallets` is available to avoid failures during backtesting.
+
+``` python
+if self.wallets:
+    free_eth = self.wallets.get_free('ETH')
+    used_eth = self.wallets.get_used('ETH')
+    total_eth = self.wallets.get_total('ETH')
+```
+
+#### Possible options for Wallets
+
+- `get_free(asset)` - currently available balance to trade
+- `get_used(asset)` - currently tied up balance (open orders)
+- `get_total(asset)` - total available balance - sum of the 2 above
+
+### Print created dataframe
+
+To inspect the created dataframe, you can issue a print-statement in either `populate_buy_trend()` or `populate_sell_trend()`.
+You may also want to print the pair so it's clear what data is currently shown.
+
+``` python
+def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+    dataframe.loc[
+        (
+            #>> whatever condition<<<
+        ),
+        'buy'] = 1
+
+    # Print the Analyzed pair
+    print(f"result for {metadata['pair']}")
+
+    # Inspect the last 5 rows
+    print(dataframe.tail())
+
+    return dataframe
+```
+
+Printing more than a few rows is also possible (simply use  `print(dataframe)` instead of `print(dataframe.tail())`), however not recommended, as that will be very verbose (~500 lines per pair every 5 seconds).
+
 ### Where is the default strategy?
 
 The default buy strategy is located in the file
@@ -250,10 +395,10 @@ The default buy strategy is located in the file
 
 ### Specify custom strategy location
 
-If you want to use a strategy from a different folder you can pass `--strategy-path`
+If you want to use a strategy from a different directory you can pass `--strategy-path`
 
 ```bash
-python3 ./freqtrade/main.py --strategy AwesomeStrategy --strategy-path /some/folder
+freqtrade --strategy AwesomeStrategy --strategy-path /some/directory
 ```
 
 ### Further strategy ideas
@@ -262,9 +407,9 @@ 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/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE) which is a great place to get and/or share ideas.
+We also got a *strategy-sharing* channel in our [Slack community](https://join.slack.com/t/highfrequencybot/shared_invite/enQtNjU5ODcwNjI1MDU3LWEyODBiNzkzNzcyNzU0MWYyYzE5NjIyOTQxMzBmMGUxOTIzM2YyN2Y4NWY1YTEwZDgwYTRmMzE2NmM5ZmY2MTg) 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.
-Your next step is to learn [How to use the Backtesting](https://github.com/freqtrade/freqtrade/blob/develop/docs/backtesting.md).
+Your next step is to learn [How to use the Backtesting](backtesting.md).

docs/telegram-usage.md

@@ -1,13 +1,48 @@
 # Telegram usage
 
-This page explains how to command your bot with Telegram.
+## Setup your Telegram bot
 
-## Pre-requisite
+Below we explain how to create your Telegram Bot, and how to get your
-To control your bot with Telegram, you need first to 
+Telegram user id.
-[set up a Telegram bot](https://github.com/freqtrade/freqtrade/blob/develop/docs/pre-requisite.md) 
+
-and add your Telegram API keys into your config file.
+### 1. Create your Telegram bot
+
+Start a chat with the [Telegram BotFather](https://telegram.me/BotFather)
+
+Send the message `/newbot`. 
+
+*BotFather response:*
+
+> Alright, a new bot. How are we going to call it? Please choose a name for your bot.
+
+Choose the public name of your bot (e.x. `Freqtrade bot`)
+
+*BotFather response:*
+
+> Good. Now let's choose a username for your bot. It must end in `bot`. Like this, for example: TetrisBot or tetris_bot.
+
+Choose the name id of your bot and send it to the BotFather (e.g. "`My_own_freqtrade_bot`")
+
+*BotFather response:*
+
+> Done! Congratulations on your new bot. You will find it at `t.me/yourbots_name_bot`. You can now add a description, about section and profile picture for your bot, see /help for a list of commands. By the way, when you've finished creating your cool bot, ping our Bot Support if you want a better username for it. Just make sure the bot is fully operational before you do this.
+
+> Use this token to access the HTTP API: `22222222:APITOKEN`
+
+> For a description of the Bot API, see this page: https://core.telegram.org/bots/api Father bot will return you the token (API key)
+
+Copy the API Token (`22222222:APITOKEN` in the above example) and keep use it for the config parameter `token`.
+
+Don't forget to start the conversation with your bot, by clicking `/START` button
+
+### 2. 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`.
 
 ## Telegram commands
+
 Per default, the Telegram bot shows predefined commands. Some commands
 are only available by sending them to the bot. The table below list the
 official commands. You can ask at any moment for help with `/help`.
@@ -16,6 +51,7 @@ official commands. You can ask at any moment for help with `/help`.
 |----------|---------|-------------|
 | `/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_conf` | | Reloads the configuration file
 | `/status` | | Lists all open trades
 | `/status table` | | List all open trades in a table format
@@ -27,6 +63,9 @@ official commands. You can ask at any moment for help with `/help`.
 | `/performance` | | Show performance of each finished trade grouped by pair
 | `/balance` | | Show account balance per currency
 | `/daily <n>` | 7 | Shows profit or loss per day, over the last n days
+| `/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.
 | `/help` | | Show help message
 | `/version` | | Show version
 
@@ -43,22 +82,34 @@ Below, example of Telegram message you will receive for each command.
 > `Stopping trader ...`
 > **Status:** `stopped`
 
-## /status
+### /stopbuy
+
+> **status:** `Setting max_open_trades to 0. Run /reload_conf to reset.`
+
+Prevents the bot from opening new trades by temporarily setting "max_open_trades" to 0. Open trades will be handled via their regular rules (ROI / Sell-signal, stoploss, ...).
+
+After this, give the bot time to close off open trades (can be checked via `/status table`).
+Once all positions are sold, run `/stop` to completely stop the bot.
+
+`/reload_conf` resets "max_open_trades" to the value set in the configuration and resets this command. 
+
+!!! warning
+   The stop-buy signal is ONLY active while the bot is running, and is not persisted anyway, so restarting the bot will cause this to reset.
+
+### /status
 
 For each open trade, the bot will send you the following message.
 
-> **Trade ID:** `123`  
+> **Trade ID:** `123` `(since 1 days ago)`  
 > **Current Pair:** CVC/BTC  
 > **Open Since:** `1 days ago`  
 > **Amount:** `26.64180098`  
 > **Open Rate:** `0.00007489`  
-> **Close Rate:** `None`  
 > **Current Rate:** `0.00007489`  
-> **Close Profit:** `None`  
 > **Current Profit:** `12.95%`  
-> **Open Order:** `None`
+> **Stoploss:** `0.00007389 (-0.02%)`  
 
-## /status table
+### /status table
 
 Return the status of all open trades in a table format.
 ```
@@ -68,7 +119,7 @@ Return the status of all open trades in a table format.
  123  CVC/BTC   1 h      12.95%
 ```
 
-## /count
+### /count
 
 Return the number of trades used and available.
 ```
@@ -77,7 +128,7 @@ current    max
      2     10
 ```
 
-## /profit
+### /profit
 
 Return a summary of your profit/loss and performance.
 
@@ -94,17 +145,19 @@ Return a summary of your profit/loss and performance.
 > **Avg. Duration:** `2:33:45`  
 > **Best Performing:** `PAY/BTC: 50.23%`  
 
-## /forcesell <trade_id>
+### /forcesell <trade_id>
 
 > **BITTREX:** Selling BTC/LTC with limit `0.01650000 (profit: ~-4.07%, -0.00008168)`
 
-## /forcebuy <pair> 
+### /forcebuy <pair>
 
-> **BITTREX**: Buying ETH/BTC with limit `0.03400000` (`1.000000 ETH`, `225.290 USD`)
+> **BITTREX:** Buying ETH/BTC with limit `0.03400000` (`1.000000 ETH`, `225.290 USD`)
 
 Note that for this to work, `forcebuy_enable` needs to be set to true.
 
-## /performance
+[More details](configuration.md/#understand-forcebuy_enable)
+
+### /performance
 
 Return the performance of each crypto-currency the bot has sold.
 > Performance:
@@ -115,7 +168,7 @@ Return the performance of each crypto-currency the bot has sold.
 > 5. `STORJ/BTC 27.24%`  
 > ...  
 
-## /balance
+### /balance
 
 Return the balance of all crypto-currency your have on the exchange.
 
@@ -129,7 +182,7 @@ Return the balance of all crypto-currency your have on the exchange.
 > **Balance:** 86.64180098  
 > **Pending:** 0.0  
 
-## /daily <n>
+### /daily <n>
 
 Per default `/daily` will return the 7 last days.
 The example below if for `/daily 3`:
@@ -143,7 +196,38 @@ Day         Profit BTC      Profit USD
 2018-01-01  0.00269130 BTC  34.986 USD
 ```
 
-## /version
+### /whitelist
+
+Shows the current whitelist
+
+> Using whitelist `StaticPairList` with 22 pairs  
+> `IOTA/BTC, NEO/BTC, TRX/BTC, VET/BTC, ADA/BTC, ETC/BTC, NCASH/BTC, DASH/BTC, XRP/BTC, XVG/BTC, EOS/BTC, LTC/BTC, OMG/BTC, BTG/BTC, LSK/BTC, ZEC/BTC, HOT/BTC, IOTX/BTC, XMR/BTC, AST/BTC, XLM/BTC, NANO/BTC`
+
+### /blacklist [pair]
+
+Shows the current blacklist.
+If Pair is set, then this pair will be added to the pairlist.
+Also supports multiple pairs, seperated by a space.
+Use `/reload_conf` to reset the blacklist.
+
+> Using blacklist `StaticPairList` with 2 pairs  
+>`DODGE/BTC`, `HOT/BTC`.
+
+### /edge
+
+Shows pairs validated by Edge along with their corresponding winrate, expectancy and stoploss values.
+
+> **Edge only validated following pairs:**
+```
+Pair        Winrate    Expectancy    Stoploss
+--------  ---------  ------------  ----------
+DOCK/ETH   0.522727      0.881821       -0.03
+PHX/ETH    0.677419      0.560488       -0.03
+HOT/ETH    0.733333      0.490492       -0.03
+HC/ETH     0.588235      0.280988       -0.02
+ARDR/ETH   0.366667      0.143059       -0.01
+```
+
+### /version
 
 > **Version:** `0.14.3`
-

docs/webhook-config.md

@@ -1,7 +1,5 @@
 # Webhook usage
 
-This page explains how to configure your bot to talk to webhooks.
-
 ## Configuration
 
 Enable webhooks by adding a webhook-section to your configuration file, and setting `webhook.enabled` to `true`.
@@ -39,34 +37,32 @@ Different payloads can be configured for different events. Not all fields are ne
 The fields in `webhook.webhookbuy` are filled when the bot executes a buy. Parameters are filled using string.format.
 Possible parameters are:
 
-* exchange
+* `exchange`
-* pair
+* `pair`
-* market_url
+* `limit`
-* limit
+* `stake_amount`
-* stake_amount
+* `stake_currency`
-* stake_amount_fiat
+* `fiat_currency`
-* stake_currency
+* `order_type`
-* fiat_currency
 
 ### Webhooksell
 
 The fields in `webhook.webhooksell` are filled when the bot sells a trade. Parameters are filled using string.format.
 Possible parameters are:
 
-* exchange
+* `exchange`
-* pair
+* `pair`
-* gain
+* `gain`
-* market_url
+* `limit`
-* limit
+* `amount`
-* amount
+* `open_rate`
-* open_rate
+* `current_rate`
-* current_rate
+* `profit_amount`
-* profit_amount
+* `profit_percent`
-* profit_percent
+* `stake_currency`
-* profit_fiat
+* `fiat_currency`
-* stake_currency
+* `sell_reason`
-* fiat_currency
+* `order_type`
-* sell_reason
 
 ### Webhookstatus
 

environment.yml

@@ -0,0 +1,59 @@
+name: freqtrade
+channels:
+  - defaults
+  - conda-forge
+dependencies:
+  # Required for app
+  - python>=3.6
+  - pip
+  - wheel
+  - numpy
+  - pandas
+  - scipy
+  - SQLAlchemy
+  - scikit-learn
+  - arrow
+  - requests
+  - urllib3
+  - wrapt
+  - joblib
+  - jsonschema
+  - tabulate
+  - python-rapidjson
+  - filelock
+  - flask
+  - python-dotenv
+  - cachetools
+  - scikit-optimize
+  - python-telegram-bot
+  # Optional for plotting
+  - plotly
+  # Optional for development
+  - flake8
+  - pytest
+  - pytest-mock
+  - pytest-asyncio
+  - pytest-cov
+  - coveralls
+  - mypy
+  # Useful for jupyter
+  - jupyter
+  - ipykernel
+  - isort
+  - yapf
+  - pip:
+    # Required for app
+    - cython
+    - coinmarketcap
+    - ccxt
+    - TA-Lib
+    - py_find_1st
+    - sdnotify
+    # Optional for develpment
+    - flake8-tidy-imports
+    - flake8-type-annotations
+    - pytest-random-order
+    - -e .
+
+
+

freqtrade.service

@@ -6,7 +6,7 @@ After=network.target
 # Set WorkingDirectory and ExecStart to your file paths accordingly
 # NOTE: %h will be resolved to /home/<username>
 WorkingDirectory=%h/freqtrade
-ExecStart=/usr/bin/freqtrade --dynamic-whitelist 40
+ExecStart=/usr/bin/freqtrade
 Restart=on-failure
 
 [Install]

freqtrade.service.watchdog

@@ -0,0 +1,30 @@
+[Unit]
+Description=Freqtrade Daemon
+After=network.target
+
+[Service]
+# Set WorkingDirectory and ExecStart to your file paths accordingly
+# NOTE: %h will be resolved to /home/<username>
+WorkingDirectory=%h/freqtrade
+ExecStart=/usr/bin/freqtrade --sd-notify
+
+Restart=always
+#Restart=on-failure
+
+# Note that we use Type=notify here
+Type=notify
+
+# Currently required if Type=notify
+NotifyAccess=all
+
+StartLimitInterval=1min
+StartLimitBurst=5
+
+TimeoutStartSec=1min
+
+# Use here (process_throttle_secs * 2) or longer time interval
+WatchdogSec=20
+
+[Install]
+WantedBy=default.target
+

freqtrade/__init__.py

@@ -1,15 +1,15 @@
 """ FreqTrade bot """
-__version__ = '0.18.0'
+__version__ = '2019.8-1'
 
 
-class DependencyException(BaseException):
+class DependencyException(Exception):
     """
-    Indicates that a assumed dependency is not met.
+    Indicates that an assumed dependency is not met.
     This could happen when there is currently not enough money on the account.
     """
 
 
-class OperationalException(BaseException):
+class OperationalException(Exception):
     """
     Requires manual intervention.
     This happens when an exchange returns an unexpected error during runtime
@@ -17,7 +17,15 @@ class OperationalException(BaseException):
     """
 
 
-class TemporaryError(BaseException):
+class InvalidOrderException(Exception):
+    """
+    This is returned when the order is not valid. Example:
+    If stoploss on exchange order is hit, then trying to cancel the order
+    should return this exception.
+    """
+
+
+class TemporaryError(Exception):
     """
     Temporary network or exchange related error.
     This could happen when an exchange is congested, unavailable, or the user

freqtrade/__main__.py

@@ -6,10 +6,7 @@ To launch Freqtrade as a module
 > python -m freqtrade (with Python >= 3.6)
 """
 
-import sys
-
 from freqtrade import main
 
 if __name__ == '__main__':
-    main.set_loggers()
+    main.main()
-    main.main(sys.argv[1:])

freqtrade/arguments.py

@@ -1,423 +0,0 @@
-"""
-This module contains the argument manager class
-"""
-
-import argparse
-import os
-import re
-from typing import List, NamedTuple, Optional
-
-import arrow
-
-from freqtrade import __version__, constants
-
-
-class TimeRange(NamedTuple):
-    """
-    NamedTuple Defining timerange inputs.
-    [start/stop]type defines if [start/stop]ts shall be used.
-    if *type is none, don't use corresponding startvalue.
-    """
-    starttype: Optional[str] = None
-    stoptype: Optional[str] = None
-    startts: int = 0
-    stopts: int = 0
-
-
-class Arguments(object):
-    """
-    Arguments Class. Manage the arguments received by the cli
-    """
-
-    def __init__(self, args: List[str], description: str) -> None:
-        self.args = args
-        self.parsed_arg: Optional[argparse.Namespace] = None
-        self.parser = argparse.ArgumentParser(description=description)
-
-    def _load_args(self) -> None:
-        self.common_args_parser()
-        self._build_subcommands()
-
-    def get_parsed_arg(self) -> argparse.Namespace:
-        """
-        Return the list of arguments
-        :return: List[str] List of arguments
-        """
-        if self.parsed_arg is None:
-            self._load_args()
-            self.parsed_arg = self.parse_args()
-
-        return self.parsed_arg
-
-    def parse_args(self) -> argparse.Namespace:
-        """
-        Parses given arguments and returns an argparse Namespace instance.
-        """
-        parsed_arg = self.parser.parse_args(self.args)
-
-        return parsed_arg
-
-    def common_args_parser(self) -> None:
-        """
-        Parses given common arguments and returns them as a parsed object.
-        """
-        self.parser.add_argument(
-            '-v', '--verbose',
-            help='verbose mode (-vv for more, -vvv to get all messages)',
-            action='count',
-            dest='loglevel',
-            default=0,
-        )
-        self.parser.add_argument(
-            '--version',
-            action='version',
-            version=f'%(prog)s {__version__}'
-        )
-        self.parser.add_argument(
-            '-c', '--config',
-            help='specify configuration file (default: %(default)s)',
-            dest='config',
-            default='config.json',
-            type=str,
-            metavar='PATH',
-        )
-        self.parser.add_argument(
-            '-d', '--datadir',
-            help='path to backtest data',
-            dest='datadir',
-            default=None,
-            type=str,
-            metavar='PATH',
-        )
-        self.parser.add_argument(
-            '-s', '--strategy',
-            help='specify strategy class name (default: %(default)s)',
-            dest='strategy',
-            default='DefaultStrategy',
-            type=str,
-            metavar='NAME',
-        )
-        self.parser.add_argument(
-            '--strategy-path',
-            help='specify additional strategy lookup path',
-            dest='strategy_path',
-            type=str,
-            metavar='PATH',
-        )
-        self.parser.add_argument(
-            '--customhyperopt',
-            help='specify hyperopt class name (default: %(default)s)',
-            dest='hyperopt',
-            default=constants.DEFAULT_HYPEROPT,
-            type=str,
-            metavar='NAME',
-        )
-        self.parser.add_argument(
-            '--dynamic-whitelist',
-            help='dynamically generate and update whitelist'
-                 ' based on 24h BaseVolume (default: %(const)s)'
-                 ' DEPRECATED.',
-            dest='dynamic_whitelist',
-            const=constants.DYNAMIC_WHITELIST,
-            type=int,
-            metavar='INT',
-            nargs='?',
-        )
-        self.parser.add_argument(
-            '--db-url',
-            help='Override trades database URL, this is useful if dry_run is enabled'
-                 ' or in custom deployments (default: %(default)s)',
-            dest='db_url',
-            type=str,
-            metavar='PATH',
-        )
-
-    @staticmethod
-    def backtesting_options(parser: argparse.ArgumentParser) -> None:
-        """
-        Parses given arguments for Backtesting scripts.
-        """
-        parser.add_argument(
-            '--eps', '--enable-position-stacking',
-            help='Allow buying the same pair multiple times (position stacking)',
-            action='store_true',
-            dest='position_stacking',
-            default=False
-        )
-
-        parser.add_argument(
-            '--dmmp', '--disable-max-market-positions',
-            help='Disable applying `max_open_trades` during backtest '
-                 '(same as setting `max_open_trades` to a very high number)',
-            action='store_false',
-            dest='use_max_market_positions',
-            default=True
-        )
-        parser.add_argument(
-            '-l', '--live',
-            help='using live data',
-            action='store_true',
-            dest='live',
-        )
-        parser.add_argument(
-            '-r', '--refresh-pairs-cached',
-            help='refresh the pairs files in tests/testdata with the latest data from the '
-                 'exchange. Use it if you want to run your backtesting with up-to-date data.',
-            action='store_true',
-            dest='refresh_pairs',
-        )
-        parser.add_argument(
-            '--strategy-list',
-            help='Provide a commaseparated list of strategies to backtest '
-                 'Please note that ticker-interval needs to be set either in config '
-                 'or via command line. When using this together with --export trades, '
-                 'the strategy-name is injected into the filename '
-                 '(so backtest-data.json becomes backtest-data-DefaultStrategy.json',
-            nargs='+',
-            dest='strategy_list',
-        )
-        parser.add_argument(
-            '--export',
-            help='export backtest results, argument are: trades\
-                  Example --export=trades',
-            type=str,
-            default=None,
-            dest='export',
-        )
-        parser.add_argument(
-            '--export-filename',
-            help='Save backtest results to this filename \
-                  requires --export to be set as well\
-                  Example --export-filename=user_data/backtest_data/backtest_today.json\
-                  (default: %(default)s)',
-            type=str,
-            default=os.path.join('user_data', 'backtest_data', 'backtest-result.json'),
-            dest='exportfilename',
-            metavar='PATH',
-        )
-
-    @staticmethod
-    def edge_options(parser: argparse.ArgumentParser) -> None:
-        """
-        Parses given arguments for Backtesting scripts.
-        """
-        parser.add_argument(
-            '-r', '--refresh-pairs-cached',
-            help='refresh the pairs files in tests/testdata with the latest data from the '
-                 'exchange. Use it if you want to run your edge with up-to-date data.',
-            action='store_true',
-            dest='refresh_pairs',
-        )
-        parser.add_argument(
-            '--stoplosses',
-            help='defines a range of stoploss against which edge will assess the strategy '
-                 'the format is "min,max,step" (without any space).'
-                 'example: --stoplosses=-0.01,-0.1,-0.001',
-            type=str,
-            dest='stoploss_range',
-        )
-
-    @staticmethod
-    def optimizer_shared_options(parser: argparse.ArgumentParser) -> None:
-        """
-        Parses given common arguments for Backtesting and Hyperopt scripts.
-        :param parser:
-        :return:
-        """
-        parser.add_argument(
-            '-i', '--ticker-interval',
-            help='specify ticker interval (1m, 5m, 30m, 1h, 1d)',
-            dest='ticker_interval',
-            type=str,
-        )
-
-        parser.add_argument(
-            '--timerange',
-            help='specify what timerange of data to use.',
-            default=None,
-            type=str,
-            dest='timerange',
-        )
-
-    @staticmethod
-    def hyperopt_options(parser: argparse.ArgumentParser) -> None:
-        """
-        Parses given arguments for Hyperopt scripts.
-        """
-        parser.add_argument(
-            '--eps', '--enable-position-stacking',
-            help='Allow buying the same pair multiple times (position stacking)',
-            action='store_true',
-            dest='position_stacking',
-            default=False
-        )
-
-        parser.add_argument(
-            '--dmmp', '--disable-max-market-positions',
-            help='Disable applying `max_open_trades` during backtest '
-                 '(same as setting `max_open_trades` to a very high number)',
-            action='store_false',
-            dest='use_max_market_positions',
-            default=True
-        )
-        parser.add_argument(
-            '-e', '--epochs',
-            help='specify number of epochs (default: %(default)d)',
-            dest='epochs',
-            default=constants.HYPEROPT_EPOCH,
-            type=int,
-            metavar='INT',
-        )
-        parser.add_argument(
-            '-s', '--spaces',
-            help='Specify which parameters to hyperopt. Space separate list. \
-                  Default: %(default)s',
-            choices=['all', 'buy', 'roi', 'stoploss'],
-            default='all',
-            nargs='+',
-            dest='spaces',
-        )
-
-    def _build_subcommands(self) -> None:
-        """
-        Builds and attaches all subcommands
-        :return: None
-        """
-        from freqtrade.optimize import backtesting, hyperopt, edge_cli
-
-        subparsers = self.parser.add_subparsers(dest='subparser')
-
-        # Add backtesting subcommand
-        backtesting_cmd = subparsers.add_parser('backtesting', help='backtesting module')
-        backtesting_cmd.set_defaults(func=backtesting.start)
-        self.optimizer_shared_options(backtesting_cmd)
-        self.backtesting_options(backtesting_cmd)
-
-        # Add edge subcommand
-        edge_cmd = subparsers.add_parser('edge', help='edge module')
-        edge_cmd.set_defaults(func=edge_cli.start)
-        self.optimizer_shared_options(edge_cmd)
-        self.edge_options(edge_cmd)
-
-        # Add hyperopt subcommand
-        hyperopt_cmd = subparsers.add_parser('hyperopt', help='hyperopt module')
-        hyperopt_cmd.set_defaults(func=hyperopt.start)
-        self.optimizer_shared_options(hyperopt_cmd)
-        self.hyperopt_options(hyperopt_cmd)
-
-    @staticmethod
-    def parse_timerange(text: Optional[str]) -> TimeRange:
-        """
-        Parse the value of the argument --timerange to determine what is the range desired
-        :param text: value from --timerange
-        :return: Start and End range period
-        """
-        if text is None:
-            return TimeRange(None, None, 0, 0)
-        syntax = [(r'^-(\d{8})$', (None, 'date')),
-                  (r'^(\d{8})-$', ('date', None)),
-                  (r'^(\d{8})-(\d{8})$', ('date', 'date')),
-                  (r'^-(\d{10})$', (None, 'date')),
-                  (r'^(\d{10})-$', ('date', None)),
-                  (r'^(\d{10})-(\d{10})$', ('date', 'date')),
-                  (r'^(-\d+)$', (None, 'line')),
-                  (r'^(\d+)-$', ('line', None)),
-                  (r'^(\d+)-(\d+)$', ('index', 'index'))]
-        for rex, stype in syntax:
-            # Apply the regular expression to text
-            match = re.match(rex, text)
-            if match:  # Regex has matched
-                rvals = match.groups()
-                index = 0
-                start: int = 0
-                stop: int = 0
-                if stype[0]:
-                    starts = rvals[index]
-                    if stype[0] == 'date' and len(starts) == 8:
-                        start = arrow.get(starts, 'YYYYMMDD').timestamp
-                    else:
-                        start = int(starts)
-                    index += 1
-                if stype[1]:
-                    stops = rvals[index]
-                    if stype[1] == 'date' and len(stops) == 8:
-                        stop = arrow.get(stops, 'YYYYMMDD').timestamp
-                    else:
-                        stop = int(stops)
-                return TimeRange(stype[0], stype[1], start, stop)
-        raise Exception('Incorrect syntax for timerange "%s"' % text)
-
-    def scripts_options(self) -> None:
-        """
-        Parses given arguments for scripts.
-        """
-        self.parser.add_argument(
-            '-p', '--pair',
-            help='Show profits for only this pairs. Pairs are comma-separated.',
-            dest='pair',
-            default=None
-        )
-
-    def testdata_dl_options(self) -> None:
-        """
-        Parses given arguments for testdata download
-        """
-        self.parser.add_argument(
-            '--pairs-file',
-            help='File containing a list of pairs to download',
-            dest='pairs_file',
-            default=None,
-            metavar='PATH',
-        )
-
-        self.parser.add_argument(
-            '--export',
-            help='Export files to given dir',
-            dest='export',
-            default=None,
-            metavar='PATH',
-        )
-
-        self.parser.add_argument(
-            '-c', '--config',
-            help='specify configuration file, used for additional exchange parameters',
-            dest='config',
-            default=None,
-            type=str,
-            metavar='PATH',
-        )
-
-        self.parser.add_argument(
-            '--days',
-            help='Download data for number of days',
-            dest='days',
-            type=int,
-            metavar='INT',
-            default=None
-        )
-
-        self.parser.add_argument(
-            '--exchange',
-            help='Exchange name (default: %(default)s). Only valid if no config is provided',
-            dest='exchange',
-            type=str,
-            default='bittrex'
-        )
-
-        self.parser.add_argument(
-            '-t', '--timeframes',
-            help='Specify which tickers to download. Space separated list. \
-                  Default: %(default)s',
-            choices=['1m', '3m', '5m', '15m', '30m', '1h', '2h', '4h',
-                     '6h', '8h', '12h', '1d', '3d', '1w'],
-            default=['1m', '5m'],
-            nargs='+',
-            dest='timeframes',
-        )
-
-        self.parser.add_argument(
-            '--erase',
-            help='Clean all existing data for the selected exchange/pairs/timeframes',
-            dest='erase',
-            action='store_true'
-        )

freqtrade/configuration.py

@@ -1,325 +0,0 @@
-"""
-This module contains the configuration class
-"""
-import json
-import logging
-import os
-from argparse import Namespace
-from typing import Any, Dict, Optional
-
-import ccxt
-from jsonschema import Draft4Validator, validate
-from jsonschema.exceptions import ValidationError, best_match
-
-from freqtrade import OperationalException, constants
-logger = logging.getLogger(__name__)
-
-
-def set_loggers(log_level: int = 0) -> None:
-    """
-    Set the logger level for Third party libs
-    :return: None
-    """
-
-    logging.getLogger('requests').setLevel(logging.INFO if log_level <= 1 else logging.DEBUG)
-    logging.getLogger("urllib3").setLevel(logging.INFO if log_level <= 1 else logging.DEBUG)
-    logging.getLogger('ccxt.base.exchange').setLevel(
-        logging.INFO if log_level <= 2 else logging.DEBUG)
-    logging.getLogger('telegram').setLevel(logging.INFO)
-
-
-class Configuration(object):
-    """
-    Class to read and init the bot configuration
-    Reuse this class for the bot, backtesting, hyperopt and every script that required configuration
-    """
-
-    def __init__(self, args: Namespace) -> None:
-        self.args = args
-        self.config: Optional[Dict[str, Any]] = None
-
-    def load_config(self) -> Dict[str, Any]:
-        """
-        Extract information for sys.argv and load the bot configuration
-        :return: Configuration dictionary
-        """
-        logger.info('Using config: %s ...', self.args.config)
-        config = self._load_config_file(self.args.config)
-
-        # Set strategy if not specified in config and or if it's non default
-        if self.args.strategy != constants.DEFAULT_STRATEGY or not config.get('strategy'):
-            config.update({'strategy': self.args.strategy})
-
-        if self.args.strategy_path:
-            config.update({'strategy_path': self.args.strategy_path})
-
-        # Add the hyperopt file to use
-        config.update({'hyperopt': self.args.hyperopt})
-
-        # Load Common configuration
-        config = self._load_common_config(config)
-
-        # Load Backtesting
-        config = self._load_backtesting_config(config)
-
-        # Load Edge
-        config = self._load_edge_config(config)
-
-        # Load Hyperopt
-        config = self._load_hyperopt_config(config)
-
-        return config
-
-    def _load_config_file(self, path: str) -> Dict[str, Any]:
-        """
-        Loads a config file from the given path
-        :param path: path as str
-        :return: configuration as dictionary
-        """
-        try:
-            with open(path) as file:
-                conf = json.load(file)
-        except FileNotFoundError:
-            raise OperationalException(
-                f'Config file "{path}" not found!'
-                ' Please create a config file or check whether it exists.')
-
-        if 'internals' not in conf:
-            conf['internals'] = {}
-        logger.info('Validating configuration ...')
-
-        return self._validate_config(conf)
-
-    def _load_common_config(self, config: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Extract information for sys.argv and load common configuration
-        :return: configuration as dictionary
-        """
-
-        # Log level
-        if 'loglevel' in self.args and self.args.loglevel:
-            config.update({'verbosity': self.args.loglevel})
-        else:
-            config.update({'verbosity': 0})
-        logging.basicConfig(
-            level=logging.INFO if config['verbosity'] < 1 else logging.DEBUG,
-            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-        )
-        set_loggers(config['verbosity'])
-        logger.info('Verbosity set to %s', config['verbosity'])
-
-        # Add dynamic_whitelist if found
-        if 'dynamic_whitelist' in self.args and self.args.dynamic_whitelist:
-            # Update to volumePairList (the previous default)
-            config['pairlist'] = {'method': 'VolumePairList',
-                                  'config': {'number_assets': self.args.dynamic_whitelist}
-                                  }
-            logger.warning(
-                'Parameter --dynamic-whitelist has been deprecated, '
-                'and will be completely replaced by the whitelist dict in the future. '
-                'For now: using dynamically generated whitelist based on VolumePairList. '
-                '(not applicable with Backtesting and Hyperopt)'
-            )
-
-        if self.args.db_url and self.args.db_url != constants.DEFAULT_DB_PROD_URL:
-            config.update({'db_url': self.args.db_url})
-            logger.info('Parameter --db-url detected ...')
-        else:
-            # Set default here
-            config.update({'db_url': constants.DEFAULT_DB_PROD_URL})
-
-        if config.get('dry_run', False):
-            logger.info('Dry run is enabled')
-            if config.get('db_url') in [None, constants.DEFAULT_DB_PROD_URL]:
-                # Default to in-memory db for dry_run if not specified
-                config['db_url'] = constants.DEFAULT_DB_DRYRUN_URL
-        else:
-            if not config.get('db_url', None):
-                config['db_url'] = constants.DEFAULT_DB_PROD_URL
-            logger.info('Dry run is disabled')
-
-        if config.get('forcebuy_enable', False):
-            logger.warning('`forcebuy` RPC message enabled.')
-
-        # Setting max_open_trades to infinite if -1
-        if config.get('max_open_trades') == -1:
-            config['max_open_trades'] = float('inf')
-
-        logger.info(f'Using DB: "{config["db_url"]}"')
-
-        # Check if the exchange set by the user is supported
-        self.check_exchange(config)
-
-        return config
-
-    def _create_default_datadir(self, config: Dict[str, Any]) -> str:
-        exchange_name = config.get('exchange', {}).get('name').lower()
-        default_path = os.path.join('user_data', 'data', exchange_name)
-        if not os.path.isdir(default_path):
-            os.makedirs(default_path)
-            logger.info(f'Created data directory: {default_path}')
-        return default_path
-
-    def _load_backtesting_config(self, config: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Extract information for sys.argv and load Backtesting configuration
-        :return: configuration as dictionary
-        """
-
-        # If -i/--ticker-interval is used we override the configuration parameter
-        # (that will override the strategy configuration)
-        if 'ticker_interval' in self.args and self.args.ticker_interval:
-            config.update({'ticker_interval': self.args.ticker_interval})
-            logger.info('Parameter -i/--ticker-interval detected ...')
-            logger.info('Using ticker_interval: %s ...', config.get('ticker_interval'))
-
-        # If -l/--live is used we add it to the configuration
-        if 'live' in self.args and self.args.live:
-            config.update({'live': True})
-            logger.info('Parameter -l/--live detected ...')
-
-        # If --enable-position-stacking is used we add it to the configuration
-        if 'position_stacking' in self.args and self.args.position_stacking:
-            config.update({'position_stacking': True})
-            logger.info('Parameter --enable-position-stacking detected ...')
-
-        # If --disable-max-market-positions is used we add it to the configuration
-        if 'use_max_market_positions' in self.args and not self.args.use_max_market_positions:
-            config.update({'use_max_market_positions': False})
-            logger.info('Parameter --disable-max-market-positions detected ...')
-            logger.info('max_open_trades set to unlimited ...')
-        else:
-            logger.info('Using max_open_trades: %s ...', config.get('max_open_trades'))
-
-        # If --timerange is used we add it to the configuration
-        if 'timerange' in self.args and self.args.timerange:
-            config.update({'timerange': self.args.timerange})
-            logger.info('Parameter --timerange detected: %s ...', self.args.timerange)
-
-        # If --datadir is used we add it to the configuration
-        if 'datadir' in self.args and self.args.datadir:
-            config.update({'datadir': self.args.datadir})
-        else:
-            config.update({'datadir': self._create_default_datadir(config)})
-        logger.info('Using data folder: %s ...', config.get('datadir'))
-
-        # If -r/--refresh-pairs-cached is used we add it to the configuration
-        if 'refresh_pairs' in self.args and self.args.refresh_pairs:
-            config.update({'refresh_pairs': True})
-            logger.info('Parameter -r/--refresh-pairs-cached detected ...')
-
-        if 'strategy_list' in self.args and self.args.strategy_list:
-            config.update({'strategy_list': self.args.strategy_list})
-            logger.info('Using strategy list of %s Strategies', len(self.args.strategy_list))
-
-        if 'ticker_interval' in self.args and self.args.ticker_interval:
-            config.update({'ticker_interval': self.args.ticker_interval})
-            logger.info('Overriding ticker interval with Command line argument')
-
-        # If --export is used we add it to the configuration
-        if 'export' in self.args and self.args.export:
-            config.update({'export': self.args.export})
-            logger.info('Parameter --export detected: %s ...', self.args.export)
-
-        # If --export-filename is used we add it to the configuration
-        if 'export' in config and 'exportfilename' in self.args and self.args.exportfilename:
-            config.update({'exportfilename': self.args.exportfilename})
-            logger.info('Storing backtest results to %s ...', self.args.exportfilename)
-
-        return config
-
-    def _load_edge_config(self, config: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Extract information for sys.argv and load Edge configuration
-        :return: configuration as dictionary
-        """
-
-        # If --timerange is used we add it to the configuration
-        if 'timerange' in self.args and self.args.timerange:
-            config.update({'timerange': self.args.timerange})
-            logger.info('Parameter --timerange detected: %s ...', self.args.timerange)
-
-        # If --timerange is used we add it to the configuration
-        if 'stoploss_range' in self.args and self.args.stoploss_range:
-            txt_range = eval(self.args.stoploss_range)
-            config['edge'].update({'stoploss_range_min': txt_range[0]})
-            config['edge'].update({'stoploss_range_max': txt_range[1]})
-            config['edge'].update({'stoploss_range_step': txt_range[2]})
-            logger.info('Parameter --stoplosses detected: %s ...', self.args.stoploss_range)
-
-        # If -r/--refresh-pairs-cached is used we add it to the configuration
-        if 'refresh_pairs' in self.args and self.args.refresh_pairs:
-            config.update({'refresh_pairs': True})
-            logger.info('Parameter -r/--refresh-pairs-cached detected ...')
-
-        return config
-
-    def _load_hyperopt_config(self, config: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Extract information for sys.argv and load Hyperopt configuration
-        :return: configuration as dictionary
-        """
-        # If --epochs is used we add it to the configuration
-        if 'epochs' in self.args and self.args.epochs:
-            config.update({'epochs': self.args.epochs})
-            logger.info('Parameter --epochs detected ...')
-            logger.info('Will run Hyperopt with for %s epochs ...', config.get('epochs'))
-
-        # If --spaces is used we add it to the configuration
-        if 'spaces' in self.args and self.args.spaces:
-            config.update({'spaces': self.args.spaces})
-            logger.info('Parameter -s/--spaces detected: %s', config.get('spaces'))
-
-        return config
-
-    def _validate_config(self, conf: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Validate the configuration follow the Config Schema
-        :param conf: Config in JSON format
-        :return: Returns the config if valid, otherwise throw an exception
-        """
-        try:
-            validate(conf, constants.CONF_SCHEMA, Draft4Validator)
-            return conf
-        except ValidationError as exception:
-            logger.critical(
-                'Invalid configuration. See config.json.example. Reason: %s',
-                exception
-            )
-            raise ValidationError(
-                best_match(Draft4Validator(constants.CONF_SCHEMA).iter_errors(conf)).message
-            )
-
-    def get_config(self) -> Dict[str, Any]:
-        """
-        Return the config. Use this method to get the bot config
-        :return: Dict: Bot config
-        """
-        if self.config is None:
-            self.config = self.load_config()
-
-        return self.config
-
-    def check_exchange(self, config: Dict[str, Any]) -> bool:
-        """
-        Check if the exchange name in the config file is supported by Freqtrade
-        :return: True or raised an exception if the exchange if not supported
-        """
-        exchange = config.get('exchange', {}).get('name').lower()
-        if exchange not in ccxt.exchanges:
-
-            exception_msg = f'Exchange "{exchange}" not supported.\n' \
-                            f'The following exchanges are supported: {", ".join(ccxt.exchanges)}'
-
-            logger.critical(exception_msg)
-            raise OperationalException(
-                exception_msg
-            )
-        # Depreciation warning
-        if 'ccxt_rate_limit' in config.get('exchange', {}):
-            logger.warning("`ccxt_rate_limit` has been deprecated in favor of "
-                           "`ccxt_config` and `ccxt_async_config` and will be removed "
-                           "in a future version.")
-
-        logger.debug('Exchange "%s" supported', exchange)
-        return True

freqtrade/configuration/__init__.py

@@ -0,0 +1,4 @@
+from freqtrade.configuration.arguments import Arguments  # noqa: F401
+from freqtrade.configuration.timerange import TimeRange  # noqa: F401
+from freqtrade.configuration.configuration import Configuration  # noqa: F401
+from freqtrade.configuration.config_validation import validate_config_consistency  # noqa: F401

freqtrade/configuration/arguments.py

@@ -0,0 +1,141 @@
+"""
+This module contains the argument manager class
+"""
+import argparse
+from typing import List, Optional
+
+from freqtrade.configuration.cli_options import AVAILABLE_CLI_OPTIONS
+from freqtrade import constants
+
+ARGS_COMMON = ["verbosity", "logfile", "version", "config", "datadir", "user_data_dir"]
+
+ARGS_STRATEGY = ["strategy", "strategy_path"]
+
+ARGS_MAIN = ARGS_COMMON + ARGS_STRATEGY + ["db_url", "sd_notify"]
+
+ARGS_COMMON_OPTIMIZE = ["ticker_interval", "timerange",
+                        "max_open_trades", "stake_amount", "refresh_pairs"]
+
+ARGS_BACKTEST = ARGS_COMMON_OPTIMIZE + ["position_stacking", "use_max_market_positions",
+                                        "strategy_list", "export", "exportfilename"]
+
+ARGS_HYPEROPT = ARGS_COMMON_OPTIMIZE + ["hyperopt", "hyperopt_path",
+                                        "position_stacking", "epochs", "spaces",
+                                        "use_max_market_positions", "print_all",
+                                        "print_colorized", "print_json", "hyperopt_jobs",
+                                        "hyperopt_random_state", "hyperopt_min_trades",
+                                        "hyperopt_continue", "hyperopt_loss"]
+
+ARGS_EDGE = ARGS_COMMON_OPTIMIZE + ["stoploss_range"]
+
+ARGS_LIST_EXCHANGES = ["print_one_column"]
+
+ARGS_CREATE_USERDIR = ["user_data_dir"]
+
+ARGS_DOWNLOAD_DATA = ["pairs", "pairs_file", "days", "exchange", "timeframes", "erase"]
+
+ARGS_PLOT_DATAFRAME = (ARGS_COMMON + ARGS_STRATEGY +
+                       ["pairs", "indicators1", "indicators2", "plot_limit", "db_url",
+                        "trade_source", "export", "exportfilename", "timerange",
+                        "refresh_pairs"])
+
+ARGS_PLOT_PROFIT = (ARGS_COMMON + ARGS_STRATEGY +
+                    ["pairs", "timerange", "export", "exportfilename", "db_url", "trade_source"])
+
+NO_CONF_REQURIED = ["start_download_data"]
+
+
+class Arguments(object):
+    """
+    Arguments Class. Manage the arguments received by the cli
+    """
+    def __init__(self, args: Optional[List[str]], description: str,
+                 no_default_config: bool = False) -> None:
+        self.args = args
+        self._parsed_arg: Optional[argparse.Namespace] = None
+        self.parser = argparse.ArgumentParser(description=description)
+        self._no_default_config = no_default_config
+
+    def _load_args(self) -> None:
+        self._build_args(optionlist=ARGS_MAIN)
+        self._build_subcommands()
+
+    def get_parsed_arg(self) -> argparse.Namespace:
+        """
+        Return the list of arguments
+        :return: List[str] List of arguments
+        """
+        if self._parsed_arg is None:
+            self._load_args()
+            self._parsed_arg = self._parse_args()
+
+        return self._parsed_arg
+
+    def _parse_args(self) -> argparse.Namespace:
+        """
+        Parses given arguments and returns an argparse Namespace instance.
+        """
+        parsed_arg = self.parser.parse_args(self.args)
+
+        # Workaround issue in argparse with action='append' and default value
+        # (see https://bugs.python.org/issue16399)
+        # Allow no-config for certain commands (like downloading / plotting)
+        if (not self._no_default_config and parsed_arg.config is None
+                and not (hasattr(parsed_arg, 'func')
+                         and parsed_arg.func.__name__ in NO_CONF_REQURIED)):
+            parsed_arg.config = [constants.DEFAULT_CONFIG]
+
+        return parsed_arg
+
+    def _build_args(self, optionlist, parser=None):
+        parser = parser or self.parser
+
+        for val in optionlist:
+            opt = AVAILABLE_CLI_OPTIONS[val]
+            parser.add_argument(*opt.cli, dest=val, **opt.kwargs)
+
+    def _build_subcommands(self) -> None:
+        """
+        Builds and attaches all subcommands.
+        :return: None
+        """
+        from freqtrade.optimize import start_backtesting, start_hyperopt, start_edge
+        from freqtrade.utils import start_create_userdir, start_download_data, start_list_exchanges
+
+        subparsers = self.parser.add_subparsers(dest='subparser')
+
+        # Add backtesting subcommand
+        backtesting_cmd = subparsers.add_parser('backtesting', help='Backtesting module.')
+        backtesting_cmd.set_defaults(func=start_backtesting)
+        self._build_args(optionlist=ARGS_BACKTEST, parser=backtesting_cmd)
+
+        # Add edge subcommand
+        edge_cmd = subparsers.add_parser('edge', help='Edge module.')
+        edge_cmd.set_defaults(func=start_edge)
+        self._build_args(optionlist=ARGS_EDGE, parser=edge_cmd)
+
+        # Add hyperopt subcommand
+        hyperopt_cmd = subparsers.add_parser('hyperopt', help='Hyperopt module.')
+        hyperopt_cmd.set_defaults(func=start_hyperopt)
+        self._build_args(optionlist=ARGS_HYPEROPT, parser=hyperopt_cmd)
+
+        create_userdir_cmd = subparsers.add_parser('create-userdir',
+                                                   help="Create user-data directory.")
+        create_userdir_cmd.set_defaults(func=start_create_userdir)
+        self._build_args(optionlist=ARGS_CREATE_USERDIR, parser=create_userdir_cmd)
+
+        # Add list-exchanges subcommand
+        list_exchanges_cmd = subparsers.add_parser(
+            'list-exchanges',
+            help='Print available exchanges.'
+        )
+        list_exchanges_cmd.set_defaults(func=start_list_exchanges)
+        self._build_args(optionlist=ARGS_LIST_EXCHANGES, parser=list_exchanges_cmd)
+
+        # Add download-data subcommand
+        download_data_cmd = subparsers.add_parser(
+            'download-data',
+            help='Download backtesting data.'
+        )
+        download_data_cmd.set_defaults(func=start_download_data)
+        self._build_args(optionlist=ARGS_DOWNLOAD_DATA, parser=download_data_cmd)

freqtrade/configuration/check_exchange.py

@@ -0,0 +1,47 @@
+import logging
+from typing import Any, Dict
+
+from freqtrade import OperationalException
+from freqtrade.exchange import (available_exchanges, get_exchange_bad_reason,
+                                is_exchange_available, is_exchange_bad,
+                                is_exchange_officially_supported)
+
+logger = logging.getLogger(__name__)
+
+
+def check_exchange(config: Dict[str, Any], check_for_bad: bool = True) -> bool:
+    """
+    Check if the exchange name in the config file is supported by Freqtrade
+    :param check_for_bad: if True, check the exchange against the list of known 'bad'
+                          exchanges
+    :return: False if exchange is 'bad', i.e. is known to work with the bot with
+             critical issues or does not work at all, crashes, etc. True otherwise.
+             raises an exception if the exchange if not supported by ccxt
+             and thus is not known for the Freqtrade at all.
+    """
+    logger.info("Checking exchange...")
+
+    exchange = config.get('exchange', {}).get('name').lower()
+    if not is_exchange_available(exchange):
+        raise OperationalException(
+                f'Exchange "{exchange}" is not supported by ccxt '
+                f'and therefore not available for the bot.\n'
+                f'The following exchanges are supported by ccxt: '
+                f'{", ".join(available_exchanges())}'
+        )
+
+    if check_for_bad and is_exchange_bad(exchange):
+        raise OperationalException(f'Exchange "{exchange}" is known to not work with the bot yet. '
+                                   f'Reason: {get_exchange_bad_reason(exchange)}')
+
+    if is_exchange_officially_supported(exchange):
+        logger.info(f'Exchange "{exchange}" is officially supported '
+                    f'by the Freqtrade development team.')
+    else:
+        logger.warning(f'Exchange "{exchange}" is supported by ccxt '
+                       f'and therefore available for the bot but not officially supported '
+                       f'by the Freqtrade development team. '
+                       f'It may work flawlessly (please report back) or have serious issues. '
+                       f'Use it at your own discretion.')
+
+    return True

freqtrade/configuration/cli_options.py

@@ -0,0 +1,319 @@
+"""
+Definition of cli arguments used in arguments.py
+"""
+import argparse
+import os
+
+from freqtrade import __version__, constants
+
+
+def check_int_positive(value: str) -> int:
+    try:
+        uint = int(value)
+        if uint <= 0:
+            raise ValueError
+    except ValueError:
+        raise argparse.ArgumentTypeError(
+            f"{value} is invalid for this parameter, should be a positive integer value"
+        )
+    return uint
+
+
+class Arg:
+    # Optional CLI arguments
+    def __init__(self, *args, **kwargs):
+        self.cli = args
+        self.kwargs = kwargs
+
+
+# List of available command line options
+AVAILABLE_CLI_OPTIONS = {
+    # Common options
+    "verbosity": Arg(
+        '-v', '--verbose',
+        help='Verbose mode (-vv for more, -vvv to get all messages).',
+        action='count',
+        default=0,
+    ),
+    "logfile": Arg(
+        '--logfile',
+        help='Log to the file specified.',
+        metavar='FILE',
+    ),
+    "version": Arg(
+        '-V', '--version',
+        action='version',
+        version=f'%(prog)s {__version__}',
+    ),
+    "config": Arg(
+        '-c', '--config',
+        help=f'Specify configuration file (default: `{constants.DEFAULT_CONFIG}`). '
+        f'Multiple --config options may be used. '
+        f'Can be set to `-` to read config from stdin.',
+        action='append',
+        metavar='PATH',
+    ),
+    "datadir": Arg(
+        '-d', '--datadir',
+        help='Path to directory with historical backtesting data.',
+        metavar='PATH',
+    ),
+    "user_data_dir": Arg(
+        '--userdir', '--user-data-dir',
+        help='Path to userdata directory.',
+        metavar='PATH',
+    ),
+    # Main options
+    "strategy": Arg(
+        '-s', '--strategy',
+        help='Specify strategy class name (default: `%(default)s`).',
+        metavar='NAME',
+        default='DefaultStrategy',
+    ),
+    "strategy_path": Arg(
+        '--strategy-path',
+        help='Specify additional strategy lookup path.',
+        metavar='PATH',
+    ),
+    "db_url": Arg(
+        '--db-url',
+        help=f'Override trades database URL, this is useful in custom deployments '
+        f'(default: `{constants.DEFAULT_DB_PROD_URL}` for Live Run mode, '
+        f'`{constants.DEFAULT_DB_DRYRUN_URL}` for Dry Run).',
+        metavar='PATH',
+    ),
+    "sd_notify": Arg(
+        '--sd-notify',
+        help='Notify systemd service manager.',
+        action='store_true',
+    ),
+    # Optimize common
+    "ticker_interval": Arg(
+        '-i', '--ticker-interval',
+        help='Specify ticker interval (`1m`, `5m`, `30m`, `1h`, `1d`).',
+    ),
+    "timerange": Arg(
+        '--timerange',
+        help='Specify what timerange of data to use.',
+    ),
+    "max_open_trades": Arg(
+        '--max_open_trades',
+        help='Specify max_open_trades to use.',
+        type=int,
+        metavar='INT',
+    ),
+    "stake_amount": Arg(
+        '--stake_amount',
+        help='Specify stake_amount.',
+        type=float,
+    ),
+    "refresh_pairs": Arg(
+        '-r', '--refresh-pairs-cached',
+        help='Refresh the pairs files in tests/testdata with the latest data from the '
+        'exchange. Use it if you want to run your optimization commands with '
+        'up-to-date data.',
+        action='store_true',
+    ),
+    # Backtesting
+    "position_stacking": Arg(
+        '--eps', '--enable-position-stacking',
+        help='Allow buying the same pair multiple times (position stacking).',
+        action='store_true',
+        default=False,
+    ),
+    "use_max_market_positions": Arg(
+        '--dmmp', '--disable-max-market-positions',
+        help='Disable applying `max_open_trades` during backtest '
+        '(same as setting `max_open_trades` to a very high number).',
+        action='store_false',
+        default=True,
+    ),
+    "strategy_list": Arg(
+        '--strategy-list',
+        help='Provide a space-separated list of strategies to backtest. '
+        'Please note that ticker-interval needs to be set either in config '
+        'or via command line. When using this together with `--export trades`, '
+        'the strategy-name is injected into the filename '
+        '(so `backtest-data.json` becomes `backtest-data-DefaultStrategy.json`',
+        nargs='+',
+    ),
+    "export": Arg(
+        '--export',
+        help='Export backtest results, argument are: trades. '
+        'Example: `--export=trades`',
+    ),
+    "exportfilename": Arg(
+        '--export-filename',
+        help='Save backtest results to the file with this filename (default: `%(default)s`). '
+        'Requires `--export` to be set as well. '
+        'Example: `--export-filename=user_data/backtest_results/backtest_today.json`',
+        metavar='PATH',
+        default=os.path.join('user_data', 'backtest_results',
+                             'backtest-result.json'),
+    ),
+    # Edge
+    "stoploss_range": Arg(
+        '--stoplosses',
+        help='Defines a range of stoploss values against which edge will assess the strategy. '
+        'The format is "min,max,step" (without any space). '
+        'Example: `--stoplosses=-0.01,-0.1,-0.001`',
+    ),
+    # Hyperopt
+    "hyperopt": Arg(
+        '--customhyperopt',
+        help='Specify hyperopt class name (default: `%(default)s`).',
+        metavar='NAME',
+        default=constants.DEFAULT_HYPEROPT,
+    ),
+    "hyperopt_path": Arg(
+        '--hyperopt-path',
+        help='Specify additional lookup path for Hyperopts and Hyperopt Loss functions.',
+        metavar='PATH',
+    ),
+    "epochs": Arg(
+        '-e', '--epochs',
+        help='Specify number of epochs (default: %(default)d).',
+        type=check_int_positive,
+        metavar='INT',
+        default=constants.HYPEROPT_EPOCH,
+    ),
+    "spaces": Arg(
+        '-s', '--spaces',
+        help='Specify which parameters to hyperopt. Space-separated list. '
+        'Default: `%(default)s`.',
+        choices=['all', 'buy', 'sell', 'roi', 'stoploss'],
+        nargs='+',
+        default='all',
+    ),
+    "print_all": Arg(
+        '--print-all',
+        help='Print all results, not only the best ones.',
+        action='store_true',
+        default=False,
+    ),
+    "print_colorized": Arg(
+        '--no-color',
+        help='Disable colorization of hyperopt results. May be useful if you are '
+        'redirecting output to a file.',
+        action='store_false',
+        default=True,
+    ),
+    "print_json": Arg(
+        '--print-json',
+        help='Print best result detailization in JSON format.',
+        action='store_true',
+        default=False,
+    ),
+    "hyperopt_jobs": Arg(
+        '-j', '--job-workers',
+        help='The number of concurrently running jobs for hyperoptimization '
+        '(hyperopt worker processes). '
+        'If -1 (default), all CPUs are used, for -2, all CPUs but one are used, etc. '
+        'If 1 is given, no parallel computing code is used at all.',
+        type=int,
+        metavar='JOBS',
+        default=-1,
+    ),
+    "hyperopt_random_state": Arg(
+        '--random-state',
+        help='Set random state to some positive integer for reproducible hyperopt results.',
+        type=check_int_positive,
+        metavar='INT',
+    ),
+    "hyperopt_min_trades": Arg(
+        '--min-trades',
+        help="Set minimal desired number of trades for evaluations in the hyperopt "
+        "optimization path (default: 1).",
+        type=check_int_positive,
+        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.'
+        '(default: `%(default)s`).',
+        metavar='NAME',
+        default=constants.DEFAULT_HYPEROPT_LOSS,
+    ),
+    # List exchanges
+    "print_one_column": Arg(
+        '-1', '--one-column',
+        help='Print exchanges in one column.',
+        action='store_true',
+    ),
+    # Script options
+    "pairs": Arg(
+        '-p', '--pairs',
+        help='Show profits for only these pairs. Pairs are space-separated.',
+        nargs='+',
+    ),
+    # Download data
+    "pairs_file": Arg(
+        '--pairs-file',
+        help='File containing a list of pairs to download.',
+        metavar='FILE',
+    ),
+    "days": Arg(
+        '--days',
+        help='Download data for given number of days.',
+        type=check_int_positive,
+        metavar='INT',
+    ),
+    "exchange": Arg(
+        '--exchange',
+        help=f'Exchange name (default: `{constants.DEFAULT_EXCHANGE}`). '
+        f'Only valid if no config is provided.',
+    ),
+    "timeframes": Arg(
+        '-t', '--timeframes',
+        help=f'Specify which tickers to download. Space-separated list. '
+        f'Default: `1m 5m`.',
+        choices=['1m', '3m', '5m', '15m', '30m', '1h', '2h', '4h',
+                 '6h', '8h', '12h', '1d', '3d', '1w'],
+        default=['1m', '5m'],
+        nargs='+',
+    ),
+    "erase": Arg(
+        '--erase',
+        help='Clean all existing data for the selected exchange/pairs/timeframes.',
+        action='store_true',
+    ),
+    # Plot dataframe
+    "indicators1": Arg(
+        '--indicators1',
+        help='Set indicators from your strategy you want in the first row of the graph. '
+        'Comma-separated list. Example: `ema3,ema5`. Default: `%(default)s`.',
+        default='sma,ema3,ema5',
+    ),
+    "indicators2": Arg(
+        '--indicators2',
+        help='Set indicators from your strategy you want in the third row of the graph. '
+        'Comma-separated list. Example: `fastd,fastk`. Default: `%(default)s`.',
+        default='macd,macdsignal',
+    ),
+    "plot_limit": Arg(
+        '--plot-limit',
+        help='Specify tick limit for plotting. Notice: too high values cause huge files. '
+        'Default: %(default)s.',
+        type=check_int_positive,
+        metavar='INT',
+        default=750,
+    ),
+    "trade_source": Arg(
+        '--trade-source',
+        help='Specify the source for trades (Can be DB or file (backtest file)) '
+        'Default: %(default)s',
+        choices=["DB", "file"],
+        default="file",
+    ),
+}

freqtrade/configuration/config_validation.py

@@ -0,0 +1,113 @@
+import logging
+from typing import Any, Dict
+
+from jsonschema import Draft4Validator, validators
+from jsonschema.exceptions import ValidationError, best_match
+
+from freqtrade import constants, OperationalException
+
+
+logger = logging.getLogger(__name__)
+
+
+def _extend_validator(validator_class):
+    """
+    Extended validator for the Freqtrade configuration JSON Schema.
+    Currently it only handles defaults for subschemas.
+    """
+    validate_properties = validator_class.VALIDATORS['properties']
+
+    def set_defaults(validator, properties, instance, schema):
+        for prop, subschema in properties.items():
+            if 'default' in subschema:
+                instance.setdefault(prop, subschema['default'])
+
+        for error in validate_properties(
+            validator, properties, instance, schema,
+        ):
+            yield error
+
+    return validators.extend(
+        validator_class, {'properties': set_defaults}
+    )
+
+
+FreqtradeValidator = _extend_validator(Draft4Validator)
+
+
+def validate_config_schema(conf: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Validate the configuration follow the Config Schema
+    :param conf: Config in JSON format
+    :return: Returns the config if valid, otherwise throw an exception
+    """
+    try:
+        FreqtradeValidator(constants.CONF_SCHEMA).validate(conf)
+        return conf
+    except ValidationError as e:
+        logger.critical(
+            f"Invalid configuration. See config.json.example. Reason: {e}"
+        )
+        raise ValidationError(
+            best_match(Draft4Validator(constants.CONF_SCHEMA).iter_errors(conf)).message
+        )
+
+
+def validate_config_consistency(conf: Dict[str, Any]) -> None:
+    """
+    Validate the configuration consistency.
+    Should be ran after loading both configuration and strategy,
+    since strategies can set certain configuration settings too.
+    :param conf: Config in JSON format
+    :return: Returns None if everything is ok, otherwise throw an OperationalException
+    """
+    # validating trailing stoploss
+    _validate_trailing_stoploss(conf)
+    _validate_edge(conf)
+
+
+def _validate_trailing_stoploss(conf: Dict[str, Any]) -> None:
+
+    if conf.get('stoploss') == 0.0:
+        raise OperationalException(
+            'The config stoploss needs to be different from 0 to avoid problems with sell orders.'
+            )
+    # Skip if trailing stoploss is not activated
+    if not conf.get('trailing_stop', False):
+        return
+
+    tsl_positive = float(conf.get('trailing_stop_positive', 0))
+    tsl_offset = float(conf.get('trailing_stop_positive_offset', 0))
+    tsl_only_offset = conf.get('trailing_only_offset_is_reached', False)
+
+    if tsl_only_offset:
+        if tsl_positive == 0.0:
+            raise OperationalException(
+                'The config trailing_only_offset_is_reached needs '
+                'trailing_stop_positive_offset to be more than 0 in your config.')
+    if tsl_positive > 0 and 0 < tsl_offset <= tsl_positive:
+        raise OperationalException(
+            'The config trailing_stop_positive_offset needs '
+            'to be greater than trailing_stop_positive in your config.')
+
+    # Fetch again without default
+    if 'trailing_stop_positive' in conf and float(conf['trailing_stop_positive']) == 0.0:
+        raise OperationalException(
+            'The config trailing_stop_positive needs to be different from 0 '
+            'to avoid problems with sell orders.'
+        )
+
+
+def _validate_edge(conf: Dict[str, Any]) -> None:
+    """
+    Edge and Dynamic whitelist should not both be enabled, since edge overrides dynamic whitelists.
+    """
+
+    if not conf.get('edge', {}).get('enabled'):
+        return
+
+    if conf.get('pairlist', {}).get('method') == 'VolumePairList':
+        raise OperationalException(
+            "Edge and VolumePairList are incompatible, "
+            "Edge will override whatever pairs VolumePairlist selects."
+        )

freqtrade/configuration/configuration.py

@@ -0,0 +1,371 @@
+"""
+This module contains the configuration class
+"""
+import logging
+import warnings
+from argparse import Namespace
+from copy import deepcopy
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional
+
+from freqtrade import OperationalException, constants
+from freqtrade.configuration.check_exchange import check_exchange
+from freqtrade.configuration.config_validation import (
+    validate_config_consistency, validate_config_schema)
+from freqtrade.configuration.directory_operations import (create_datadir,
+                                                          create_userdata_dir)
+from freqtrade.configuration.load_config import load_config_file
+from freqtrade.loggers import setup_logging
+from freqtrade.misc import deep_merge_dicts, json_load
+from freqtrade.state import RunMode
+
+logger = logging.getLogger(__name__)
+
+
+class Configuration(object):
+    """
+    Class to read and init the bot configuration
+    Reuse this class for the bot, backtesting, hyperopt and every script that required configuration
+    """
+
+    def __init__(self, args: Namespace, runmode: RunMode = None) -> None:
+        self.args = args
+        self.config: Optional[Dict[str, Any]] = None
+        self.runmode = runmode
+
+    def get_config(self) -> Dict[str, Any]:
+        """
+        Return the config. Use this method to get the bot config
+        :return: Dict: Bot config
+        """
+        if self.config is None:
+            self.config = self.load_config()
+
+        return self.config
+
+    @staticmethod
+    def from_files(files: List[str]) -> Dict[str, Any]:
+        """
+        Iterate through the config files passed in, loading all of them
+        and merging their contents.
+        Files are loaded in sequence, parameters in later configuration files
+        override the same parameter from an earlier file (last definition wins).
+        :param files: List of file paths
+        :return: configuration dictionary
+        """
+        # Keep this method as staticmethod, so it can be used from interactive environments
+        config: Dict[str, Any] = {}
+
+        if not files:
+            return deepcopy(constants.MINIMAL_CONFIG)
+
+        # We expect here a list of config filenames
+        for path in files:
+            logger.info(f'Using config: {path} ...')
+
+            # Merge config options, overwriting old values
+            config = deep_merge_dicts(load_config_file(path), config)
+
+        # Normalize config
+        if 'internals' not in config:
+            config['internals'] = {}
+
+        # validate configuration before returning
+        logger.info('Validating configuration ...')
+        validate_config_schema(config)
+
+        return config
+
+    def load_config(self) -> Dict[str, Any]:
+        """
+        Extract information for sys.argv and load the bot configuration
+        :return: Configuration dictionary
+        """
+        # Load all configs
+        config: Dict[str, Any] = Configuration.from_files(self.args.config)
+
+        self._process_common_options(config)
+
+        self._process_optimize_options(config)
+
+        self._process_plot_options(config)
+
+        self._process_runmode(config)
+
+        # Check if the exchange set by the user is supported
+        check_exchange(config, config.get('experimental', {}).get('block_bad_exchanges', True))
+
+        self._resolve_pairs_list(config)
+
+        validate_config_consistency(config)
+
+        return config
+
+    def _process_logging_options(self, config: Dict[str, Any]) -> None:
+        """
+        Extract information for sys.argv and load logging configuration:
+        the -v/--verbose, --logfile options
+        """
+        # Log level
+        if 'verbosity' in self.args and self.args.verbosity:
+            config.update({'verbosity': self.args.verbosity})
+        else:
+            config.update({'verbosity': 0})
+
+        if 'logfile' in self.args and self.args.logfile:
+            config.update({'logfile': self.args.logfile})
+
+        setup_logging(config)
+
+    def _process_common_options(self, config: Dict[str, Any]) -> None:
+
+        self._process_logging_options(config)
+
+        # Set strategy if not specified in config and or if it's non default
+        if self.args.strategy != constants.DEFAULT_STRATEGY or not config.get('strategy'):
+            config.update({'strategy': self.args.strategy})
+
+        self._args_to_config(config, argname='strategy_path',
+                             logstring='Using additional Strategy lookup path: {}')
+
+        if ('db_url' in self.args and self.args.db_url and
+                self.args.db_url != constants.DEFAULT_DB_PROD_URL):
+            config.update({'db_url': self.args.db_url})
+            logger.info('Parameter --db-url detected ...')
+
+        if config.get('dry_run', False):
+            logger.info('Dry run is enabled')
+            if config.get('db_url') in [None, constants.DEFAULT_DB_PROD_URL]:
+                # Default to in-memory db for dry_run if not specified
+                config['db_url'] = constants.DEFAULT_DB_DRYRUN_URL
+        else:
+            if not config.get('db_url', None):
+                config['db_url'] = constants.DEFAULT_DB_PROD_URL
+            logger.info('Dry run is disabled')
+
+        logger.info(f'Using DB: "{config["db_url"]}"')
+
+        if config.get('forcebuy_enable', False):
+            logger.warning('`forcebuy` RPC message enabled.')
+
+        # Setting max_open_trades to infinite if -1
+        if config.get('max_open_trades') == -1:
+            config['max_open_trades'] = float('inf')
+
+        # Support for sd_notify
+        if 'sd_notify' in self.args and self.args.sd_notify:
+            config['internals'].update({'sd_notify': True})
+
+    def _process_datadir_options(self, config: Dict[str, Any]) -> None:
+        """
+        Extract information for sys.argv and load directory configurations
+        --user-data, --datadir
+        """
+        # Check exchange parameter here - otherwise `datadir` might be wrong.
+        if "exchange" in self.args and self.args.exchange:
+            config['exchange']['name'] = self.args.exchange
+            logger.info(f"Using exchange {config['exchange']['name']}")
+
+        if 'user_data_dir' in self.args and self.args.user_data_dir:
+            config.update({'user_data_dir': self.args.user_data_dir})
+        elif 'user_data_dir' not in config:
+            # Default to cwd/user_data (legacy option ...)
+            config.update({'user_data_dir': str(Path.cwd() / "user_data")})
+
+        # reset to user_data_dir so this contains the absolute path.
+        config['user_data_dir'] = create_userdata_dir(config['user_data_dir'], create_dir=False)
+        logger.info('Using user-data directory: %s ...', config['user_data_dir'])
+
+        if 'datadir' in self.args and self.args.datadir:
+            config.update({'datadir': create_datadir(config, self.args.datadir)})
+        else:
+            config.update({'datadir': create_datadir(config, None)})
+        logger.info('Using data directory: %s ...', config.get('datadir'))
+
+    def _process_optimize_options(self, config: Dict[str, Any]) -> None:
+
+        # This will override the strategy configuration
+        self._args_to_config(config, argname='ticker_interval',
+                             logstring='Parameter -i/--ticker-interval detected ... '
+                             'Using ticker_interval: {} ...')
+
+        self._args_to_config(config, argname='position_stacking',
+                             logstring='Parameter --enable-position-stacking detected ...')
+
+        if 'use_max_market_positions' in self.args and not self.args.use_max_market_positions:
+            config.update({'use_max_market_positions': False})
+            logger.info('Parameter --disable-max-market-positions detected ...')
+            logger.info('max_open_trades set to unlimited ...')
+        elif 'max_open_trades' in self.args and self.args.max_open_trades:
+            config.update({'max_open_trades': self.args.max_open_trades})
+            logger.info('Parameter --max_open_trades detected, '
+                        'overriding max_open_trades to: %s ...', config.get('max_open_trades'))
+        else:
+            logger.info('Using max_open_trades: %s ...', config.get('max_open_trades'))
+
+        self._args_to_config(config, argname='stake_amount',
+                             logstring='Parameter --stake_amount detected, '
+                             'overriding stake_amount to: {} ...')
+
+        self._args_to_config(config, argname='timerange',
+                             logstring='Parameter --timerange detected: {} ...')
+
+        self._process_datadir_options(config)
+
+        self._args_to_config(config, argname='refresh_pairs',
+                             logstring='Parameter -r/--refresh-pairs-cached detected ...',
+                             deprecated_msg='-r/--refresh-pairs-cached will be removed soon.')
+
+        self._args_to_config(config, argname='strategy_list',
+                             logstring='Using strategy list of {} Strategies', logfun=len)
+
+        self._args_to_config(config, argname='ticker_interval',
+                             logstring='Overriding ticker interval with Command line argument')
+
+        self._args_to_config(config, argname='export',
+                             logstring='Parameter --export detected: {} ...')
+
+        self._args_to_config(config, argname='exportfilename',
+                             logstring='Storing backtest results to {} ...')
+
+        # Edge section:
+        if 'stoploss_range' in self.args and self.args.stoploss_range:
+            txt_range = eval(self.args.stoploss_range)
+            config['edge'].update({'stoploss_range_min': txt_range[0]})
+            config['edge'].update({'stoploss_range_max': txt_range[1]})
+            config['edge'].update({'stoploss_range_step': txt_range[2]})
+            logger.info('Parameter --stoplosses detected: %s ...', self.args.stoploss_range)
+
+        # Hyperopt section
+        self._args_to_config(config, argname='hyperopt',
+                             logstring='Using Hyperopt file {}')
+
+        self._args_to_config(config, argname='hyperopt_path',
+                             logstring='Using additional Hyperopt lookup path: {}')
+
+        self._args_to_config(config, argname='epochs',
+                             logstring='Parameter --epochs detected ... '
+                             'Will run Hyperopt with for {} epochs ...'
+                             )
+
+        self._args_to_config(config, argname='spaces',
+                             logstring='Parameter -s/--spaces detected: {}')
+
+        self._args_to_config(config, argname='print_all',
+                             logstring='Parameter --print-all detected ...')
+
+        if 'print_colorized' in self.args and not self.args.print_colorized:
+            logger.info('Parameter --no-color detected ...')
+            config.update({'print_colorized': False})
+        else:
+            config.update({'print_colorized': True})
+
+        self._args_to_config(config, argname='print_json',
+                             logstring='Parameter --print-json detected ...')
+
+        self._args_to_config(config, argname='hyperopt_jobs',
+                             logstring='Parameter -j/--job-workers detected: {}')
+
+        self._args_to_config(config, argname='hyperopt_random_state',
+                             logstring='Parameter --random-state detected: {}')
+
+        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 loss function: {}')
+
+    def _process_plot_options(self, config: Dict[str, Any]) -> None:
+
+        self._args_to_config(config, argname='pairs',
+                             logstring='Using pairs {}')
+
+        self._args_to_config(config, argname='indicators1',
+                             logstring='Using indicators1: {}')
+
+        self._args_to_config(config, argname='indicators2',
+                             logstring='Using indicators2: {}')
+
+        self._args_to_config(config, argname='plot_limit',
+                             logstring='Limiting plot to: {}')
+        self._args_to_config(config, argname='trade_source',
+                             logstring='Using trades from: {}')
+
+        self._args_to_config(config, argname='erase',
+                             logstring='Erase detected. Deleting existing data.')
+
+        self._args_to_config(config, argname='timeframes',
+                             logstring='timeframes --timeframes: {}')
+
+        self._args_to_config(config, argname='days',
+                             logstring='Detected --days: {}')
+
+    def _process_runmode(self, config: Dict[str, Any]) -> None:
+
+        if not self.runmode:
+            # Handle real mode, infer dry/live from config
+            self.runmode = RunMode.DRY_RUN if config.get('dry_run', True) else RunMode.LIVE
+            logger.info(f"Runmode set to {self.runmode}.")
+
+        config.update({'runmode': self.runmode})
+
+    def _args_to_config(self, config: Dict[str, Any], argname: str,
+                        logstring: str, logfun: Optional[Callable] = None,
+                        deprecated_msg: Optional[str] = None) -> None:
+        """
+        :param config: Configuration dictionary
+        :param argname: Argumentname in self.args - will be copied to config dict.
+        :param logstring: Logging String
+        :param logfun: logfun is applied to the configuration entry before passing
+                        that entry to the log string using .format().
+                        sample: logfun=len (prints the length of the found
+                        configuration instead of the content)
+        """
+        if argname in self.args and getattr(self.args, argname):
+
+            config.update({argname: getattr(self.args, argname)})
+            if logfun:
+                logger.info(logstring.format(logfun(config[argname])))
+            else:
+                logger.info(logstring.format(config[argname]))
+            if deprecated_msg:
+                warnings.warn(f"DEPRECATED: {deprecated_msg}", DeprecationWarning)
+
+    def _resolve_pairs_list(self, config: Dict[str, Any]) -> None:
+        """
+        Helper for download script.
+        Takes first found:
+        * -p (pairs argument)
+        * --pairs-file
+        * whitelist from config
+        """
+
+        if "pairs" in config:
+            return
+
+        if "pairs_file" in self.args and self.args.pairs_file:
+            pairs_file = Path(self.args.pairs_file)
+            logger.info(f'Reading pairs file "{pairs_file}".')
+            # Download pairs from the pairs file if no config is specified
+            # or if pairs file is specified explicitely
+            if not pairs_file.exists():
+                raise OperationalException(f'No pairs file found with path "{pairs_file}".')
+            with pairs_file.open('r') as f:
+                config['pairs'] = json_load(f)
+                config['pairs'].sort()
+            return
+
+        if "config" in self.args and self.args.config:
+            logger.info("Using pairlist from configuration.")
+            config['pairs'] = config.get('exchange', {}).get('pair_whitelist')
+        else:
+            # Fall back to /dl_path/pairs.json
+            pairs_file = Path(config['datadir']) / "pairs.json"
+            if pairs_file.exists():
+                with pairs_file.open('r') as f:
+                    config['pairs'] = json_load(f)
+                if 'pairs' in config:
+                    config['pairs'].sort()

freqtrade/configuration/directory_operations.py

@@ -0,0 +1,50 @@
+import logging
+from typing import Any, Dict, Optional
+from pathlib import Path
+
+from freqtrade import OperationalException
+
+logger = logging.getLogger(__name__)
+
+
+def create_datadir(config: Dict[str, Any], datadir: Optional[str] = None) -> str:
+
+    folder = Path(datadir) if datadir else Path(f"{config['user_data_dir']}/data")
+    if not datadir:
+        # set datadir
+        exchange_name = config.get('exchange', {}).get('name').lower()
+        folder = folder.joinpath(exchange_name)
+
+    if not folder.is_dir():
+        folder.mkdir(parents=True)
+        logger.info(f'Created data directory: {datadir}')
+    return str(folder)
+
+
+def create_userdata_dir(directory: str, create_dir=False) -> Path:
+    """
+    Create userdata directory structure.
+    if create_dir is True, then the parent-directory will be created if it does not exist.
+    Sub-directories will always be created if the parent directory exists.
+    Raises OperationalException if given a non-existing directory.
+    :param directory: Directory to check
+    :param create_dir: Create directory if it does not exist.
+    :return: Path object containing the directory
+    """
+    sub_dirs = ["backtest_results", "data", "hyperopts", "hyperopt_results", "plot", "strategies", ]
+    folder = Path(directory)
+    if not folder.is_dir():
+        if create_dir:
+            folder.mkdir(parents=True)
+            logger.info(f'Created user-data directory: {folder}')
+        else:
+            raise OperationalException(
+                f"Directory `{folder}` does not exist. "
+                "Please use `freqtrade create-userdir` to create a user directory")
+
+    # Create required subdirectories
+    for f in sub_dirs:
+        subfolder = folder / f
+        if not subfolder.is_dir():
+            subfolder.mkdir(parents=False)
+    return folder

freqtrade/configuration/load_config.py

@@ -0,0 +1,33 @@
+"""
+This module contain functions to load the configuration file
+"""
+import rapidjson
+import logging
+import sys
+from typing import Any, Dict
+
+from freqtrade import OperationalException
+
+
+logger = logging.getLogger(__name__)
+
+
+CONFIG_PARSE_MODE = rapidjson.PM_COMMENTS | rapidjson.PM_TRAILING_COMMAS
+
+
+def load_config_file(path: str) -> Dict[str, Any]:
+    """
+    Loads a config file from the given path
+    :param path: path as str
+    :return: configuration as dictionary
+    """
+    try:
+        # Read config from stdin if requested in the options
+        with open(path) if path != '-' else sys.stdin as file:
+            config = rapidjson.load(file, parse_mode=CONFIG_PARSE_MODE)
+    except FileNotFoundError:
+        raise OperationalException(
+            f'Config file "{path}" not found!'
+            ' Please create a config file or check whether it exists.')
+
+    return config

freqtrade/configuration/timerange.py

@@ -0,0 +1,70 @@
+"""
+This module contains the argument manager class
+"""
+import re
+from typing import Optional
+
+import arrow
+
+
+class TimeRange():
+    """
+    object defining timerange inputs.
+    [start/stop]type defines if [start/stop]ts shall be used.
+    if *type is None, don't use corresponding startvalue.
+    """
+
+    def __init__(self, starttype: Optional[str] = None, stoptype: Optional[str] = None,
+                 startts: int = 0, stopts: int = 0):
+
+        self.starttype: Optional[str] = starttype
+        self.stoptype: Optional[str] = stoptype
+        self.startts: int = startts
+        self.stopts: int = stopts
+
+    def __eq__(self, other):
+        """Override the default Equals behavior"""
+        return (self.starttype == other.starttype and self.stoptype == other.stoptype
+                and self.startts == other.startts and self.stopts == other.stopts)
+
+    @staticmethod
+    def parse_timerange(text: Optional[str]):
+        """
+        Parse the value of the argument --timerange to determine what is the range desired
+        :param text: value from --timerange
+        :return: Start and End range period
+        """
+        if text is None:
+            return TimeRange(None, None, 0, 0)
+        syntax = [(r'^-(\d{8})$', (None, 'date')),
+                  (r'^(\d{8})-$', ('date', None)),
+                  (r'^(\d{8})-(\d{8})$', ('date', 'date')),
+                  (r'^-(\d{10})$', (None, 'date')),
+                  (r'^(\d{10})-$', ('date', None)),
+                  (r'^(\d{10})-(\d{10})$', ('date', 'date')),
+                  (r'^(-\d+)$', (None, 'line')),
+                  (r'^(\d+)-$', ('line', None)),
+                  (r'^(\d+)-(\d+)$', ('index', 'index'))]
+        for rex, stype in syntax:
+            # Apply the regular expression to text
+            match = re.match(rex, text)
+            if match:  # Regex has matched
+                rvals = match.groups()
+                index = 0
+                start: int = 0
+                stop: int = 0
+                if stype[0]:
+                    starts = rvals[index]
+                    if stype[0] == 'date' and len(starts) == 8:
+                        start = arrow.get(starts, 'YYYYMMDD').timestamp
+                    else:
+                        start = int(starts)
+                    index += 1
+                if stype[1]:
+                    stops = rvals[index]
+                    if stype[1] == 'date' and len(stops) == 8:
+                        stop = arrow.get(stops, 'YYYYMMDD').timestamp
+                    else:
+                        stop = int(stops)
+                return TimeRange(stype[0], stype[1], start, stop)
+        raise Exception('Incorrect syntax for timerange "%s"' % text)

freqtrade/constants.py

@@ -3,38 +3,31 @@
 """
 bot constants
 """
-DYNAMIC_WHITELIST = 20  # pairs
+DEFAULT_CONFIG = 'config.json'
+DEFAULT_EXCHANGE = 'bittrex'
 PROCESS_THROTTLE_SECS = 5  # sec
-TICKER_INTERVAL = 5  # min
+DEFAULT_TICKER_INTERVAL = 5  # min
 HYPEROPT_EPOCH = 100  # epochs
 RETRY_TIMEOUT = 30  # sec
 DEFAULT_STRATEGY = 'DefaultStrategy'
 DEFAULT_HYPEROPT = 'DefaultHyperOpts'
+DEFAULT_HYPEROPT_LOSS = 'DefaultHyperOptLoss'
 DEFAULT_DB_PROD_URL = 'sqlite:///tradesv3.sqlite'
 DEFAULT_DB_DRYRUN_URL = 'sqlite://'
 UNLIMITED_STAKE_AMOUNT = 'unlimited'
+DEFAULT_AMOUNT_RESERVE_PERCENT = 0.05
 REQUIRED_ORDERTIF = ['buy', 'sell']
 REQUIRED_ORDERTYPES = ['buy', 'sell', 'stoploss', 'stoploss_on_exchange']
 ORDERTYPE_POSSIBILITIES = ['limit', 'market']
 ORDERTIF_POSSIBILITIES = ['gtc', 'fok', 'ioc']
 AVAILABLE_PAIRLISTS = ['StaticPairList', 'VolumePairList']
+DRY_RUN_WALLET = 999.9
 
-TICKER_INTERVAL_MINUTES = {
+TICKER_INTERVALS = [
-    '1m': 1,
+    '1m', '3m', '5m', '15m', '30m',
-    '3m': 3,
+    '1h', '2h', '4h', '6h', '8h', '12h',
-    '5m': 5,
+    '1d', '3d', '1w',
-    '15m': 15,
+]
-    '30m': 30,
-    '1h': 60,
-    '2h': 120,
-    '4h': 240,
-    '6h': 360,
-    '8h': 480,
-    '12h': 720,
-    '1d': 1440,
-    '3d': 4320,
-    '1w': 10080,
-}
 
 SUPPORTED_FIAT = [
     "AUD", "BRL", "CAD", "CHF", "CLP", "CNY", "CZK", "DKK",
@@ -44,12 +37,26 @@ SUPPORTED_FIAT = [
     "BTC", "XBT", "ETH", "XRP", "LTC", "BCH", "USDT"
 ]
 
+MINIMAL_CONFIG = {
+    'stake_currency': '',
+    'dry_run': True,
+    'exchange': {
+        'name': '',
+        'key': '',
+        'secret': '',
+        'pair_whitelist': [],
+        'ccxt_async_config': {
+            'enableRateLimit': True,
+        }
+    }
+}
+
 # Required json-schema for user specified config
 CONF_SCHEMA = {
     'type': 'object',
     'properties': {
         'max_open_trades': {'type': 'integer', 'minimum': -1},
-        'ticker_interval': {'type': 'string', 'enum': list(TICKER_INTERVAL_MINUTES.keys())},
+        'ticker_interval': {'type': 'string', 'enum': TICKER_INTERVALS},
         'stake_currency': {'type': 'string', 'enum': ['BTC', 'XBT', 'ETH', 'USDT', 'EUR', 'USD']},
         'stake_amount': {
             "type": ["number", "string"],
@@ -58,6 +65,7 @@ CONF_SCHEMA = {
         },
         'fiat_display_currency': {'type': 'string', 'enum': SUPPORTED_FIAT},
         'dry_run': {'type': 'boolean'},
+        'dry_run_wallet': {'type': 'number'},
         'process_only_new_candles': {'type': 'boolean'},
         'minimal_roi': {
             'type': 'object',
@@ -66,10 +74,12 @@ CONF_SCHEMA = {
             },
             'minProperties': 1
         },
+        'amount_reserve_percent': {'type': 'number', 'minimum': 0.0, 'maximum': 0.5},
         'stoploss': {'type': 'number', 'maximum': 0, 'exclusiveMaximum': True},
         'trailing_stop': {'type': 'boolean'},
         'trailing_stop_positive': {'type': 'number', 'minimum': 0, 'maximum': 1},
         'trailing_stop_positive_offset': {'type': 'number', 'minimum': 0, 'maximum': 1},
+        'trailing_only_offset_is_reached': {'type': 'boolean'},
         'unfilledtimeout': {
             'type': 'object',
             'properties': {
@@ -112,7 +122,8 @@ CONF_SCHEMA = {
                 'buy': {'type': 'string', 'enum': ORDERTYPE_POSSIBILITIES},
                 'sell': {'type': 'string', 'enum': ORDERTYPE_POSSIBILITIES},
                 'stoploss': {'type': 'string', 'enum': ORDERTYPE_POSSIBILITIES},
-                'stoploss_on_exchange': {'type': 'boolean'}
+                'stoploss_on_exchange': {'type': 'boolean'},
+                'stoploss_on_exchange_interval': {'type': 'number'}
             },
             'required': ['buy', 'sell', 'stoploss', 'stoploss_on_exchange']
         },
@@ -137,7 +148,7 @@ CONF_SCHEMA = {
         'pairlist': {
             'type': 'object',
             'properties': {
-                'method': {'type': 'string',  'enum': AVAILABLE_PAIRLISTS},
+                'method': {'type': 'string', 'enum': AVAILABLE_PAIRLISTS},
                 'config': {'type': 'object'}
             },
             'required': ['method']
@@ -160,6 +171,21 @@ CONF_SCHEMA = {
                 'webhookstatus': {'type': 'object'},
             },
         },
+        'api_server': {
+            'type': 'object',
+            'properties': {
+                'enabled': {'type': 'boolean'},
+                'listen_ip_address': {'format': 'ipv4'},
+                'listen_port': {
+                    'type': 'integer',
+                    "minimum": 1024,
+                    "maximum": 65535
+                },
+                'username': {'type': 'string'},
+                'password': {'type': 'string'},
+            },
+            'required': ['enabled', 'listen_ip_address', 'listen_port', 'username', 'password']
+        },
         'db_url': {'type': 'string'},
         'initial_state': {'type': 'string', 'enum': ['running', 'stopped']},
         'forcebuy_enable': {'type': 'boolean'},
@@ -167,7 +193,8 @@ CONF_SCHEMA = {
             'type': 'object',
             'properties': {
                 'process_throttle_secs': {'type': 'number'},
-                'interval': {'type': 'integer'}
+                'interval': {'type': 'integer'},
+                'sd_notify': {'type': 'boolean'},
             }
         }
     },
@@ -176,10 +203,10 @@ CONF_SCHEMA = {
             'type': 'object',
             'properties': {
                 'name': {'type': 'string'},
-                'sandbox': {'type': 'boolean'},
+                'sandbox': {'type': 'boolean', 'default': False},
-                'key': {'type': 'string'},
+                'key': {'type': 'string', 'default': ''},
-                'secret': {'type': 'string'},
+                'secret': {'type': 'string', 'default': ''},
-                'password': {'type': 'string'},
+                'password': {'type': 'string', 'default': ''},
                 'uid': {'type': 'string'},
                 'pair_whitelist': {
                     'type': 'array',
@@ -198,10 +225,11 @@ CONF_SCHEMA = {
                     'uniqueItems': True
                 },
                 'outdated_offset': {'type': 'integer', 'minimum': 1},
+                'markets_refresh_interval': {'type': 'integer'},
                 'ccxt_config': {'type': 'object'},
                 'ccxt_async_config': {'type': 'object'}
             },
-            'required': ['name', 'key', 'secret', 'pair_whitelist']
+            'required': ['name', 'pair_whitelist']
         },
         'edge': {
             'type': 'object',

freqtrade/data/btanalysis.py

@@ -0,0 +1,165 @@
+"""
+Helpers when analyzing backtest data
+"""
+import logging
+from pathlib import Path
+from typing import Dict
+
+import numpy as np
+import pandas as pd
+import pytz
+
+from freqtrade import persistence
+from freqtrade.misc import json_load
+from freqtrade.persistence import Trade
+
+logger = logging.getLogger(__name__)
+
+# must align with columns in backtest.py
+BT_DATA_COLUMNS = ["pair", "profitperc", "open_time", "close_time", "index", "duration",
+                   "open_rate", "close_rate", "open_at_end", "sell_reason"]
+
+
+def load_backtest_data(filename) -> pd.DataFrame:
+    """
+    Load backtest data file.
+    :param filename: pathlib.Path object, or string pointing to the file.
+    :return: a dataframe with the analysis results
+    """
+    if isinstance(filename, str):
+        filename = Path(filename)
+
+    if not filename.is_file():
+        raise ValueError(f"File {filename} does not exist.")
+
+    with filename.open() as file:
+        data = json_load(file)
+
+    df = pd.DataFrame(data, columns=BT_DATA_COLUMNS)
+
+    df['open_time'] = pd.to_datetime(df['open_time'],
+                                     unit='s',
+                                     utc=True,
+                                     infer_datetime_format=True
+                                     )
+    df['close_time'] = pd.to_datetime(df['close_time'],
+                                      unit='s',
+                                      utc=True,
+                                      infer_datetime_format=True
+                                      )
+    df['profitabs'] = df['close_rate'] - df['open_rate']
+    df = df.sort_values("open_time").reset_index(drop=True)
+    return df
+
+
+def evaluate_result_multi(results: pd.DataFrame, freq: str, max_open_trades: int) -> pd.DataFrame:
+    """
+    Find overlapping trades by expanding each trade once per period it was open
+    and then counting overlaps
+    :param results: Results Dataframe - can be loaded
+    :param freq: Frequency used for the backtest
+    :param max_open_trades: parameter max_open_trades used during backtest run
+    :return: dataframe with open-counts per time-period in freq
+    """
+    dates = [pd.Series(pd.date_range(row[1].open_time, row[1].close_time, freq=freq))
+             for row in results[['open_time', 'close_time']].iterrows()]
+    deltas = [len(x) for x in dates]
+    dates = pd.Series(pd.concat(dates).values, name='date')
+    df2 = pd.DataFrame(np.repeat(results.values, deltas, axis=0), columns=results.columns)
+
+    df2 = pd.concat([dates, df2], axis=1)
+    df2 = df2.set_index('date')
+    df_final = df2.resample(freq)[['pair']].count()
+    return df_final[df_final['pair'] > max_open_trades]
+
+
+def load_trades_from_db(db_url: str) -> pd.DataFrame:
+    """
+    Load trades from a DB (using dburl)
+    :param db_url: Sqlite url (default format sqlite:///tradesv3.dry-run.sqlite)
+    :return: Dataframe containing Trades
+    """
+    trades: pd.DataFrame = pd.DataFrame([], columns=BT_DATA_COLUMNS)
+    persistence.init(db_url, clean_open_orders=False)
+
+    columns = ["pair", "open_time", "close_time", "profit", "profitperc",
+               "open_rate", "close_rate", "amount", "duration", "sell_reason",
+               "fee_open", "fee_close", "open_rate_requested", "close_rate_requested",
+               "stake_amount", "max_rate", "min_rate", "id", "exchange",
+               "stop_loss", "initial_stop_loss", "strategy", "ticker_interval"]
+
+    trades = pd.DataFrame([(t.pair,
+                            t.open_date.replace(tzinfo=pytz.UTC),
+                            t.close_date.replace(tzinfo=pytz.UTC) if t.close_date else None,
+                            t.calc_profit(), t.calc_profit_percent(),
+                            t.open_rate, t.close_rate, t.amount,
+                            (t.close_date.timestamp() - t.open_date.timestamp()
+                                if t.close_date else None),
+                            t.sell_reason,
+                            t.fee_open, t.fee_close,
+                            t.open_rate_requested,
+                            t.close_rate_requested,
+                            t.stake_amount,
+                            t.max_rate,
+                            t.min_rate,
+                            t.id, t.exchange,
+                            t.stop_loss, t.initial_stop_loss,
+                            t.strategy, t.ticker_interval
+                            )
+                           for t in Trade.query.all()],
+                          columns=columns)
+
+    return trades
+
+
+def load_trades(config) -> pd.DataFrame:
+    """
+    Based on configuration option "trade_source":
+    * loads data from DB (using `db_url`)
+    * loads data from backtestfile (using `exportfilename`)
+    """
+    if config["trade_source"] == "DB":
+        return load_trades_from_db(config["db_url"])
+    elif config["trade_source"] == "file":
+        return load_backtest_data(Path(config["exportfilename"]))
+
+
+def extract_trades_of_period(dataframe: pd.DataFrame, trades: pd.DataFrame) -> pd.DataFrame:
+    """
+    Compare trades and backtested pair DataFrames to get trades performed on backtested period
+    :return: the DataFrame of a trades of period
+    """
+    trades = trades.loc[(trades['open_time'] >= dataframe.iloc[0]['date']) &
+                        (trades['close_time'] <= dataframe.iloc[-1]['date'])]
+    return trades
+
+
+def combine_tickers_with_mean(tickers: Dict[str, pd.DataFrame], column: str = "close"):
+    """
+    Combine multiple dataframes "column"
+    :param tickers: Dict of Dataframes, dict key should be pair.
+    :param column: Column in the original dataframes to use
+    :return: DataFrame with the column renamed to the dict key, and a column
+        named mean, containing the mean of all pairs.
+    """
+    df_comb = pd.concat([tickers[pair].set_index('date').rename(
+        {column: pair}, axis=1)[pair] for pair in tickers], axis=1)
+
+    df_comb['mean'] = df_comb.mean(axis=1)
+
+    return df_comb
+
+
+def create_cum_profit(df: pd.DataFrame, trades: pd.DataFrame, col_name: str) -> pd.DataFrame:
+    """
+    Adds a column `col_name` with the cumulative profit for the given trades array.
+    :param df: DataFrame with date index
+    :param trades: DataFrame containing trades (requires columns close_time and profitperc)
+    :return: Returns df with one additional column, col_name, containing the cumulative profit.
+    """
+    df[col_name] = trades.set_index('close_time')['profitperc'].cumsum()
+    # Set first value to 0
+    df.loc[df.iloc[0].name, col_name] = 0
+    # FFill to get continuous
+    df[col_name] = df[col_name].ffill()
+    return df

freqtrade/data/converter.py

@@ -2,16 +2,25 @@
 Functions to convert data from one format to another
 """
 import logging
+
 import pandas as pd
 from pandas import DataFrame, to_datetime
 
+
 logger = logging.getLogger(__name__)
 
 
-def parse_ticker_dataframe(ticker: list) -> DataFrame:
+def parse_ticker_dataframe(ticker: list, ticker_interval: str, pair: str, *,
+                           fill_missing: bool = True,
+                           drop_incomplete: bool = True) -> DataFrame:
     """
     Converts a ticker-list (format ccxt.fetch_ohlcv) to a Dataframe
     :param ticker: ticker list, as returned by exchange.async_get_candle_history
+    :param ticker_interval: ticker_interval (e.g. 5m). Used to fill up eventual missing data
+    :param pair: Pair this data is for (used to warn if fillup was necessary)
+    :param fill_missing: fill up missing candles with 0 candles
+                         (see ohlcv_fill_up_missing_data for details)
+    :param drop_incomplete: Drop the last candle of the dataframe, assuming it's incomplete
     :return: DataFrame
     """
     logger.debug("Parsing tickerlist to dataframe")
@@ -23,6 +32,12 @@ def parse_ticker_dataframe(ticker: list) -> DataFrame:
                                 utc=True,
                                 infer_datetime_format=True)
 
+    # Some exchanges return int values for volume and even for ohlc.
+    # Convert them since TA-LIB indicators used in the strategy assume floats
+    # and fail with exception...
+    frame = frame.astype(dtype={'open': 'float', 'high': 'float', 'low': 'float', 'close': 'float',
+                                'volume': 'float'})
+
     # group by index and aggregate results to eliminate duplicate ticks
     frame = frame.groupby(by='date', as_index=False, sort=True).agg({
         'open': 'first',
@@ -31,9 +46,50 @@ def parse_ticker_dataframe(ticker: list) -> DataFrame:
         'close': 'last',
         'volume': 'max',
     })
-    frame.drop(frame.tail(1).index, inplace=True)     # eliminate partial candle
+    # eliminate partial candle
-    logger.debug('Dropping last candle')
+    if drop_incomplete:
-    return frame
+        frame.drop(frame.tail(1).index, inplace=True)
+        logger.debug('Dropping last candle')
+
+    if fill_missing:
+        return ohlcv_fill_up_missing_data(frame, ticker_interval, pair)
+    else:
+        return frame
+
+
+def ohlcv_fill_up_missing_data(dataframe: DataFrame, ticker_interval: str, pair: str) -> DataFrame:
+    """
+    Fills up missing data with 0 volume rows,
+    using the previous close as price for "open", "high" "low" and "close", volume is set to 0
+
+    """
+    from freqtrade.exchange import timeframe_to_minutes
+
+    ohlc_dict = {
+        'open': 'first',
+        'high': 'max',
+        'low': 'min',
+        'close': 'last',
+        'volume': 'sum'
+    }
+    ticker_minutes = timeframe_to_minutes(ticker_interval)
+    # Resample to create "NAN" values
+    df = dataframe.resample(f'{ticker_minutes}min', on='date').agg(ohlc_dict)
+
+    # Forwardfill close for missing columns
+    df['close'] = df['close'].fillna(method='ffill')
+    # Use close for "open, high, low"
+    df.loc[:, ['open', 'high', 'low']] = df[['open', 'high', 'low']].fillna(
+        value={'open': df['close'],
+               'high': df['close'],
+               'low': df['close'],
+               })
+    df.reset_index(inplace=True)
+    len_before = len(dataframe)
+    len_after = len(df)
+    if len_before != len_after:
+        logger.info(f"Missing data fillup for {pair}: before: {len_before} - after: {len_after}")
+    return df
 
 
 def order_book_to_dataframe(bids: list, asks: list) -> DataFrame:

freqtrade/data/dataprovider.py

@@ -0,0 +1,112 @@
+"""
+Dataprovider
+Responsible to provide data to the bot
+including Klines, tickers, historic data
+Common Interface for bot and strategy to access data.
+"""
+import logging
+from pathlib import Path
+from typing import List, Tuple
+
+from pandas import DataFrame
+
+from freqtrade.data.history import load_pair_history
+from freqtrade.exchange import Exchange
+from freqtrade.state import RunMode
+
+logger = logging.getLogger(__name__)
+
+
+class DataProvider():
+
+    def __init__(self, config: dict, exchange: Exchange) -> None:
+        self._config = config
+        self._exchange = exchange
+
+    def refresh(self,
+                pairlist: List[Tuple[str, str]],
+                helping_pairs: List[Tuple[str, str]] = None) -> None:
+        """
+        Refresh data, called with each cycle
+        """
+        if helping_pairs:
+            self._exchange.refresh_latest_ohlcv(pairlist + helping_pairs)
+        else:
+            self._exchange.refresh_latest_ohlcv(pairlist)
+
+    @property
+    def available_pairs(self) -> List[Tuple[str, str]]:
+        """
+        Return a list of tuples containing pair, ticker_interval for which data is currently cached.
+        Should be whitelist + open trades.
+        """
+        return list(self._exchange._klines.keys())
+
+    def ohlcv(self, pair: str, ticker_interval: str = None, copy: bool = True) -> DataFrame:
+        """
+        Get ohlcv data for the given pair as DataFrame
+        Please use the `available_pairs` method to verify which pairs are currently cached.
+        :param pair: pair to get the data for
+        :param ticker_interval: ticker interval to get data for
+        :param copy: copy dataframe before returning if True.
+                     Use False only for read-only operations (where the dataframe is not modified)
+        """
+        if self.runmode in (RunMode.DRY_RUN, RunMode.LIVE):
+            return self._exchange.klines((pair, ticker_interval or self._config['ticker_interval']),
+                                         copy=copy)
+        else:
+            return DataFrame()
+
+    def historic_ohlcv(self, pair: str, ticker_interval: str = None) -> DataFrame:
+        """
+        Get stored historic ohlcv data
+        :param pair: pair to get the data for
+        :param ticker_interval: ticker interval to get data for
+        """
+        return load_pair_history(pair=pair,
+                                 ticker_interval=ticker_interval or self._config['ticker_interval'],
+                                 refresh_pairs=False,
+                                 datadir=Path(self._config['datadir']) if self._config.get(
+                                     'datadir') else None
+                                 )
+
+    def get_pair_dataframe(self, pair: str, ticker_interval: str = None) -> DataFrame:
+        """
+        Return pair ohlcv data, either live or cached historical -- depending
+        on the runmode.
+        :param pair: pair to get the data for
+        :param ticker_interval: ticker interval to get data for
+        """
+        if self.runmode in (RunMode.DRY_RUN, RunMode.LIVE):
+            # Get live ohlcv data.
+            data = self.ohlcv(pair=pair, ticker_interval=ticker_interval)
+        else:
+            # Get historic ohlcv data (cached on disk).
+            data = self.historic_ohlcv(pair=pair, ticker_interval=ticker_interval)
+        if len(data) == 0:
+            logger.warning(f"No data found for ({pair}, {ticker_interval}).")
+        return data
+
+    def ticker(self, pair: str):
+        """
+        Return last ticker data
+        """
+        # TODO: Implement me
+        pass
+
+    def orderbook(self, pair: str, maximum: int):
+        """
+        return latest orderbook data
+        :param pair: pair to get the data for
+        :param maximum: Maximum number of orderbook entries to query
+        :return: dict including bids/asks with a total of `maximum` entries.
+        """
+        return self._exchange.get_order_book(pair, maximum)
+
+    @property
+    def runmode(self) -> RunMode:
+        """
+        Get runmode of the bot
+        can be "live", "dry-run", "backtest", "edgecli", "hyperopt" or "other".
+        """
+        return RunMode(self._config.get('runmode', RunMode.OTHER))

freqtrade/data/history.py

@@ -1,37 +1,28 @@
 """
 Handle historic data (ohlcv).
-includes:
+
+Includes:
 * load data for a pair (or a list of pairs) from disk
 * download data from exchange and store to disk
 """
 
-import gzip
-
 import logging
+import operator
+from datetime import datetime
 from pathlib import Path
-from typing import Optional, List, Dict, Tuple, Any
+from typing import Any, Dict, List, Optional, Tuple
 
 import arrow
 from pandas import DataFrame
-import ujson
 
-from freqtrade import misc, constants, OperationalException
+from freqtrade import OperationalException, misc
+from freqtrade.configuration import TimeRange
 from freqtrade.data.converter import parse_ticker_dataframe
-from freqtrade.exchange import Exchange
+from freqtrade.exchange import Exchange, timeframe_to_minutes
-from freqtrade.arguments import TimeRange
 
 logger = logging.getLogger(__name__)
 
 
-def json_load(data):
-    """
-    load data with ujson
-    Use this to have a consistent experience,
-    otherwise "precise_float" needs to be passed to all load operations
-    """
-    return ujson.load(data, precise_float=True)
-
-
 def trim_tickerlist(tickerlist: List[Dict], timerange: TimeRange) -> List[Dict]:
     """
     Trim tickerlist based on given timerange
@@ -52,7 +43,7 @@ def trim_tickerlist(tickerlist: List[Dict], timerange: TimeRange) -> List[Dict]:
             start_index += 1
 
     if timerange.stoptype == 'line':
-        start_index = len(tickerlist) + timerange.stopts
+        start_index = max(len(tickerlist) + timerange.stopts, 0)
     if timerange.stoptype == 'index':
         stop_index = timerange.stopts
     elif timerange.stoptype == 'date':
@@ -66,62 +57,64 @@ def trim_tickerlist(tickerlist: List[Dict], timerange: TimeRange) -> List[Dict]:
     return tickerlist[start_index:stop_index]
 
 
-def load_tickerdata_file(
+def load_tickerdata_file(datadir: Optional[Path], pair: str, ticker_interval: str,
-        datadir: Optional[Path], pair: str,
+                         timerange: Optional[TimeRange] = None) -> Optional[list]:
-        ticker_interval: str,
-        timerange: Optional[TimeRange] = None) -> Optional[list]:
     """
     Load a pair from file, either .json.gz or .json
-    :return tickerlist or None if unsuccesful
+    :return: tickerlist or None if unsuccesful
     """
-    path = make_testdata_path(datadir)
+    filename = pair_data_filename(datadir, pair, ticker_interval)
-    pair_s = pair.replace('/', '_')
+    pairdata = misc.file_load_json(filename)
-    file = path.joinpath(f'{pair_s}-{ticker_interval}.json')
+    if not pairdata:
-    gzipfile = file.with_suffix(file.suffix + '.gz')
+        return []
-
-    # Try gzip file first, otherwise regular json file.
-    if gzipfile.is_file():
-        logger.debug('Loading ticker data from file %s', gzipfile)
-        with gzip.open(gzipfile) as tickerdata:
-            pairdata = json_load(tickerdata)
-    elif file.is_file():
-        logger.debug('Loading ticker data from file %s', file)
-        with open(file) as tickerdata:
-            pairdata = json_load(tickerdata)
-    else:
-        return None
 
     if timerange:
         pairdata = trim_tickerlist(pairdata, timerange)
     return pairdata
 
 
+def store_tickerdata_file(datadir: Optional[Path], pair: str,
+                          ticker_interval: str, data: list, is_zip: bool = False):
+    """
+    Stores tickerdata to file
+    """
+    filename = pair_data_filename(datadir, pair, ticker_interval)
+    misc.file_dump_json(filename, data, is_zip=is_zip)
+
+
 def load_pair_history(pair: str,
                       ticker_interval: str,
                       datadir: Optional[Path],
                       timerange: TimeRange = TimeRange(None, None, 0, 0),
                       refresh_pairs: bool = False,
                       exchange: Optional[Exchange] = None,
+                      fill_up_missing: bool = True,
+                      drop_incomplete: bool = True
                       ) -> DataFrame:
     """
     Loads cached ticker history for the given pair.
+    :param pair: Pair to load data for
+    :param ticker_interval: Ticker-interval (e.g. "5m")
+    :param datadir: Path to the data storage location.
+    :param timerange: Limit data to be loaded to this timerange
+    :param refresh_pairs: Refresh pairs from exchange.
+        (Note: Requires exchange to be passed as well.)
+    :param exchange: Exchange object (needed when using "refresh_pairs")
+    :param fill_up_missing: Fill missing values with "No action"-candles
+    :param drop_incomplete: Drop last candle assuming it may be incomplete.
     :return: DataFrame with ohlcv data
     """
 
-    pairdata = load_tickerdata_file(datadir, pair, ticker_interval, timerange=timerange)
+    # The user forced the refresh of pairs
-    # If the user force the refresh of pairs
     if refresh_pairs:
-        if not exchange:
-            raise OperationalException("Exchange needs to be initialized when "
-                                       "calling load_data with refresh_pairs=True")
-
-        logger.info('Download data for all pairs and store them in %s', datadir)
         download_pair_history(datadir=datadir,
                               exchange=exchange,
                               pair=pair,
-                              tick_interval=ticker_interval,
+                              ticker_interval=ticker_interval,
                               timerange=timerange)
 
+    pairdata = load_tickerdata_file(datadir, pair, ticker_interval, timerange=timerange)
+
     if pairdata:
         if timerange.starttype == 'date' and pairdata[0][0] > timerange.startts * 1000:
             logger.warning('Missing data at start for pair %s, data starts at %s',
@@ -130,11 +123,15 @@ def load_pair_history(pair: str,
             logger.warning('Missing data at end for pair %s, data ends at %s',
                            pair,
                            arrow.get(pairdata[-1][0] // 1000).strftime('%Y-%m-%d %H:%M:%S'))
-        return parse_ticker_dataframe(pairdata)
+        return parse_ticker_dataframe(pairdata, ticker_interval, pair=pair,
+                                      fill_missing=fill_up_missing,
+                                      drop_incomplete=drop_incomplete)
     else:
-        logger.warning('No data for pair: "%s", Interval: %s. '
+        logger.warning(
-                       'Use --refresh-pairs-cached to download the data',
+            f'No history data for pair: "{pair}", interval: {ticker_interval}. '
-                       pair, ticker_interval)
+            'Use --refresh-pairs-cached option or `freqtrade download-data` '
+            'script to download the data'
+        )
         return None
 
 
@@ -143,20 +140,35 @@ def load_data(datadir: Optional[Path],
               pairs: List[str],
               refresh_pairs: bool = False,
               exchange: Optional[Exchange] = None,
-              timerange: TimeRange = TimeRange(None, None, 0, 0)) -> Dict[str, DataFrame]:
+              timerange: TimeRange = TimeRange(None, None, 0, 0),
+              fill_up_missing: bool = True,
+              live: bool = False
+              ) -> Dict[str, DataFrame]:
     """
     Loads ticker history data for a list of pairs the given parameters
     :return: dict(<pair>:<tickerlist>)
     """
-    result = {}
+    result: Dict[str, DataFrame] = {}
+    if live:
+        if exchange:
+            logger.info('Live: Downloading data for all defined pairs ...')
+            exchange.refresh_latest_ohlcv([(pair, ticker_interval) for pair in pairs])
+            result = {key[0]: value for key, value in exchange._klines.items() if value is not None}
+        else:
+            raise OperationalException(
+                "Exchange needs to be initialized when using live data."
+            )
+    else:
+        logger.info('Using local backtesting data ...')
 
-    for pair in pairs:
+        for pair in pairs:
-        hist = load_pair_history(pair=pair, ticker_interval=ticker_interval,
+            hist = load_pair_history(pair=pair, ticker_interval=ticker_interval,
-                                 datadir=datadir, timerange=timerange,
+                                     datadir=datadir, timerange=timerange,
-                                 refresh_pairs=refresh_pairs,
+                                     refresh_pairs=refresh_pairs,
-                                 exchange=exchange)
+                                     exchange=exchange,
-        if hist is not None:
+                                     fill_up_missing=fill_up_missing)
-            result[pair] = hist
+            if hist is not None:
+                result[pair] = hist
     return result
 
 
@@ -165,11 +177,21 @@ def make_testdata_path(datadir: Optional[Path]) -> Path:
     return datadir or (Path(__file__).parent.parent / "tests" / "testdata").resolve()
 
 
-def load_cached_data_for_updating(filename: Path, tick_interval: str,
+def pair_data_filename(datadir: Optional[Path], pair: str, ticker_interval: str) -> Path:
+    path = make_testdata_path(datadir)
+    pair_s = pair.replace("/", "_")
+    filename = path.joinpath(f'{pair_s}-{ticker_interval}.json')
+    return filename
+
+
+def load_cached_data_for_updating(datadir: Optional[Path], pair: str, ticker_interval: str,
                                   timerange: Optional[TimeRange]) -> Tuple[List[Any],
                                                                            Optional[int]]:
     """
-    Load cached data and choose what part of the data should be updated
+    Load cached data to download more data.
+    If timerange is passed in, checks wether data from an before the stored data will be downloaded.
+    If that's the case than what's available should be completely overwritten.
+    Only used by download_pair_history().
     """
 
     since_ms = None
@@ -179,16 +201,15 @@ def load_cached_data_for_updating(filename: Path, tick_interval: str,
         if timerange.starttype == 'date':
             since_ms = timerange.startts * 1000
         elif timerange.stoptype == 'line':
-            num_minutes = timerange.stopts * constants.TICKER_INTERVAL_MINUTES[tick_interval]
+            num_minutes = timerange.stopts * timeframe_to_minutes(ticker_interval)
             since_ms = arrow.utcnow().shift(minutes=num_minutes).timestamp * 1000
 
     # read the cached file
-    if filename.is_file():
+    # Intentionally don't pass timerange in - since we need to load the full dataset.
-        with open(filename, "rt") as file:
+    data = load_tickerdata_file(datadir, pair, ticker_interval)
-            data = json_load(file)
+    # remove the last item, could be incomplete candle
-        # remove the last item, could be incomplete candle
+    if data:
-        if data:
+        data.pop()
-            data.pop()
     else:
         data = []
 
@@ -204,9 +225,9 @@ def load_cached_data_for_updating(filename: Path, tick_interval: str,
 
 
 def download_pair_history(datadir: Optional[Path],
-                          exchange: Exchange,
+                          exchange: Optional[Exchange],
                           pair: str,
-                          tick_interval: str = '5m',
+                          ticker_interval: str = '5m',
                           timerange: Optional[TimeRange] = None) -> bool:
     """
     Download the latest ticker intervals from the exchange for the pair passed in parameters
@@ -215,37 +236,81 @@ def download_pair_history(datadir: Optional[Path],
     the full data will be redownloaded
 
     Based on @Rybolov work: https://github.com/rybolov/freqtrade-data
+
     :param pair: pair to download
-    :param tick_interval: ticker interval
+    :param ticker_interval: ticker interval
     :param timerange: range of time to download
     :return: bool with success state
-
     """
+    if not exchange:
+        raise OperationalException(
+            "Exchange needs to be initialized when downloading pair history data"
+        )
+
     try:
-        path = make_testdata_path(datadir)
+        logger.info(
-        filepair = pair.replace("/", "_")
+            f'Download history data for pair: "{pair}", interval: {ticker_interval} '
-        filename = path.joinpath(f'{filepair}-{tick_interval}.json')
+            f'and store in {datadir}.'
+        )
 
-        logger.info('Download the pair: "%s", Interval: %s', pair, tick_interval)
+        data, since_ms = load_cached_data_for_updating(datadir, pair, ticker_interval, timerange)
-
-        data, since_ms = load_cached_data_for_updating(filename, tick_interval, timerange)
 
         logger.debug("Current Start: %s", misc.format_ms_time(data[1][0]) if data else 'None')
         logger.debug("Current End: %s", misc.format_ms_time(data[-1][0]) if data else 'None')
 
         # Default since_ms to 30 days if nothing is given
-        new_data = exchange.get_history(pair=pair, tick_interval=tick_interval,
+        new_data = exchange.get_historic_ohlcv(pair=pair, ticker_interval=ticker_interval,
-                                        since_ms=since_ms if since_ms
+                                               since_ms=since_ms if since_ms
-                                        else
+                                               else
-                                        int(arrow.utcnow().shift(days=-30).float_timestamp) * 1000)
+                                               int(arrow.utcnow().shift(
+                                                   days=-30).float_timestamp) * 1000)
         data.extend(new_data)
 
         logger.debug("New Start: %s", misc.format_ms_time(data[0][0]))
         logger.debug("New End: %s", misc.format_ms_time(data[-1][0]))
 
-        misc.file_dump_json(filename, data)
+        store_tickerdata_file(datadir, pair, ticker_interval, data=data)
         return True
-    except BaseException:
+
-            logger.info('Failed to download the pair: "%s", Interval: %s',
+    except Exception as e:
-                        pair, tick_interval)
+        logger.error(
-            return False
+            f'Failed to download history data for pair: "{pair}", interval: {ticker_interval}. '
+            f'Error: {e}'
+        )
+        return False
+
+
+def get_timeframe(data: Dict[str, DataFrame]) -> Tuple[arrow.Arrow, arrow.Arrow]:
+    """
+    Get the maximum timeframe for the given backtest data
+    :param data: dictionary with preprocessed backtesting data
+    :return: tuple containing min_date, max_date
+    """
+    timeframe = [
+        (arrow.get(frame['date'].min()), arrow.get(frame['date'].max()))
+        for frame in data.values()
+    ]
+    return min(timeframe, key=operator.itemgetter(0))[0], \
+        max(timeframe, key=operator.itemgetter(1))[1]
+
+
+def validate_backtest_data(data: DataFrame, pair: str, min_date: datetime,
+                           max_date: datetime, ticker_interval_mins: int) -> bool:
+    """
+    Validates preprocessed backtesting data for missing values and shows warnings about it that.
+
+    :param data: preprocessed backtesting data (as DataFrame)
+    :param pair: pair used for log output.
+    :param min_date: start-date of the data
+    :param max_date: end-date of the data
+    :param ticker_interval_mins: ticker interval in minutes
+    """
+    # total difference in minutes / interval-minutes
+    expected_frames = int((max_date - min_date).total_seconds() // 60 // ticker_interval_mins)
+    found_missing = False
+    dflen = len(data)
+    if dflen < expected_frames:
+        found_missing = True
+        logger.warning("%s has missing frames: expected %s, got %s, that's %s missing values",
+                       pair, expected_frames, dflen, expected_frames - dflen)
+    return found_missing

freqtrade/edge/__init__.py

@@ -10,10 +10,8 @@ import utils_find_1st as utf1st
 from pandas import DataFrame
 
 from freqtrade import constants, OperationalException
-from freqtrade.arguments import Arguments
+from freqtrade.configuration import TimeRange
-from freqtrade.arguments import TimeRange
 from freqtrade.data import history
-from freqtrade.optimize import get_timeframe
 from freqtrade.strategy.interface import SellType
 
 
@@ -47,11 +45,6 @@ class Edge():
         self.config = config
         self.exchange = exchange
         self.strategy = strategy
-        self.ticker_interval = self.strategy.ticker_interval
-        self.tickerdata_to_dataframe = self.strategy.tickerdata_to_dataframe
-        self.get_timeframe = get_timeframe
-        self.advise_sell = self.strategy.advise_sell
-        self.advise_buy = self.strategy.advise_buy
 
         self.edge_config = self.config.get('edge', {})
         self._cached_pairs: Dict[str, Any] = {}  # Keeps a list of pairs
@@ -59,7 +52,7 @@ class Edge():
 
         # checking max_open_trades. it should be -1 as with Edge
         # the number of trades is determined by position size
-        if self.config['max_open_trades'] != -1:
+        if self.config['max_open_trades'] != float('inf'):
             logger.critical('max_open_trades should be -1 in config !')
 
         if self.config['stake_amount'] != constants.UNLIMITED_STAKE_AMOUNT:
@@ -82,7 +75,7 @@ class Edge():
             self._stoploss_range_step
         )
 
-        self._timerange: TimeRange = Arguments.parse_timerange("%s-" % arrow.now().shift(
+        self._timerange: TimeRange = TimeRange.parse_timerange("%s-" % arrow.now().shift(
             days=-1 * self._since_number_of_days).format('YYYYMMDD'))
 
         self.fee = self.exchange.get_fee()
@@ -102,7 +95,7 @@ class Edge():
         data = history.load_data(
             datadir=Path(self.config['datadir']) if self.config.get('datadir') else None,
             pairs=pairs,
-            ticker_interval=self.ticker_interval,
+            ticker_interval=self.strategy.ticker_interval,
             refresh_pairs=self._refresh_pairs,
             exchange=self.exchange,
             timerange=self._timerange
@@ -114,10 +107,10 @@ class Edge():
             logger.critical("No data found. Edge is stopped ...")
             return False
 
-        preprocessed = self.tickerdata_to_dataframe(data)
+        preprocessed = self.strategy.tickerdata_to_dataframe(data)
 
         # Print timeframe
-        min_date, max_date = self.get_timeframe(preprocessed)
+        min_date, max_date = history.get_timeframe(preprocessed)
         logger.info(
             'Measuring data from %s up to %s (%s days) ...',
             min_date.isoformat(),
@@ -132,13 +125,14 @@ class Edge():
             pair_data = pair_data.sort_values(by=['date'])
             pair_data = pair_data.reset_index(drop=True)
 
-            ticker_data = self.advise_sell(
+            ticker_data = self.strategy.advise_sell(
-                self.advise_buy(pair_data, {'pair': pair}), {'pair': pair})[headers].copy()
+                self.strategy.advise_buy(pair_data, {'pair': pair}), {'pair': pair})[headers].copy()
 
             trades += self._find_trades_for_stoploss_range(ticker_data, pair, self._stoploss_range)
 
         # If no trade found then exit
         if len(trades) == 0:
+            logger.info("No trades found.")
             return False
 
         # Fill missing, calculable columns, profit, duration , abs etc.
@@ -190,12 +184,35 @@ class Edge():
         if self._final_pairs != final:
             self._final_pairs = final
             if self._final_pairs:
-                logger.info('Edge validated only %s', self._final_pairs)
+                logger.info(
+                    'Minimum expectancy and minimum winrate are met only for %s,'
+                    ' so other pairs are filtered out.',
+                    self._final_pairs
+                    )
             else:
-                logger.info('Edge removed all pairs as no pair with minimum expectancy was found !')
+                logger.info(
+                    'Edge removed all pairs as no pair with minimum expectancy '
+                    'and minimum winrate was found !'
+                    )
 
         return self._final_pairs
 
+    def accepted_pairs(self) -> list:
+        """
+        return a list of accepted pairs along with their winrate, expectancy and stoploss
+        """
+        final = []
+        for pair, info in self._cached_pairs.items():
+            if info.expectancy > float(self.edge_config.get('minimum_expectancy', 0.2)) and \
+                 info.winrate > float(self.edge_config.get('minimum_winrate', 0.60)):
+                final.append({
+                    'Pair': pair,
+                    'Winrate': info.winrate,
+                    'Expectancy': info.expectancy,
+                    'Stoploss': info.stoploss,
+                })
+        return final
+
     def _fill_calculable_fields(self, result: DataFrame) -> DataFrame:
         """
         The result frame contains a number of columns that are calculable
@@ -344,91 +361,93 @@ class Edge():
         return result
 
     def _detect_next_stop_or_sell_point(self, buy_column, sell_column, date_column,
-                                        ohlc_columns, stoploss, pair, start_point=0):
+                                        ohlc_columns, stoploss, pair):
         """
-        Iterate through ohlc_columns recursively in order to find the next trade
+        Iterate through ohlc_columns in order to find the next trade
         Next trade opens from the first buy signal noticed to
         The sell or stoploss signal after it.
-        It then calls itself cutting OHLC, buy_column, sell_colum and date_column
+        It then cuts OHLC, buy_column, sell_column and date_column.
-        Cut from (the exit trade index) + 1
+        Cut from (the exit trade index) + 1.
+
         Author: https://github.com/mishaker
         """
 
         result: list = []
-        open_trade_index = utf1st.find_1st(buy_column, 1, utf1st.cmp_equal)
+        start_point = 0
 
-        # return empty if we don't find trade entry (i.e. buy==1) or
+        while True:
-        # we find a buy but at the of array
+            open_trade_index = utf1st.find_1st(buy_column, 1, utf1st.cmp_equal)
-        if open_trade_index == -1 or open_trade_index == len(buy_column) - 1:
-            return []
-        else:
-            open_trade_index += 1  # when a buy signal is seen,
-            # trade opens in reality on the next candle
 
-        stop_price_percentage = stoploss + 1
+            # Return empty if we don't find trade entry (i.e. buy==1) or
-        open_price = ohlc_columns[open_trade_index, 0]
+            # we find a buy but at the end of array
-        stop_price = (open_price * stop_price_percentage)
+            if open_trade_index == -1 or open_trade_index == len(buy_column) - 1:
+                break
+            else:
+                # When a buy signal is seen,
+                # trade opens in reality on the next candle
+                open_trade_index += 1
 
-        # Searching for the index where stoploss is hit
+            stop_price_percentage = stoploss + 1
-        stop_index = utf1st.find_1st(
+            open_price = ohlc_columns[open_trade_index, 0]
-            ohlc_columns[open_trade_index:, 2], stop_price, utf1st.cmp_smaller)
+            stop_price = (open_price * stop_price_percentage)
 
-        # If we don't find it then we assume stop_index will be far in future (infinite number)
+            # Searching for the index where stoploss is hit
-        if stop_index == -1:
+            stop_index = utf1st.find_1st(
-            stop_index = float('inf')
+                ohlc_columns[open_trade_index:, 2], stop_price, utf1st.cmp_smaller)
 
-        # Searching for the index where sell is hit
+            # If we don't find it then we assume stop_index will be far in future (infinite number)
-        sell_index = utf1st.find_1st(sell_column[open_trade_index:], 1, utf1st.cmp_equal)
+            if stop_index == -1:
+                stop_index = float('inf')
 
-        # If we don't find it then we assume sell_index will be far in future (infinite number)
+            # Searching for the index where sell is hit
-        if sell_index == -1:
+            sell_index = utf1st.find_1st(sell_column[open_trade_index:], 1, utf1st.cmp_equal)
-            sell_index = float('inf')
 
-        # Check if we don't find any stop or sell point (in that case trade remains open)
+            # If we don't find it then we assume sell_index will be far in future (infinite number)
-        # It is not interesting for Edge to consider it so we simply ignore the trade
+            if sell_index == -1:
-        # And stop iterating there is no more entry
+                sell_index = float('inf')
-        if stop_index == sell_index == float('inf'):
-            return []
 
-        if stop_index <= sell_index:
+            # Check if we don't find any stop or sell point (in that case trade remains open)
-            exit_index = open_trade_index + stop_index
+            # It is not interesting for Edge to consider it so we simply ignore the trade
-            exit_type = SellType.STOP_LOSS
+            # And stop iterating there is no more entry
-            exit_price = stop_price
+            if stop_index == sell_index == float('inf'):
-        elif stop_index > sell_index:
+                break
-            # if exit is SELL then we exit at the next candle
-            exit_index = open_trade_index + sell_index + 1
 
-            # check if we have the next candle
+            if stop_index <= sell_index:
-            if len(ohlc_columns) - 1 < exit_index:
+                exit_index = open_trade_index + stop_index
-                return []
+                exit_type = SellType.STOP_LOSS
+                exit_price = stop_price
+            elif stop_index > sell_index:
+                # If exit is SELL then we exit at the next candle
+                exit_index = open_trade_index + sell_index + 1
 
-            exit_type = SellType.SELL_SIGNAL
+                # Check if we have the next candle
-            exit_price = ohlc_columns[exit_index, 0]
+                if len(ohlc_columns) - 1 < exit_index:
+                    break
 
-        trade = {'pair': pair,
+                exit_type = SellType.SELL_SIGNAL
-                 'stoploss': stoploss,
+                exit_price = ohlc_columns[exit_index, 0]
-                 'profit_percent': '',
-                 'profit_abs': '',
-                 'open_time': date_column[open_trade_index],
-                 'close_time': date_column[exit_index],
-                 'open_index': start_point + open_trade_index,
-                 'close_index': start_point + exit_index,
-                 'trade_duration': '',
-                 'open_rate': round(open_price, 15),
-                 'close_rate': round(exit_price, 15),
-                 'exit_type': exit_type
-                 }
 
-        result.append(trade)
+            trade = {'pair': pair,
+                     'stoploss': stoploss,
+                     'profit_percent': '',
+                     'profit_abs': '',
+                     'open_time': date_column[open_trade_index],
+                     'close_time': date_column[exit_index],
+                     'open_index': start_point + open_trade_index,
+                     'close_index': start_point + exit_index,
+                     'trade_duration': '',
+                     'open_rate': round(open_price, 15),
+                     'close_rate': round(exit_price, 15),
+                     'exit_type': exit_type
+                     }
 
-        # Calling again the same function recursively but giving
+            result.append(trade)
-        # it a view of exit_index till the end of array
+
-        return result + self._detect_next_stop_or_sell_point(
+            # Giving a view of exit_index till the end of array
-            buy_column[exit_index:],
+            buy_column = buy_column[exit_index:]
-            sell_column[exit_index:],
+            sell_column = sell_column[exit_index:]
-            date_column[exit_index:],
+            date_column = date_column[exit_index:]
-            ohlc_columns[exit_index:],
+            ohlc_columns = ohlc_columns[exit_index:]
-            stoploss,
+            start_point += exit_index
-            pair,
+
-            (start_point + exit_index)
+        return result
-        )

freqtrade/exchange/__init__.py

@@ -1,713 +1,13 @@
-# pragma pylint: disable=W0603
+from freqtrade.exchange.exchange import Exchange  # noqa: F401
-""" Cryptocurrency Exchanges support """
+from freqtrade.exchange.exchange import (get_exchange_bad_reason,  # noqa: F401
-import logging
+                                         is_exchange_bad,
-import inspect
+                                         is_exchange_available,
-from random import randint
+                                         is_exchange_officially_supported,
-from typing import List, Dict, Tuple, Any, Optional
+                                         available_exchanges)
-from datetime import datetime
+from freqtrade.exchange.exchange import (timeframe_to_seconds,  # noqa: F401
-from math import floor, ceil
+                                         timeframe_to_minutes,
-
+                                         timeframe_to_msecs,
-import arrow
+                                         timeframe_to_next_date,
-import asyncio
+                                         timeframe_to_prev_date)
-import ccxt
+from freqtrade.exchange.kraken import Kraken  # noqa: F401
-import ccxt.async_support as ccxt_async
+from freqtrade.exchange.binance import Binance  # noqa: F401
-from pandas import DataFrame
-
-from freqtrade import constants, OperationalException, DependencyException, TemporaryError
-from freqtrade.data.converter import parse_ticker_dataframe
-
-logger = logging.getLogger(__name__)
-
-API_RETRY_COUNT = 4
-
-
-# Urls to exchange markets, insert quote and base with .format()
-_EXCHANGE_URLS = {
-    ccxt.bittrex.__name__: '/Market/Index?MarketName={quote}-{base}',
-    ccxt.binance.__name__: '/tradeDetail.html?symbol={base}_{quote}'
-}
-
-
-def retrier_async(f):
-    async def wrapper(*args, **kwargs):
-        count = kwargs.pop('count', API_RETRY_COUNT)
-        try:
-            return await f(*args, **kwargs)
-        except (TemporaryError, DependencyException) as ex:
-            logger.warning('%s() returned exception: "%s"', f.__name__, ex)
-            if count > 0:
-                count -= 1
-                kwargs.update({'count': count})
-                logger.warning('retrying %s() still for %s times', f.__name__, count)
-                return await wrapper(*args, **kwargs)
-            else:
-                logger.warning('Giving up retrying: %s()', f.__name__)
-                raise ex
-    return wrapper
-
-
-def retrier(f):
-    def wrapper(*args, **kwargs):
-        count = kwargs.pop('count', API_RETRY_COUNT)
-        try:
-            return f(*args, **kwargs)
-        except (TemporaryError, DependencyException) as ex:
-            logger.warning('%s() returned exception: "%s"', f.__name__, ex)
-            if count > 0:
-                count -= 1
-                kwargs.update({'count': count})
-                logger.warning('retrying %s() still for %s times', f.__name__, count)
-                return wrapper(*args, **kwargs)
-            else:
-                logger.warning('Giving up retrying: %s()', f.__name__)
-                raise ex
-    return wrapper
-
-
-class Exchange(object):
-
-    _conf: Dict = {}
-
-    def __init__(self, config: dict) -> None:
-        """
-        Initializes this module with the given config,
-        it does basic validation whether the specified
-        exchange and pairs are valid.
-        :return: None
-        """
-        self._conf.update(config)
-
-        self._cached_ticker: Dict[str, Any] = {}
-
-        # Holds last candle refreshed time of each pair
-        self._pairs_last_refresh_time: Dict[str, int] = {}
-
-        # Holds candles
-        self._klines: Dict[str, DataFrame] = {}
-
-        # Holds all open sell orders for dry_run
-        self._dry_run_open_orders: Dict[str, Any] = {}
-
-        if config['dry_run']:
-            logger.info('Instance is running with dry_run enabled')
-
-        exchange_config = config['exchange']
-        self._api: ccxt.Exchange = self._init_ccxt(
-            exchange_config, ccxt_kwargs=exchange_config.get('ccxt_config'))
-        self._api_async: ccxt_async.Exchange = self._init_ccxt(
-            exchange_config, ccxt_async, ccxt_kwargs=exchange_config.get('ccxt_async_config'))
-
-        logger.info('Using Exchange "%s"', self.name)
-
-        self.markets = self._load_markets()
-        # Check if all pairs are available
-        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', {}))
-        if config.get('ticker_interval'):
-            # Check if timeframe is available
-            self.validate_timeframes(config['ticker_interval'])
-
-    def __del__(self):
-        """
-        Destructor - clean up async stuff
-        """
-        logger.debug("Exchange object destroyed, closing async loop")
-        if self._api_async and inspect.iscoroutinefunction(self._api_async.close):
-            asyncio.get_event_loop().run_until_complete(self._api_async.close())
-
-    def _init_ccxt(self, exchange_config: dict, ccxt_module=ccxt,
-                   ccxt_kwargs: dict = None) -> ccxt.Exchange:
-        """
-        Initialize ccxt with given config and return valid
-        ccxt instance.
-        """
-        # Find matching class for the given exchange name
-        name = exchange_config['name']
-
-        if name not in ccxt_module.exchanges:
-            raise OperationalException(f'Exchange {name} is not supported')
-
-        ex_config = {
-            'apiKey': exchange_config.get('key'),
-            'secret': exchange_config.get('secret'),
-            'password': exchange_config.get('password'),
-            'uid': exchange_config.get('uid', ''),
-            'enableRateLimit': exchange_config.get('ccxt_rate_limit', True)
-        }
-        if ccxt_kwargs:
-            logger.info('Applying additional ccxt config: %s', ccxt_kwargs)
-            ex_config.update(ccxt_kwargs)
-        try:
-
-            api = getattr(ccxt_module, name.lower())(ex_config)
-        except (KeyError, AttributeError):
-            raise OperationalException(f'Exchange {name} is not supported')
-
-        self.set_sandbox(api, exchange_config, name)
-
-        return api
-
-    @property
-    def name(self) -> str:
-        """exchange Name (from ccxt)"""
-        return self._api.name
-
-    @property
-    def id(self) -> str:
-        """exchange ccxt id"""
-        return self._api.id
-
-    def klines(self, pair: str, copy=True) -> DataFrame:
-        if pair in self._klines:
-            return self._klines[pair].copy() if copy else self._klines[pair]
-        else:
-            return None
-
-    def set_sandbox(self, api, exchange_config: dict, name: str):
-        if exchange_config.get('sandbox'):
-            if api.urls.get('test'):
-                api.urls['api'] = api.urls['test']
-                logger.info("Enabled Sandbox API on %s", name)
-            else:
-                logger.warning(name, "No Sandbox URL in CCXT, exiting. "
-                                     "Please check your config.json")
-                raise OperationalException(f'Exchange {name} does not provide a sandbox api')
-
-    def _load_async_markets(self) -> None:
-        try:
-            if self._api_async:
-                asyncio.get_event_loop().run_until_complete(self._api_async.load_markets())
-
-        except ccxt.BaseError as e:
-            logger.warning('Could not load async markets. Reason: %s', e)
-            return
-
-    def _load_markets(self) -> Dict[str, Any]:
-        """ Initialize markets both sync and async """
-        try:
-            markets = self._api.load_markets()
-            self._load_async_markets()
-            return markets
-        except ccxt.BaseError as e:
-            logger.warning('Unable to initialize markets. Reason: %s', e)
-        return {}
-
-    def validate_pairs(self, pairs: List[str]) -> None:
-        """
-        Checks if all given pairs are tradable on the current exchange.
-        Raises OperationalException if one pair is not available.
-        :param pairs: list of pairs
-        :return: None
-        """
-
-        if not self.markets:
-            logger.warning('Unable to validate pairs (assuming they are correct).')
-        #     return
-
-        stake_cur = self._conf['stake_currency']
-        for pair in pairs:
-            # Note: ccxt has BaseCurrency/QuoteCurrency format for pairs
-            # TODO: add a support for having coins in BTC/USDT format
-            if not pair.endswith(stake_cur):
-                raise OperationalException(
-                    f'Pair {pair} not compatible with stake_currency: {stake_cur}')
-            if self.markets and pair not in self.markets:
-                raise OperationalException(
-                    f'Pair {pair} is not available at {self.name}'
-                    f'Please remove {pair} from your whitelist.')
-
-    def validate_timeframes(self, timeframe: List[str]) -> None:
-        """
-        Checks if ticker interval from config is a supported timeframe on the exchange
-        """
-        timeframes = self._api.timeframes
-        if timeframe not in timeframes:
-            raise OperationalException(
-                f'Invalid ticker {timeframe}, this Exchange supports {timeframes}')
-
-    def validate_ordertypes(self, order_types: Dict) -> None:
-        """
-        Checks if order-types configured in strategy/config are supported
-        """
-        if any(v == 'market' for k, v in order_types.items()):
-            if not self.exchange_has('createMarketOrder'):
-                raise OperationalException(
-                    f'Exchange {self.name} does not support market orders.')
-
-        if order_types.get('stoploss_on_exchange'):
-            if self.name is not 'Binance':
-                raise OperationalException(
-                    'On exchange stoploss is not supported for %s.' % self.name
-                )
-
-    def validate_order_time_in_force(self, order_time_in_force: Dict) -> None:
-        """
-        Checks if order time in force configured in strategy/config are supported
-        """
-        if any(v != 'gtc' for k, v in order_time_in_force.items()):
-            if self.name is not 'Binance':
-                raise OperationalException(
-                    f'Time in force policies are not supporetd for  {self.name} yet.')
-
-    def exchange_has(self, endpoint: str) -> bool:
-        """
-        Checks if exchange implements a specific API endpoint.
-        Wrapper around ccxt 'has' attribute
-        :param endpoint: Name of endpoint (e.g. 'fetchOHLCV', 'fetchTickers')
-        :return: bool
-        """
-        return endpoint in self._api.has and self._api.has[endpoint]
-
-    def symbol_amount_prec(self, pair, amount: float):
-        '''
-        Returns the amount to buy or sell to a precision the Exchange accepts
-        Rounded down
-        '''
-        if self._api.markets[pair]['precision']['amount']:
-            symbol_prec = self._api.markets[pair]['precision']['amount']
-            big_amount = amount * pow(10, symbol_prec)
-            amount = floor(big_amount) / pow(10, symbol_prec)
-        return amount
-
-    def symbol_price_prec(self, pair, price: float):
-        '''
-        Returns the price buying or selling with to the precision the Exchange accepts
-        Rounds up
-        '''
-        if self._api.markets[pair]['precision']['price']:
-            symbol_prec = self._api.markets[pair]['precision']['price']
-            big_price = price * pow(10, symbol_prec)
-            price = ceil(big_price) / pow(10, symbol_prec)
-        return price
-
-    def buy(self, pair: str, ordertype: str, amount: float,
-            rate: float, time_in_force) -> Dict:
-        if self._conf['dry_run']:
-            order_id = f'dry_run_buy_{randint(0, 10**6)}'
-            self._dry_run_open_orders[order_id] = {
-                'pair': pair,
-                'price': rate,
-                'amount': amount,
-                'type': ordertype,
-                'side': 'buy',
-                'remaining': 0.0,
-                'datetime': arrow.utcnow().isoformat(),
-                'status': 'closed',
-                'fee': None
-            }
-            return {'id': order_id}
-
-        try:
-            # Set the precision for amount and price(rate) as accepted by the exchange
-            amount = self.symbol_amount_prec(pair, amount)
-            rate = self.symbol_price_prec(pair, rate) if ordertype != 'market' else None
-
-            if time_in_force == 'gtc':
-                return self._api.create_order(pair, ordertype, 'buy', amount, rate)
-            else:
-                return self._api.create_order(pair, ordertype, 'buy',
-                                              amount, rate, {'timeInForce': time_in_force})
-
-        except ccxt.InsufficientFunds as e:
-            raise DependencyException(
-                f'Insufficient funds to create limit buy order on market {pair}.'
-                f'Tried to buy amount {amount} at rate {rate} (total {rate*amount}).'
-                f'Message: {e}')
-        except ccxt.InvalidOrder as e:
-            raise DependencyException(
-                f'Could not create limit buy order on market {pair}.'
-                f'Tried to buy amount {amount} at rate {rate} (total {rate*amount}).'
-                f'Message: {e}')
-        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-            raise TemporaryError(
-                f'Could not place buy order due to {e.__class__.__name__}. Message: {e}')
-        except ccxt.BaseError as e:
-            raise OperationalException(e)
-
-    def sell(self, pair: str, ordertype: str, amount: float,
-             rate: float, time_in_force='gtc') -> Dict:
-        if self._conf['dry_run']:
-            order_id = f'dry_run_sell_{randint(0, 10**6)}'
-            self._dry_run_open_orders[order_id] = {
-                'pair': pair,
-                'price': rate,
-                'amount': amount,
-                'type': ordertype,
-                'side': 'sell',
-                'remaining': 0.0,
-                'datetime': arrow.utcnow().isoformat(),
-                'status': 'closed'
-            }
-            return {'id': order_id}
-
-        try:
-            # Set the precision for amount and price(rate) as accepted by the exchange
-            amount = self.symbol_amount_prec(pair, amount)
-            rate = self.symbol_price_prec(pair, rate) if ordertype != 'market' else None
-
-            if time_in_force == 'gtc':
-                return self._api.create_order(pair, ordertype, 'sell', amount, rate)
-            else:
-                return self._api.create_order(pair, ordertype, 'sell',
-                                              amount, rate, {'timeInForce': time_in_force})
-
-        except ccxt.InsufficientFunds as e:
-            raise DependencyException(
-                f'Insufficient funds to create limit sell order on market {pair}.'
-                f'Tried to sell amount {amount} at rate {rate} (total {rate*amount}).'
-                f'Message: {e}')
-        except ccxt.InvalidOrder as e:
-            raise DependencyException(
-                f'Could not create limit sell order on market {pair}.'
-                f'Tried to sell amount {amount} at rate {rate} (total {rate*amount}).'
-                f'Message: {e}')
-        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-            raise TemporaryError(
-                f'Could not place sell order due to {e.__class__.__name__}. Message: {e}')
-        except ccxt.BaseError as e:
-            raise OperationalException(e)
-
-    def stoploss_limit(self, pair: str, amount: float, stop_price: float, rate: float) -> Dict:
-        """
-        creates a stoploss limit order.
-        NOTICE: it is not supported by all exchanges. only binance is tested for now.
-        """
-
-        # Set the precision for amount and price(rate) as accepted by the exchange
-        amount = self.symbol_amount_prec(pair, amount)
-        rate = self.symbol_price_prec(pair, rate)
-        stop_price = self.symbol_price_prec(pair, stop_price)
-
-        # Ensure rate is less than stop price
-        if stop_price <= rate:
-            raise OperationalException(
-                'In stoploss limit order, stop price should be more than limit price')
-
-        if self._conf['dry_run']:
-            order_id = f'dry_run_buy_{randint(0, 10**6)}'
-            self._dry_run_open_orders[order_id] = {
-                'info': {},
-                'id': order_id,
-                'pair': pair,
-                'price': stop_price,
-                'amount': amount,
-                'type': 'stop_loss_limit',
-                'side': 'sell',
-                'remaining': amount,
-                'datetime': arrow.utcnow().isoformat(),
-                'status': 'open',
-                'fee': None
-            }
-            return self._dry_run_open_orders[order_id]
-
-        try:
-            return self._api.create_order(pair, 'stop_loss_limit', 'sell',
-                                          amount, rate, {'stopPrice': stop_price})
-
-        except ccxt.InsufficientFunds as e:
-            raise DependencyException(
-                f'Insufficient funds to place stoploss limit order on market {pair}. '
-                f'Tried to put a stoploss amount {amount} with '
-                f'stop {stop_price} and limit {rate} (total {rate*amount}).'
-                f'Message: {e}')
-        except ccxt.InvalidOrder as e:
-            raise DependencyException(
-                f'Could not place stoploss limit order on market {pair}.'
-                f'Tried to place stoploss amount {amount} with '
-                f'stop {stop_price} and limit {rate} (total {rate*amount}).'
-                f'Message: {e}')
-        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-            raise TemporaryError(
-                f'Could not place stoploss limit order due to {e.__class__.__name__}. Message: {e}')
-        except ccxt.BaseError as e:
-            raise OperationalException(e)
-
-    @retrier
-    def get_balance(self, currency: str) -> float:
-        if self._conf['dry_run']:
-            return 999.9
-
-        # ccxt exception is already handled by get_balances
-        balances = self.get_balances()
-        balance = balances.get(currency)
-        if balance is None:
-            raise TemporaryError(
-                f'Could not get {currency} balance due to malformed exchange response: {balances}')
-        return balance['free']
-
-    @retrier
-    def get_balances(self) -> dict:
-        if self._conf['dry_run']:
-            return {}
-
-        try:
-            balances = self._api.fetch_balance()
-            # Remove additional info from ccxt results
-            balances.pop("info", None)
-            balances.pop("free", None)
-            balances.pop("total", None)
-            balances.pop("used", None)
-
-            return balances
-        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-            raise TemporaryError(
-                f'Could not get balance due to {e.__class__.__name__}. Message: {e}')
-        except ccxt.BaseError as e:
-            raise OperationalException(e)
-
-    @retrier
-    def get_tickers(self) -> Dict:
-        try:
-            return self._api.fetch_tickers()
-        except ccxt.NotSupported as e:
-            raise OperationalException(
-                f'Exchange {self._api.name} does not support fetching tickers in batch.'
-                f'Message: {e}')
-        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-            raise TemporaryError(
-                f'Could not load tickers due to {e.__class__.__name__}. Message: {e}')
-        except ccxt.BaseError as e:
-            raise OperationalException(e)
-
-    @retrier
-    def get_ticker(self, pair: str, refresh: Optional[bool] = True) -> dict:
-        if refresh or pair not in self._cached_ticker.keys():
-            try:
-                if pair not in self._api.markets:
-                    raise DependencyException(f"Pair {pair} not available")
-                data = self._api.fetch_ticker(pair)
-                try:
-                    self._cached_ticker[pair] = {
-                        'bid': float(data['bid']),
-                        'ask': float(data['ask']),
-                    }
-                except KeyError:
-                    logger.debug("Could not cache ticker data for %s", pair)
-                return data
-            except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-                raise TemporaryError(
-                    f'Could not load ticker due to {e.__class__.__name__}. Message: {e}')
-            except ccxt.BaseError as e:
-                raise OperationalException(e)
-        else:
-            logger.info("returning cached ticker-data for %s", pair)
-            return self._cached_ticker[pair]
-
-    def get_history(self, pair: str, tick_interval: str,
-                    since_ms: int) -> List:
-        """
-        Gets candle history using asyncio and returns the list of candles.
-        Handles all async doing.
-        """
-        return asyncio.get_event_loop().run_until_complete(
-            self._async_get_history(pair=pair, tick_interval=tick_interval,
-                                    since_ms=since_ms))
-
-    async def _async_get_history(self, pair: str,
-                                 tick_interval: str,
-                                 since_ms: int) -> List:
-        # Assume exchange returns 500 candles
-        _LIMIT = 500
-
-        one_call = constants.TICKER_INTERVAL_MINUTES[tick_interval] * 60 * _LIMIT * 1000
-        logger.debug("one_call: %s", one_call)
-        input_coroutines = [self._async_get_candle_history(
-            pair, tick_interval, since) for since in
-            range(since_ms, arrow.utcnow().timestamp * 1000, one_call)]
-        tickers = await asyncio.gather(*input_coroutines, return_exceptions=True)
-
-        # Combine tickers
-        data: List = []
-        for p, ticker in tickers:
-            if p == pair:
-                data.extend(ticker)
-        # Sort data again after extending the result - above calls return in "async order" order
-        data = sorted(data, key=lambda x: x[0])
-        logger.info("downloaded %s with length %s.", pair, len(data))
-        return data
-
-    def refresh_tickers(self, pair_list: List[str], ticker_interval: str) -> None:
-        """
-        Refresh tickers asyncronously and set `_klines` of this object with the result
-        """
-        logger.debug("Refreshing klines for %d pairs", len(pair_list))
-        asyncio.get_event_loop().run_until_complete(
-            self.async_get_candles_history(pair_list, ticker_interval))
-
-    async def async_get_candles_history(self, pairs: List[str],
-                                        tick_interval: str) -> List[Tuple[str, List]]:
-        """Download ohlcv history for pair-list asyncronously """
-        # Calculating ticker interval in second
-        interval_in_sec = constants.TICKER_INTERVAL_MINUTES[tick_interval] * 60
-        input_coroutines = []
-
-        # Gather corotines to run
-        for pair in pairs:
-            if not (self._pairs_last_refresh_time.get(pair, 0) + interval_in_sec >=
-                    arrow.utcnow().timestamp and pair in self._klines):
-                input_coroutines.append(self._async_get_candle_history(pair, tick_interval))
-            else:
-                logger.debug("Using cached klines data for %s ...", pair)
-
-        tickers = await asyncio.gather(*input_coroutines, return_exceptions=True)
-
-        # handle caching
-        for pair, ticks in tickers:
-            # keeping last candle time as last refreshed time of the pair
-            if ticks:
-                self._pairs_last_refresh_time[pair] = ticks[-1][0] // 1000
-            # keeping parsed dataframe in cache
-            self._klines[pair] = parse_ticker_dataframe(ticks)
-        return tickers
-
-    @retrier_async
-    async def _async_get_candle_history(self, pair: str, tick_interval: str,
-                                        since_ms: Optional[int] = None) -> Tuple[str, List]:
-        try:
-            # fetch ohlcv asynchronously
-            logger.debug("fetching %s since %s ...", pair, since_ms)
-
-            data = await self._api_async.fetch_ohlcv(pair, timeframe=tick_interval,
-                                                     since=since_ms)
-
-            # Because some exchange sort Tickers ASC and other DESC.
-            # Ex: Bittrex returns a list of tickers ASC (oldest first, newest last)
-            # when GDAX returns a list of tickers DESC (newest first, oldest last)
-            # Only sort if necessary to save computing time
-            if data and data[0][0] > data[-1][0]:
-                data = sorted(data, key=lambda x: x[0])
-
-            logger.debug("done fetching %s ...", pair)
-            return pair, data
-
-        except ccxt.NotSupported as e:
-            raise OperationalException(
-                f'Exchange {self._api.name} does not support fetching historical candlestick data.'
-                f'Message: {e}')
-        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-            raise TemporaryError(
-                f'Could not load ticker history due to {e.__class__.__name__}. Message: {e}')
-        except ccxt.BaseError as e:
-            raise OperationalException(f'Could not fetch ticker data. Msg: {e}')
-
-    @retrier
-    def cancel_order(self, order_id: str, pair: str) -> None:
-        if self._conf['dry_run']:
-            return
-
-        try:
-            return self._api.cancel_order(order_id, pair)
-        except ccxt.InvalidOrder as e:
-            raise DependencyException(
-                f'Could not cancel order. Message: {e}')
-        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-            raise TemporaryError(
-                f'Could not cancel order due to {e.__class__.__name__}. Message: {e}')
-        except ccxt.BaseError as e:
-            raise OperationalException(e)
-
-    @retrier
-    def get_order(self, order_id: str, pair: str) -> Dict:
-        if self._conf['dry_run']:
-            order = self._dry_run_open_orders[order_id]
-            order.update({
-                'id': order_id
-            })
-            return order
-        try:
-            return self._api.fetch_order(order_id, pair)
-        except ccxt.InvalidOrder as e:
-            raise DependencyException(
-                f'Could not get order. Message: {e}')
-        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-            raise TemporaryError(
-                f'Could not get order due to {e.__class__.__name__}. Message: {e}')
-        except ccxt.BaseError as e:
-            raise OperationalException(e)
-
-    @retrier
-    def get_order_book(self, pair: str, limit: int = 100) -> dict:
-        """
-        get order book level 2 from exchange
-
-        Notes:
-        20180619: bittrex doesnt support limits -.-
-        20180619: binance support limits but only on specific range
-        """
-        try:
-            if self._api.name == 'Binance':
-                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)))
-                # above script works like loop below (but with slightly better performance):
-                #   for limitx in limit_range:
-                #        if limit <= limitx:
-                #           limit = limitx
-                #           break
-
-            return self._api.fetch_l2_order_book(pair, limit)
-        except ccxt.NotSupported as e:
-            raise OperationalException(
-                f'Exchange {self._api.name} does not support fetching order book.'
-                f'Message: {e}')
-        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-            raise TemporaryError(
-                f'Could not get order book due to {e.__class__.__name__}. Message: {e}')
-        except ccxt.BaseError as e:
-            raise OperationalException(e)
-
-    @retrier
-    def get_trades_for_order(self, order_id: str, pair: str, since: datetime) -> List:
-        if self._conf['dry_run']:
-            return []
-        if not self.exchange_has('fetchMyTrades'):
-            return []
-        try:
-            # Allow 5s offset to catch slight time offsets (discovered in #1185)
-            my_trades = self._api.fetch_my_trades(pair, since.timestamp() - 5)
-            matched_trades = [trade for trade in my_trades if trade['order'] == order_id]
-
-            return matched_trades
-
-        except ccxt.NetworkError as e:
-            raise TemporaryError(
-                f'Could not get trades due to networking error. Message: {e}')
-        except ccxt.BaseError as e:
-            raise OperationalException(e)
-
-    def get_pair_detail_url(self, pair: str) -> str:
-        try:
-            url_base = self._api.urls.get('www')
-            base, quote = pair.split('/')
-
-            return url_base + _EXCHANGE_URLS[self._api.id].format(base=base, quote=quote)
-        except KeyError:
-            logger.warning('Could not get exchange url for %s', self.name)
-            return ""
-
-    @retrier
-    def get_markets(self) -> List[dict]:
-        try:
-            return self._api.fetch_markets()
-        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-            raise TemporaryError(
-                f'Could not load markets due to {e.__class__.__name__}. Message: {e}')
-        except ccxt.BaseError as e:
-            raise OperationalException(e)
-
-    @retrier
-    def get_fee(self, symbol='ETH/BTC', type='', side='', amount=1,
-                price=1, taker_or_maker='maker') -> float:
-        try:
-            # validate that markets are loaded before trying to get fee
-            if self._api.markets is None or len(self._api.markets) == 0:
-                self._api.load_markets()
-
-            return self._api.calculate_fee(symbol=symbol, type=type, side=side, amount=amount,
-                                           price=price, takerOrMaker=taker_or_maker)['rate']
-        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-            raise TemporaryError(
-                f'Could not get fee info due to {e.__class__.__name__}. Message: {e}')
-        except ccxt.BaseError as e:
-            raise OperationalException(e)

freqtrade/exchange/binance.py

@@ -0,0 +1,27 @@
+""" Binance exchange subclass """
+import logging
+from typing import Dict
+
+from freqtrade.exchange import Exchange
+
+logger = logging.getLogger(__name__)
+
+
+class Binance(Exchange):
+
+    _ft_has: Dict = {
+        "stoploss_on_exchange": True,
+        "order_time_in_force": ['gtc', 'fok', 'ioc'],
+    }
+
+    def get_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().get_order_book(pair, limit)

freqtrade/exchange/exchange.py

@@ -0,0 +1,847 @@
+# pragma pylint: disable=W0603
+"""
+Cryptocurrency Exchanges support
+"""
+import asyncio
+import inspect
+import logging
+from copy import deepcopy
+from datetime import datetime, timezone
+from math import ceil, floor
+from random import randint
+from typing import Any, Dict, List, Optional, Tuple
+
+import arrow
+import ccxt
+import ccxt.async_support as ccxt_async
+from pandas import DataFrame
+
+from freqtrade import (DependencyException, InvalidOrderException,
+                       OperationalException, TemporaryError, constants)
+from freqtrade.data.converter import parse_ticker_dataframe
+from freqtrade.misc import deep_merge_dicts
+
+logger = logging.getLogger(__name__)
+
+
+API_RETRY_COUNT = 4
+BAD_EXCHANGES = {
+    "bitmex": "Various reasons",
+    "bitstamp": "Does not provide history. "
+                "Details in https://github.com/freqtrade/freqtrade/issues/1983",
+    }
+
+
+def retrier_async(f):
+    async def wrapper(*args, **kwargs):
+        count = kwargs.pop('count', API_RETRY_COUNT)
+        try:
+            return await f(*args, **kwargs)
+        except (TemporaryError, DependencyException) as ex:
+            logger.warning('%s() returned exception: "%s"', f.__name__, ex)
+            if count > 0:
+                count -= 1
+                kwargs.update({'count': count})
+                logger.warning('retrying %s() still for %s times', f.__name__, count)
+                return await wrapper(*args, **kwargs)
+            else:
+                logger.warning('Giving up retrying: %s()', f.__name__)
+                raise ex
+    return wrapper
+
+
+def retrier(f):
+    def wrapper(*args, **kwargs):
+        count = kwargs.pop('count', API_RETRY_COUNT)
+        try:
+            return f(*args, **kwargs)
+        except (TemporaryError, DependencyException) as ex:
+            logger.warning('%s() returned exception: "%s"', f.__name__, ex)
+            if count > 0:
+                count -= 1
+                kwargs.update({'count': count})
+                logger.warning('retrying %s() still for %s times', f.__name__, count)
+                return wrapper(*args, **kwargs)
+            else:
+                logger.warning('Giving up retrying: %s()', f.__name__)
+                raise ex
+    return wrapper
+
+
+class Exchange(object):
+
+    _config: Dict = {}
+    _params: Dict = {}
+
+    # Dict to specify which options each exchange implements
+    # This defines defaults, which can be selectively overridden by subclasses using _ft_has
+    # or by specifying them in the configuration.
+    _ft_has_default: Dict = {
+        "stoploss_on_exchange": False,
+        "order_time_in_force": ["gtc"],
+        "ohlcv_candle_limit": 500,
+        "ohlcv_partial_candle": True,
+    }
+    _ft_has: Dict = {}
+
+    def __init__(self, config: dict) -> None:
+        """
+        Initializes this module with the given config,
+        it does basic validation whether the specified exchange and pairs are valid.
+        :return: None
+        """
+        self._api: ccxt.Exchange = None
+        self._api_async: ccxt_async.Exchange = None
+
+        self._config.update(config)
+
+        self._cached_ticker: Dict[str, Any] = {}
+
+        # Holds last candle refreshed time of each pair
+        self._pairs_last_refresh_time: Dict[Tuple[str, str], int] = {}
+        # Timestamp of last markets refresh
+        self._last_markets_refresh: int = 0
+
+        # Holds candles
+        self._klines: Dict[Tuple[str, str], DataFrame] = {}
+
+        # Holds all open sell orders for dry_run
+        self._dry_run_open_orders: Dict[str, Any] = {}
+
+        if config['dry_run']:
+            logger.info('Instance is running with dry_run enabled')
+
+        exchange_config = config['exchange']
+
+        # Deep merge ft_has with default ft_has options
+        self._ft_has = deep_merge_dicts(self._ft_has, deepcopy(self._ft_has_default))
+        if exchange_config.get("_ft_has_params"):
+            self._ft_has = deep_merge_dicts(exchange_config.get("_ft_has_params"),
+                                            self._ft_has)
+            logger.info("Overriding exchange._ft_has with config params, result: %s", self._ft_has)
+
+        # Assign this directly for easy access
+        self._ohlcv_candle_limit = self._ft_has['ohlcv_candle_limit']
+        self._ohlcv_partial_candle = self._ft_has['ohlcv_partial_candle']
+
+        # Initialize ccxt objects
+        self._api = self._init_ccxt(
+            exchange_config, ccxt_kwargs=exchange_config.get('ccxt_config'))
+        self._api_async = self._init_ccxt(
+            exchange_config, ccxt_async, ccxt_kwargs=exchange_config.get('ccxt_async_config'))
+
+        logger.info('Using Exchange "%s"', self.name)
+
+        # Converts the interval provided in minutes in config to seconds
+        self.markets_refresh_interval: int = exchange_config.get(
+            "markets_refresh_interval", 60) * 60
+        # Initial markets load
+        self._load_markets()
+
+        # Check if all pairs are available
+        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', {}))
+
+        if config.get('ticker_interval'):
+            # Check if timeframe is available
+            self.validate_timeframes(config['ticker_interval'])
+
+    def __del__(self):
+        """
+        Destructor - clean up async stuff
+        """
+        logger.debug("Exchange object destroyed, closing async loop")
+        if self._api_async and inspect.iscoroutinefunction(self._api_async.close):
+            asyncio.get_event_loop().run_until_complete(self._api_async.close())
+
+    def _init_ccxt(self, exchange_config: dict, ccxt_module=ccxt,
+                   ccxt_kwargs: dict = None) -> ccxt.Exchange:
+        """
+        Initialize ccxt with given config and return valid
+        ccxt instance.
+        """
+        # Find matching class for the given exchange name
+        name = exchange_config['name']
+
+        if not is_exchange_available(name, ccxt_module):
+            raise OperationalException(f'Exchange {name} is not supported by ccxt')
+
+        ex_config = {
+            'apiKey': exchange_config.get('key'),
+            'secret': exchange_config.get('secret'),
+            'password': exchange_config.get('password'),
+            'uid': exchange_config.get('uid', ''),
+        }
+        if ccxt_kwargs:
+            logger.info('Applying additional ccxt config: %s', ccxt_kwargs)
+            ex_config.update(ccxt_kwargs)
+        try:
+
+            api = getattr(ccxt_module, name.lower())(ex_config)
+        except (KeyError, AttributeError) as e:
+            raise OperationalException(f'Exchange {name} is not supported') from e
+        except ccxt.BaseError as e:
+            raise OperationalException(f"Initialization of ccxt failed. Reason: {e}") from e
+
+        self.set_sandbox(api, exchange_config, name)
+
+        return api
+
+    @property
+    def name(self) -> str:
+        """exchange Name (from ccxt)"""
+        return self._api.name
+
+    @property
+    def id(self) -> str:
+        """exchange ccxt id"""
+        return self._api.id
+
+    @property
+    def markets(self) -> Dict:
+        """exchange ccxt markets"""
+        if not self._api.markets:
+            logger.warning("Markets were not loaded. Loading them now..")
+            self._load_markets()
+        return self._api.markets
+
+    def klines(self, pair_interval: Tuple[str, str], copy=True) -> DataFrame:
+        if pair_interval in self._klines:
+            return self._klines[pair_interval].copy() if copy else self._klines[pair_interval]
+        else:
+            return DataFrame()
+
+    def set_sandbox(self, api, exchange_config: dict, name: str):
+        if exchange_config.get('sandbox'):
+            if api.urls.get('test'):
+                api.urls['api'] = api.urls['test']
+                logger.info("Enabled Sandbox API on %s", name)
+            else:
+                logger.warning(name, "No Sandbox URL in CCXT, exiting. "
+                                     "Please check your config.json")
+                raise OperationalException(f'Exchange {name} does not provide a sandbox api')
+
+    def _load_async_markets(self, reload=False) -> None:
+        try:
+            if self._api_async:
+                asyncio.get_event_loop().run_until_complete(
+                    self._api_async.load_markets(reload=reload))
+
+        except ccxt.BaseError as e:
+            logger.warning('Could not load async markets. Reason: %s', e)
+            return
+
+    def _load_markets(self) -> None:
+        """ Initialize markets both sync and async """
+        try:
+            self._api.load_markets()
+            self._load_async_markets()
+            self._last_markets_refresh = arrow.utcnow().timestamp
+        except ccxt.BaseError as e:
+            logger.warning('Unable to initialize markets. Reason: %s', e)
+
+    def _reload_markets(self) -> None:
+        """Reload markets both sync and async, if refresh interval has passed"""
+        # 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):
+            return None
+        logger.debug("Performing scheduled market reload..")
+        try:
+            self._api.load_markets(reload=True)
+            self._last_markets_refresh = arrow.utcnow().timestamp
+        except ccxt.BaseError:
+            logger.exception("Could not reload markets.")
+
+    def validate_pairs(self, pairs: List[str]) -> None:
+        """
+        Checks if all given pairs are tradable on the current exchange.
+        Raises OperationalException if one pair is not available.
+        :param pairs: list of pairs
+        :return: None
+        """
+
+        if not self.markets:
+            logger.warning('Unable to validate pairs (assuming they are correct).')
+            return
+
+        for pair in pairs:
+            # Note: ccxt has BaseCurrency/QuoteCurrency format for pairs
+            # TODO: add a support for having coins in BTC/USDT format
+            if self.markets and pair not in self.markets:
+                raise OperationalException(
+                    f'Pair {pair} is not available on {self.name}. '
+                    f'Please remove {pair} from your whitelist.')
+            elif self.markets[pair].get('info', {}).get('IsRestricted', False):
+                # Warn users about restricted pairs in whitelist.
+                # We cannot determine reliably if Users are affected.
+                logger.warning(f"Pair {pair} is restricted for some users on this exchange."
+                               f"Please check if you are impacted by this restriction "
+                               f"on the exchange and eventually remove {pair} from your whitelist.")
+
+    def get_valid_pair_combination(self, curr_1, curr_2) -> str:
+        """
+        Get valid pair combination of curr_1 and curr_2 by trying both combinations.
+        """
+        for pair in [f"{curr_1}/{curr_2}", f"{curr_2}/{curr_1}"]:
+            if pair in self.markets and self.markets[pair].get('active'):
+                return pair
+        raise DependencyException(f"Could not combine {curr_1} and {curr_2} to get a valid pair.")
+
+    def validate_timeframes(self, timeframe: List[str]) -> None:
+        """
+        Checks if ticker interval from config is a supported timeframe on the exchange
+        """
+        if not hasattr(self._api, "timeframes") or self._api.timeframes is None:
+            # If timeframes attribute is missing (or is None), the exchange probably
+            # has no fetchOHLCV method.
+            # Therefore we also show that.
+            raise OperationalException(
+                f"The ccxt library does not provide the list of timeframes "
+                f"for the exchange \"{self.name}\" and this exchange "
+                f"is therefore not supported. ccxt fetchOHLCV: {self.exchange_has('fetchOHLCV')}")
+
+        timeframes = self._api.timeframes
+        if timeframe not in timeframes:
+            raise OperationalException(
+                f'Invalid ticker {timeframe}, this Exchange supports {timeframes}')
+
+    def validate_ordertypes(self, order_types: Dict) -> None:
+        """
+        Checks if order-types configured in strategy/config are supported
+        """
+        if any(v == 'market' for k, v in order_types.items()):
+            if not self.exchange_has('createMarketOrder'):
+                raise OperationalException(
+                    f'Exchange {self.name} does not support market orders.')
+
+        if (order_types.get("stoploss_on_exchange")
+                and not self._ft_has.get("stoploss_on_exchange", False)):
+            raise OperationalException(
+                'On exchange stoploss is not supported for %s.' % self.name
+            )
+
+    def validate_order_time_in_force(self, order_time_in_force: Dict) -> None:
+        """
+        Checks if order time in force configured in strategy/config are supported
+        """
+        if any(v not in self._ft_has["order_time_in_force"]
+               for k, v in order_time_in_force.items()):
+            raise OperationalException(
+                f'Time in force policies are not supported for {self.name} yet.')
+
+    def exchange_has(self, endpoint: str) -> bool:
+        """
+        Checks if exchange implements a specific API endpoint.
+        Wrapper around ccxt 'has' attribute
+        :param endpoint: Name of endpoint (e.g. 'fetchOHLCV', 'fetchTickers')
+        :return: bool
+        """
+        return endpoint in self._api.has and self._api.has[endpoint]
+
+    def symbol_amount_prec(self, pair, amount: float):
+        '''
+        Returns the amount to buy or sell to a precision the Exchange accepts
+        Rounded down
+        '''
+        if self.markets[pair]['precision']['amount']:
+            symbol_prec = self.markets[pair]['precision']['amount']
+            big_amount = amount * pow(10, symbol_prec)
+            amount = floor(big_amount) / pow(10, symbol_prec)
+        return amount
+
+    def symbol_price_prec(self, pair, price: float):
+        '''
+        Returns the price buying or selling with to the precision the Exchange accepts
+        Rounds up
+        '''
+        if self.markets[pair]['precision']['price']:
+            symbol_prec = self.markets[pair]['precision']['price']
+            big_price = price * pow(10, symbol_prec)
+            price = ceil(big_price) / pow(10, symbol_prec)
+        return price
+
+    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)}'
+        dry_order = {  # TODO: additional entry should be added for stoploss limit
+            "id": order_id,
+            'pair': pair,
+            'price': rate,
+            'amount': amount,
+            "cost": amount * rate,
+            'type': ordertype,
+            'side': side,
+            'remaining': amount,
+            'datetime': arrow.utcnow().isoformat(),
+            'status': "closed" if ordertype == "market" else "open",
+            'fee': None,
+            "info": {}
+        }
+        self._store_dry_order(dry_order)
+        return dry_order
+
+    def _store_dry_order(self, dry_order: Dict) -> None:
+        closed_order = dry_order.copy()
+        if closed_order["type"] in ["market", "limit"]:
+            closed_order.update({
+                "status": "closed",
+                "filled": closed_order["amount"],
+                "remaining": 0
+                })
+        self._dry_run_open_orders[closed_order["id"]] = closed_order
+
+    def create_order(self, pair: str, ordertype: str, side: str, amount: float,
+                     rate: float, params: Dict = {}) -> Dict:
+        try:
+            # Set the precision for amount and price(rate) as accepted by the exchange
+            amount = self.symbol_amount_prec(pair, amount)
+            needs_price = (ordertype != 'market'
+                           or self._api.options.get("createMarketBuyOrderRequiresPrice", False))
+            rate = self.symbol_price_prec(pair, rate) if needs_price else None
+
+            return self._api.create_order(pair, ordertype, side,
+                                          amount, rate, params)
+
+        except ccxt.InsufficientFunds as e:
+            raise DependencyException(
+                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
+        except ccxt.InvalidOrder as e:
+            raise DependencyException(
+                f'Could not create {ordertype} {side} order on market {pair}.'
+                f'Tried to {side} amount {amount} at rate {rate}.'
+                f'Message: {e}') from e
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not place {side} order due to {e.__class__.__name__}. Message: {e}') from e
+        except ccxt.BaseError as e:
+            raise OperationalException(e) from e
+
+    def buy(self, pair: str, ordertype: str, amount: float,
+            rate: float, time_in_force) -> Dict:
+
+        if self._config['dry_run']:
+            dry_order = self.dry_run_order(pair, ordertype, "buy", amount, rate)
+            return dry_order
+
+        params = self._params.copy()
+        if time_in_force != 'gtc' and ordertype != 'market':
+            params.update({'timeInForce': time_in_force})
+
+        return self.create_order(pair, ordertype, 'buy', amount, rate, params)
+
+    def sell(self, pair: str, ordertype: str, amount: float,
+             rate: float, time_in_force='gtc') -> Dict:
+
+        if self._config['dry_run']:
+            dry_order = self.dry_run_order(pair, ordertype, "sell", amount, rate)
+            return dry_order
+
+        params = self._params.copy()
+        if time_in_force != 'gtc' and ordertype != 'market':
+            params.update({'timeInForce': time_in_force})
+
+        return self.create_order(pair, ordertype, 'sell', amount, rate, params)
+
+    def stoploss_limit(self, pair: str, amount: float, stop_price: float, rate: float) -> Dict:
+        """
+        creates a stoploss limit order.
+        NOTICE: it is not supported by all exchanges. only binance is tested for now.
+        TODO: implementation maybe needs to be moved to the binance subclass
+        """
+        ordertype = "stop_loss_limit"
+
+        stop_price = self.symbol_price_prec(pair, stop_price)
+
+        # Ensure rate is less than stop price
+        if stop_price <= rate:
+            raise OperationalException(
+                'In stoploss limit order, stop price should be more than limit price')
+
+        if self._config['dry_run']:
+            dry_order = self.dry_run_order(
+                pair, ordertype, "sell", amount, stop_price)
+            return dry_order
+
+        params = self._params.copy()
+        params.update({'stopPrice': stop_price})
+
+        order = self.create_order(pair, ordertype, 'sell', amount, rate, params)
+        logger.info('stoploss limit order added for %s. '
+                    'stop price: %s. limit: %s', pair, stop_price, rate)
+        return order
+
+    @retrier
+    def get_balance(self, currency: str) -> float:
+        if self._config['dry_run']:
+            return constants.DRY_RUN_WALLET
+
+        # ccxt exception is already handled by get_balances
+        balances = self.get_balances()
+        balance = balances.get(currency)
+        if balance is None:
+            raise TemporaryError(
+                f'Could not get {currency} balance due to malformed exchange response: {balances}')
+        return balance['free']
+
+    @retrier
+    def get_balances(self) -> dict:
+        if self._config['dry_run']:
+            return {}
+
+        try:
+            balances = self._api.fetch_balance()
+            # Remove additional info from ccxt results
+            balances.pop("info", None)
+            balances.pop("free", None)
+            balances.pop("total", None)
+            balances.pop("used", None)
+
+            return balances
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not get balance due to {e.__class__.__name__}. Message: {e}') from e
+        except ccxt.BaseError as e:
+            raise OperationalException(e) from e
+
+    @retrier
+    def get_tickers(self) -> Dict:
+        try:
+            return self._api.fetch_tickers()
+        except ccxt.NotSupported as e:
+            raise OperationalException(
+                f'Exchange {self._api.name} does not support fetching tickers in batch.'
+                f'Message: {e}') from e
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not load tickers due to {e.__class__.__name__}. Message: {e}') from e
+        except ccxt.BaseError as e:
+            raise OperationalException(e) from e
+
+    @retrier
+    def get_ticker(self, pair: str, refresh: Optional[bool] = True) -> dict:
+        if refresh or pair not in self._cached_ticker.keys():
+            try:
+                if pair not in self._api.markets or not self._api.markets[pair].get('active'):
+                    raise DependencyException(f"Pair {pair} not available")
+                data = self._api.fetch_ticker(pair)
+                try:
+                    self._cached_ticker[pair] = {
+                        'bid': float(data['bid']),
+                        'ask': float(data['ask']),
+                    }
+                except KeyError:
+                    logger.debug("Could not cache ticker data for %s", pair)
+                return data
+            except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+                raise TemporaryError(
+                    f'Could not load ticker due to {e.__class__.__name__}. Message: {e}') from e
+            except ccxt.BaseError as e:
+                raise OperationalException(e) from e
+        else:
+            logger.info("returning cached ticker-data for %s", pair)
+            return self._cached_ticker[pair]
+
+    def get_historic_ohlcv(self, pair: str, ticker_interval: str,
+                           since_ms: int) -> List:
+        """
+        Gets candle history using asyncio and returns the list of candles.
+        Handles all async doing.
+        Async over one pair, assuming we get `_ohlcv_candle_limit` candles per call.
+        :param pair: Pair to download
+        :param ticker_interval: Interval to get
+        :param since_ms: Timestamp in milliseconds to get history from
+        :returns List of tickers
+        """
+        return asyncio.get_event_loop().run_until_complete(
+            self._async_get_historic_ohlcv(pair=pair, ticker_interval=ticker_interval,
+                                           since_ms=since_ms))
+
+    async def _async_get_historic_ohlcv(self, pair: str,
+                                        ticker_interval: str,
+                                        since_ms: int) -> List:
+
+        one_call = timeframe_to_msecs(ticker_interval) * self._ohlcv_candle_limit
+        logger.debug(
+            "one_call: %s msecs (%s)",
+            one_call,
+            arrow.utcnow().shift(seconds=one_call // 1000).humanize(only_distance=True)
+        )
+        input_coroutines = [self._async_get_candle_history(
+            pair, ticker_interval, since) for since in
+            range(since_ms, arrow.utcnow().timestamp * 1000, one_call)]
+
+        tickers = await asyncio.gather(*input_coroutines, return_exceptions=True)
+
+        # Combine tickers
+        data: List = []
+        for p, ticker_interval, ticker in tickers:
+            if p == pair:
+                data.extend(ticker)
+        # Sort data again after extending the result - above calls return in "async order"
+        data = sorted(data, key=lambda x: x[0])
+        logger.info("downloaded %s with length %s.", pair, len(data))
+        return data
+
+    def refresh_latest_ohlcv(self, pair_list: List[Tuple[str, str]]) -> List[Tuple[str, List]]:
+        """
+        Refresh in-memory ohlcv asynchronously and set `_klines` with the result
+        Loops asynchronously over pair_list and downloads all pairs async (semi-parallel).
+        :param pair_list: List of 2 element tuples containing pair, interval to refresh
+        :return: Returns a List of ticker-dataframes.
+        """
+        logger.debug("Refreshing ohlcv data for %d pairs", len(pair_list))
+
+        input_coroutines = []
+
+        # Gather coroutines to run
+        for pair, ticker_interval in set(pair_list):
+            if (not ((pair, ticker_interval) in self._klines)
+                    or self._now_is_time_to_refresh(pair, ticker_interval)):
+                input_coroutines.append(self._async_get_candle_history(pair, ticker_interval))
+            else:
+                logger.debug(
+                    "Using cached ohlcv data for pair %s, interval %s ...",
+                    pair, ticker_interval
+                )
+
+        tickers = asyncio.get_event_loop().run_until_complete(
+            asyncio.gather(*input_coroutines, return_exceptions=True))
+
+        # handle caching
+        for res in tickers:
+            if isinstance(res, Exception):
+                logger.warning("Async code raised an exception: %s", res.__class__.__name__)
+                continue
+            pair = res[0]
+            ticker_interval = res[1]
+            ticks = res[2]
+            # keeping last candle time as last refreshed time of the pair
+            if ticks:
+                self._pairs_last_refresh_time[(pair, ticker_interval)] = ticks[-1][0] // 1000
+            # keeping parsed dataframe in cache
+            self._klines[(pair, ticker_interval)] = parse_ticker_dataframe(
+                ticks, ticker_interval, pair=pair, fill_missing=True,
+                drop_incomplete=self._ohlcv_partial_candle)
+        return tickers
+
+    def _now_is_time_to_refresh(self, pair: str, ticker_interval: str) -> bool:
+        # Calculating ticker interval in seconds
+        interval_in_sec = timeframe_to_seconds(ticker_interval)
+
+        return not ((self._pairs_last_refresh_time.get((pair, ticker_interval), 0)
+                     + interval_in_sec) >= arrow.utcnow().timestamp)
+
+    @retrier_async
+    async def _async_get_candle_history(self, pair: str, ticker_interval: str,
+                                        since_ms: Optional[int] = None) -> Tuple[str, str, List]:
+        """
+        Asynchronously gets candle histories using fetch_ohlcv
+        returns tuple: (pair, ticker_interval, ohlcv_list)
+        """
+        try:
+            # fetch ohlcv asynchronously
+            s = '(' + arrow.get(since_ms // 1000).isoformat() + ') ' if since_ms is not None else ''
+            logger.debug(
+                "Fetching pair %s, interval %s, since %s %s...",
+                pair, ticker_interval, since_ms, s
+            )
+
+            data = await self._api_async.fetch_ohlcv(pair, timeframe=ticker_interval,
+                                                     since=since_ms)
+
+            # Because some exchange sort Tickers ASC and other DESC.
+            # Ex: Bittrex returns a list of tickers ASC (oldest first, newest last)
+            # when GDAX returns a list of tickers DESC (newest first, oldest last)
+            # Only sort if necessary to save computing time
+            try:
+                if data and data[0][0] > data[-1][0]:
+                    data = sorted(data, key=lambda x: x[0])
+            except IndexError:
+                logger.exception("Error loading %s. Result was %s.", pair, data)
+                return pair, ticker_interval, []
+            logger.debug("Done fetching pair %s, interval %s ...", pair, ticker_interval)
+            return pair, ticker_interval, data
+
+        except ccxt.NotSupported as e:
+            raise OperationalException(
+                f'Exchange {self._api.name} does not support fetching historical candlestick data.'
+                f'Message: {e}') from e
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(f'Could not load ticker history due to {e.__class__.__name__}. '
+                                 f'Message: {e}') from e
+        except ccxt.BaseError as e:
+            raise OperationalException(f'Could not fetch ticker data. Msg: {e}') from e
+
+    @retrier
+    def cancel_order(self, order_id: str, pair: str) -> None:
+        if self._config['dry_run']:
+            return
+
+        try:
+            return self._api.cancel_order(order_id, pair)
+        except ccxt.InvalidOrder as e:
+            raise InvalidOrderException(
+                f'Could not cancel order. Message: {e}') from e
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not cancel order due to {e.__class__.__name__}. Message: {e}') from e
+        except ccxt.BaseError as e:
+            raise OperationalException(e) from e
+
+    @retrier
+    def get_order(self, order_id: str, pair: str) -> Dict:
+        if self._config['dry_run']:
+            try:
+                order = self._dry_run_open_orders[order_id]
+                return order
+            except KeyError as e:
+                # Gracefully handle errors with dry-run orders.
+                raise InvalidOrderException(
+                    f'Tried to get an invalid dry-run-order (id: {order_id}). Message: {e}') from e
+        try:
+            return self._api.fetch_order(order_id, pair)
+        except ccxt.InvalidOrder as e:
+            raise InvalidOrderException(
+                f'Tried to get an invalid order (id: {order_id}). Message: {e}') from e
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not get order due to {e.__class__.__name__}. Message: {e}') from e
+        except ccxt.BaseError as e:
+            raise OperationalException(e) from e
+
+    @retrier
+    def get_order_book(self, pair: str, limit: int = 100) -> dict:
+        """
+        get order book level 2 from exchange
+
+        Notes:
+        20180619: bittrex doesnt support limits -.-
+        """
+        try:
+
+            return self._api.fetch_l2_order_book(pair, limit)
+        except ccxt.NotSupported as e:
+            raise OperationalException(
+                f'Exchange {self._api.name} does not support fetching order book.'
+                f'Message: {e}') from e
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not get order book due to {e.__class__.__name__}. Message: {e}') from e
+        except ccxt.BaseError as e:
+            raise OperationalException(e) from e
+
+    @retrier
+    def get_trades_for_order(self, order_id: str, pair: str, since: datetime) -> List:
+        if self._config['dry_run']:
+            return []
+        if not self.exchange_has('fetchMyTrades'):
+            return []
+        try:
+            # Allow 5s offset to catch slight time offsets (discovered in #1185)
+            # since needs to be int in milliseconds
+            my_trades = self._api.fetch_my_trades(pair, int((since.timestamp() - 5) * 1000))
+            matched_trades = [trade for trade in my_trades if trade['order'] == order_id]
+
+            return matched_trades
+
+        except ccxt.NetworkError as e:
+            raise TemporaryError(
+                f'Could not get trades due to networking error. Message: {e}') from e
+        except ccxt.BaseError as e:
+            raise OperationalException(e) from e
+
+    @retrier
+    def get_fee(self, symbol='ETH/BTC', type='', side='', amount=1,
+                price=1, taker_or_maker='maker') -> float:
+        try:
+            # validate that markets are loaded before trying to get fee
+            if self._api.markets is None or len(self._api.markets) == 0:
+                self._api.load_markets()
+
+            return self._api.calculate_fee(symbol=symbol, type=type, side=side, amount=amount,
+                                           price=price, takerOrMaker=taker_or_maker)['rate']
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not get fee info due to {e.__class__.__name__}. Message: {e}') from e
+        except ccxt.BaseError as e:
+            raise OperationalException(e) from e
+
+
+def is_exchange_bad(exchange_name: str) -> bool:
+    return exchange_name in BAD_EXCHANGES
+
+
+def get_exchange_bad_reason(exchange_name: str) -> str:
+    return BAD_EXCHANGES.get(exchange_name, "")
+
+
+def is_exchange_available(exchange_name: str, ccxt_module=None) -> bool:
+    return exchange_name in available_exchanges(ccxt_module)
+
+
+def is_exchange_officially_supported(exchange_name: str) -> bool:
+    return exchange_name in ['bittrex', 'binance']
+
+
+def available_exchanges(ccxt_module=None) -> List[str]:
+    return ccxt_module.exchanges if ccxt_module is not None else ccxt.exchanges
+
+
+def timeframe_to_seconds(ticker_interval: str) -> int:
+    """
+    Translates the timeframe interval value written in the human readable
+    form ('1m', '5m', '1h', '1d', '1w', etc.) to the number
+    of seconds for one timeframe interval.
+    """
+    return ccxt.Exchange.parse_timeframe(ticker_interval)
+
+
+def timeframe_to_minutes(ticker_interval: str) -> int:
+    """
+    Same as timeframe_to_seconds, but returns minutes.
+    """
+    return ccxt.Exchange.parse_timeframe(ticker_interval) // 60
+
+
+def timeframe_to_msecs(ticker_interval: str) -> int:
+    """
+    Same as timeframe_to_seconds, but returns milliseconds.
+    """
+    return ccxt.Exchange.parse_timeframe(ticker_interval) * 1000
+
+
+def timeframe_to_prev_date(timeframe: str, date: datetime = None) -> datetime:
+    """
+    Use Timeframe and determine last possible candle.
+    :param timeframe: timeframe in string format (e.g. "5m")
+    :param date: date to use. Defaults to utcnow()
+    :returns: date of previous candle (with utc timezone)
+    """
+    if not date:
+        date = datetime.now(timezone.utc)
+    timeframe_secs = timeframe_to_seconds(timeframe)
+    # Get offset based on timerame_secs
+    offset = date.timestamp() % timeframe_secs
+    # Subtract seconds passed since last offset
+    new_timestamp = date.timestamp() - offset
+    return datetime.fromtimestamp(new_timestamp, tz=timezone.utc)
+
+
+def timeframe_to_next_date(timeframe: str, date: datetime = None) -> datetime:
+    """
+    Use Timeframe and determine next candle.
+    :param timeframe: timeframe in string format (e.g. "5m")
+    :param date: date to use. Defaults to utcnow()
+    :returns: date of next candle (with utc timezone)
+    """
+    prevdate = timeframe_to_prev_date(timeframe, date)
+    timeframe_secs = timeframe_to_seconds(timeframe)
+
+    # Add one interval to previous candle
+    new_timestamp = prevdate.timestamp() + timeframe_secs
+    return datetime.fromtimestamp(new_timestamp, tz=timezone.utc)

freqtrade/exchange/kraken.py

@@ -0,0 +1,12 @@
+""" Kraken exchange subclass """
+import logging
+from typing import Dict
+
+from freqtrade.exchange import Exchange
+
+logger = logging.getLogger(__name__)
+
+
+class Kraken(Exchange):
+
+    _params: Dict = {"trading_agreement": "agree"}

freqtrade/loggers.py

@@ -0,0 +1,50 @@
+import logging
+import sys
+
+from logging.handlers import RotatingFileHandler
+from typing import Any, Dict, List
+
+
+logger = logging.getLogger(__name__)
+
+
+def _set_loggers(verbosity: int = 0) -> None:
+    """
+    Set the logging level for third party libraries
+    :return: None
+    """
+
+    logging.getLogger('requests').setLevel(
+            logging.INFO if verbosity <= 1 else logging.DEBUG
+    )
+    logging.getLogger("urllib3").setLevel(
+            logging.INFO if verbosity <= 1 else logging.DEBUG
+    )
+    logging.getLogger('ccxt.base.exchange').setLevel(
+            logging.INFO if verbosity <= 2 else logging.DEBUG
+    )
+    logging.getLogger('telegram').setLevel(logging.INFO)
+
+
+def setup_logging(config: Dict[str, Any]) -> None:
+    """
+    Process -v/--verbose, --logfile options
+    """
+    # Log level
+    verbosity = config['verbosity']
+
+    # Log to stdout, not stderr
+    log_handlers: List[logging.Handler] = [logging.StreamHandler(sys.stdout)]
+
+    if config.get('logfile'):
+        log_handlers.append(RotatingFileHandler(config['logfile'],
+                                                maxBytes=1024 * 1024,  # 1Mb
+                                                backupCount=10))
+
+    logging.basicConfig(
+        level=logging.INFO if verbosity < 1 else logging.DEBUG,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        handlers=log_handlers
+    )
+    _set_loggers(verbosity)
+    logger.info('Verbosity set to %s', verbosity)

freqtrade/main.py

@@ -3,87 +3,66 @@
 Main Freqtrade bot script.
 Read the documentation to know what cli arguments you need.
 """
-import logging
+
 import sys
+# check min. python version
+if sys.version_info < (3, 6):
+    sys.exit("Freqtrade requires Python version >= 3.6")
+
+# flake8: noqa E402
+import logging
 from argparse import Namespace
-from typing import List
+from typing import Any, List
 
 from freqtrade import OperationalException
-from freqtrade.arguments import Arguments
+from freqtrade.configuration import Arguments
-from freqtrade.configuration import Configuration, set_loggers
+from freqtrade.worker import Worker
-from freqtrade.freqtradebot import FreqtradeBot
+
-from freqtrade.state import State
-from freqtrade.rpc import RPCMessageType
 
 logger = logging.getLogger('freqtrade')
 
 
-def main(sysargv: List[str]) -> None:
+def main(sysargv: List[str] = None) -> None:
     """
     This function will initiate the bot and start the trading loop.
     :return: None
     """
-    arguments = Arguments(
-        sysargv,
-        'Simple High Frequency Trading Bot for crypto currencies'
-    )
-    args = arguments.get_parsed_arg()
 
-    # A subcommand has been issued.
+    return_code: Any = 1
-    # Means if Backtesting or Hyperopt have been called we exit the bot
+    worker = None
-    if hasattr(args, 'func'):
-        args.func(args)
-        return
-
-    freqtrade = None
-    return_code = 1
     try:
-        # Load and validate configuration
+        arguments = Arguments(
-        config = Configuration(args).get_config()
+            sysargv,
+            'Free, open source crypto trading bot'
+        )
+        args: Namespace = arguments.get_parsed_arg()
 
-        # Init the bot
+        # A subcommand has been issued.
-        freqtrade = FreqtradeBot(config)
+        # Means if Backtesting or Hyperopt have been called we exit the bot
-
+        if hasattr(args, 'func'):
-        state = None
+            args.func(args)
-        while 1:
+            # TODO: fetch return_code as returned by the command function here
-            state = freqtrade.worker(old_state=state)
+            return_code = 0
-            if state == State.RELOAD_CONF:
+        else:
-                freqtrade = reconfigure(freqtrade, args)
+            # Load and run worker
+            worker = Worker(args)
+            worker.run()
 
+    except SystemExit as e:
+        return_code = e
     except KeyboardInterrupt:
         logger.info('SIGINT received, aborting ...')
         return_code = 0
     except OperationalException as e:
         logger.error(str(e))
         return_code = 2
-    except BaseException:
+    except Exception:
         logger.exception('Fatal exception!')
     finally:
-        if freqtrade:
+        if worker:
-            freqtrade.rpc.send_msg({
+            worker.exit()
-                'type': RPCMessageType.STATUS_NOTIFICATION,
-                'status': 'process died'
-            })
-            freqtrade.cleanup()
         sys.exit(return_code)
 
 
-def reconfigure(freqtrade: FreqtradeBot, args: Namespace) -> FreqtradeBot:
-    """
-    Cleans up current instance, reloads the configuration and returns the new instance
-    """
-    # Clean up current modules
-    freqtrade.cleanup()
-
-    # Create new instance
-    freqtrade = FreqtradeBot(Configuration(args).get_config())
-    freqtrade.rpc.send_msg({
-        'type': RPCMessageType.STATUS_NOTIFICATION,
-        'status': 'config reloaded'
-    })
-    return freqtrade
-
-
 if __name__ == '__main__':
-    set_loggers()
+    main()
-    main(sys.argv[1:])

freqtrade/misc.py

@@ -1,16 +1,15 @@
 """
 Various tool function for Freqtrade and scripts
 """
-
 import gzip
-import json
 import logging
 import re
 from datetime import datetime
-from typing import Dict
+from pathlib import Path
+from typing.io import IO
 
 import numpy as np
-from pandas import DataFrame
+import rapidjson
 
 logger = logging.getLogger(__name__)
 
@@ -38,49 +37,55 @@ def datesarray_to_datetimearray(dates: np.ndarray) -> np.ndarray:
     An numpy-array of datetimes
     :return: numpy-array of datetime
     """
-    times = []
+    return dates.dt.to_pydatetime()
-    dates = dates.astype(datetime)
-    for index in range(0, dates.size):
-        date = dates[index].to_pydatetime()
-        times.append(date)
-    return np.array(times)
 
 
-def common_datearray(dfs: Dict[str, DataFrame]) -> np.ndarray:
+def file_dump_json(filename: Path, data, is_zip=False) -> None:
-    """
-    Return dates from Dataframe
-    :param dfs: Dict with format pair: pair_data
-    :return: List of dates
-    """
-    alldates = {}
-    for pair, pair_data in dfs.items():
-        dates = datesarray_to_datetimearray(pair_data['date'])
-        for date in dates:
-            alldates[date] = 1
-    lst = []
-    for date, _ in alldates.items():
-        lst.append(date)
-    arr = np.array(lst)
-    return np.sort(arr, axis=0)
-
-
-def file_dump_json(filename, data, is_zip=False) -> None:
     """
     Dump JSON data into a file
     :param filename: file to create
     :param data: JSON Data to save
     :return:
     """
-    print(f'dumping json to "{filename}"')
+    logger.info(f'dumping json to "{filename}"')
 
     if is_zip:
-        if not filename.endswith('.gz'):
+        if filename.suffix != '.gz':
-            filename = filename + '.gz'
+            filename = filename.with_suffix('.gz')
         with gzip.open(filename, 'w') as fp:
-            json.dump(data, fp, default=str)
+            rapidjson.dump(data, fp, default=str, number_mode=rapidjson.NM_NATIVE)
     else:
         with open(filename, 'w') as fp:
-            json.dump(data, fp, default=str)
+            rapidjson.dump(data, fp, default=str, number_mode=rapidjson.NM_NATIVE)
+
+    logger.debug(f'done json to "{filename}"')
+
+
+def json_load(datafile: IO):
+    """
+    load data with rapidjson
+    Use this to have a consistent experience,
+    sete number_mode to "NM_NATIVE" for greatest speed
+    """
+    return rapidjson.load(datafile, number_mode=rapidjson.NM_NATIVE)
+
+
+def file_load_json(file):
+
+    gzipfile = file.with_suffix(file.suffix + '.gz')
+
+    # Try gzip file first, otherwise regular json file.
+    if gzipfile.is_file():
+        logger.debug('Loading ticker data from file %s', gzipfile)
+        with gzip.open(gzipfile) as tickerdata:
+            pairdata = json_load(tickerdata)
+    elif file.is_file():
+        logger.debug('Loading ticker data from file %s', file)
+        with open(file) as tickerdata:
+            pairdata = json_load(tickerdata)
+    else:
+        return None
+    return pairdata
 
 
 def format_ms_time(date: int) -> str:
@@ -89,3 +94,23 @@ def format_ms_time(date: int) -> str:
     : epoch-string in ms
     """
     return datetime.fromtimestamp(date/1000.0).strftime('%Y-%m-%dT%H:%M:%S')
+
+
+def deep_merge_dicts(source, destination):
+    """
+    Values from Source override destination, destination is returned (and modified!!)
+    Sample:
+    >>> a = { 'first' : { 'rows' : { 'pass' : 'dog', 'number' : '1' } } }
+    >>> b = { 'first' : { 'rows' : { 'fail' : 'cat', 'number' : '5' } } }
+    >>> merge(b, a) == { 'first' : { 'rows' : { 'pass' : 'dog', 'fail' : 'cat', 'number' : '5' } } }
+    True
+    """
+    for key, value in source.items():
+        if isinstance(value, dict):
+            # get node or create one
+            node = destination.setdefault(key, {})
+            deep_merge_dicts(value, node)
+        else:
+            destination[key] = value
+
+    return destination

freqtrade/optimize/__init__.py

@@ -1,49 +1,111 @@
-# pragma pylint: disable=missing-docstring
-
 import logging
-from datetime import datetime
+from argparse import Namespace
-from typing import Dict, Tuple
+from typing import Any, Dict
-import operator
 
-import arrow
+from filelock import FileLock, Timeout
-from pandas import DataFrame
+
+from freqtrade import DependencyException, constants
+from freqtrade.state import RunMode
+from freqtrade.utils import setup_utils_configuration
 
-from freqtrade.optimize.default_hyperopt import DefaultHyperOpts  # noqa: F401
 
 logger = logging.getLogger(__name__)
 
 
-def get_timeframe(data: Dict[str, DataFrame]) -> Tuple[arrow.Arrow, arrow.Arrow]:
+def setup_configuration(args: Namespace, method: RunMode) -> Dict[str, Any]:
     """
-    Get the maximum timeframe for the given backtest data
+    Prepare the configuration for the Hyperopt module
-    :param data: dictionary with preprocessed backtesting data
+    :param args: Cli args from Arguments()
-    :return: tuple containing min_date, max_date
+    :return: Configuration
     """
-    timeframe = [
+    config = setup_utils_configuration(args, method)
-        (arrow.get(frame['date'].min()), arrow.get(frame['date'].max()))
+
-        for frame in data.values()
+    if method == RunMode.BACKTEST:
-    ]
+        if config['stake_amount'] == constants.UNLIMITED_STAKE_AMOUNT:
-    return min(timeframe, key=operator.itemgetter(0))[0], \
+            raise DependencyException('stake amount could not be "%s" for backtesting' %
-        max(timeframe, key=operator.itemgetter(1))[1]
+                                      constants.UNLIMITED_STAKE_AMOUNT)
+
+    if method == RunMode.HYPEROPT:
+        # Special cases for Hyperopt
+        if config.get('strategy') and config.get('strategy') != 'DefaultStrategy':
+            logger.error("Please don't use --strategy for hyperopt.")
+            logger.error(
+                "Read the documentation at "
+                "https://github.com/freqtrade/freqtrade/blob/develop/docs/hyperopt.md "
+                "to understand how to configure hyperopt.")
+            raise DependencyException("--strategy configured but not supported for hyperopt")
+
+    return config
 
 
-def validate_backtest_data(data: Dict[str, DataFrame], min_date: datetime,
+def start_backtesting(args: Namespace) -> None:
-                           max_date: datetime, ticker_interval_mins: int) -> bool:
     """
-    Validates preprocessed backtesting data for missing values and shows warnings about it that.
+    Start Backtesting script
+    :param args: Cli args from Arguments()
+    :return: None
+    """
+    # Import here to avoid loading backtesting module when it's not used
+    from freqtrade.optimize.backtesting import Backtesting
 
-    :param data: dictionary with preprocessed backtesting data
+    # Initialize configuration
-    :param min_date: start-date of the data
+    config = setup_configuration(args, RunMode.BACKTEST)
-    :param max_date: end-date of the data
+
-    :param ticker_interval_mins: ticker interval in minutes
+    logger.info('Starting freqtrade in Backtesting mode')
+
+    # Initialize backtesting object
+    backtesting = Backtesting(config)
+    backtesting.start()
+
+
+def start_hyperopt(args: Namespace) -> None:
     """
-    # total difference in minutes / interval-minutes
+    Start hyperopt script
-    expected_frames = int((max_date - min_date).total_seconds() // 60 // ticker_interval_mins)
+    :param args: Cli args from Arguments()
-    found_missing = False
+    :return: None
-    for pair, df in data.items():
+    """
-        dflen = len(df)
+    # Import here to avoid loading hyperopt module when it's not used
-        if dflen < expected_frames:
+    from freqtrade.optimize.hyperopt import Hyperopt
-            found_missing = True
+
-            logger.warning("%s has missing frames: expected %s, got %s, that's %s missing values",
+    # Initialize configuration
-                           pair, expected_frames, dflen, expected_frames - dflen)
+    config = setup_configuration(args, RunMode.HYPEROPT)
-    return found_missing
+
+    logger.info('Starting freqtrade in Hyperopt mode')
+
+    lock = FileLock(Hyperopt.get_lock_filename(config))
+
+    try:
+        with lock.acquire(timeout=1):
+
+            # Remove noisy log messages
+            logging.getLogger('hyperopt.tpe').setLevel(logging.WARNING)
+            logging.getLogger('filelock').setLevel(logging.WARNING)
+
+            # Initialize backtesting object
+            hyperopt = Hyperopt(config)
+            hyperopt.start()
+
+    except Timeout:
+        logger.info("Another running instance of freqtrade Hyperopt detected.")
+        logger.info("Simultaneous execution of multiple Hyperopt commands is not supported. "
+                    "Hyperopt module is resource hungry. Please run your Hyperopts sequentially "
+                    "or on separate machines.")
+        logger.info("Quitting now.")
+        # TODO: return False here in order to help freqtrade to exit
+        # with non-zero exit code...
+        # Same in Edge and Backtesting start() functions.
+
+
+def start_edge(args: Namespace) -> None:
+    """
+    Start Edge script
+    :param args: Cli args from Arguments()
+    :return: None
+    """
+    from freqtrade.optimize.edge_cli import EdgeCli
+    # Initialize configuration
+    config = setup_configuration(args, RunMode.EDGE)
+    logger.info('Starting freqtrade in Edge mode')
+
+    # Initialize Edge object
+    edge_cli = EdgeCli(config)
+    edge_cli.start()

freqtrade/optimize/backtesting.py

@@ -4,25 +4,24 @@
 This module contains the backtesting logic
 """
 import logging
-from argparse import Namespace
 from copy import deepcopy
 from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Any, Dict, List, NamedTuple, Optional
 
 from pandas import DataFrame
-from tabulate import tabulate
 
-import freqtrade.optimize as optimize
+from freqtrade import OperationalException
-from freqtrade import DependencyException, constants
+from freqtrade.configuration import TimeRange
-from freqtrade.arguments import Arguments
-from freqtrade.configuration import Configuration
-from freqtrade.exchange import Exchange
 from freqtrade.data import history
+from freqtrade.data.dataprovider import DataProvider
+from freqtrade.exchange import timeframe_to_minutes
 from freqtrade.misc import file_dump_json
 from freqtrade.persistence import Trade
-from freqtrade.resolvers import StrategyResolver
+from freqtrade.resolvers import ExchangeResolver, StrategyResolver
-from freqtrade.strategy.interface import SellType, IStrategy
+from freqtrade.state import RunMode
+from freqtrade.strategy.interface import IStrategy, SellType
+from tabulate import tabulate
 
 logger = logging.getLogger(__name__)
 
@@ -64,34 +63,44 @@ class Backtesting(object):
         self.config['exchange']['uid'] = ''
         self.config['dry_run'] = True
         self.strategylist: List[IStrategy] = []
+
+        self.exchange = ExchangeResolver(self.config['exchange']['name'], self.config).exchange
+        self.fee = self.exchange.get_fee()
+
+        if self.config.get('runmode') != RunMode.HYPEROPT:
+            self.dataprovider = DataProvider(self.config, self.exchange)
+            IStrategy.dp = self.dataprovider
+
         if self.config.get('strategy_list', None):
-            # Force one interval
-            self.ticker_interval = str(self.config.get('ticker_interval'))
-            self.ticker_interval_mins = constants.TICKER_INTERVAL_MINUTES[self.ticker_interval]
             for strat in list(self.config['strategy_list']):
                 stratconf = deepcopy(self.config)
                 stratconf['strategy'] = strat
                 self.strategylist.append(StrategyResolver(stratconf).strategy)
 
         else:
-            # only one strategy
+            # No strategy list specified, only one strategy
             self.strategylist.append(StrategyResolver(self.config).strategy)
-        # Load one strategy
-        self._set_strategy(self.strategylist[0])
 
-        self.exchange = Exchange(self.config)
+        # Load one (first) strategy
-        self.fee = self.exchange.get_fee()
+        self._set_strategy(self.strategylist[0])
 
     def _set_strategy(self, strategy):
         """
         Load strategy into backtesting
         """
         self.strategy = strategy
+        if "ticker_interval" not in self.config:
+            raise OperationalException("Ticker-interval needs to be set in either configuration "
+                                       "or as cli argument `--ticker-interval 5m`")
+
         self.ticker_interval = self.config.get('ticker_interval')
-        self.ticker_interval_mins = constants.TICKER_INTERVAL_MINUTES[self.ticker_interval]
+        self.ticker_interval_mins = timeframe_to_minutes(self.ticker_interval)
-        self.tickerdata_to_dataframe = strategy.tickerdata_to_dataframe
         self.advise_buy = strategy.advise_buy
         self.advise_sell = strategy.advise_sell
+        # 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
+        self.strategy.order_types['stoploss_on_exchange'] = False
 
     def _generate_text_table(self, data: Dict[str, Dict], results: DataFrame,
                              skip_nan: bool = False) -> str:
@@ -100,11 +109,13 @@ class Backtesting(object):
         :return: pretty printed table with tabulate as str
         """
         stake_currency = str(self.config.get('stake_currency'))
+        max_open_trades = self.config.get('max_open_trades')
 
-        floatfmt = ('s', 'd', '.2f', '.2f', '.8f', 'd', '.1f', '.1f')
+        floatfmt = ('s', 'd', '.2f', '.2f', '.8f', '.2f', 'd', '.1f', '.1f')
         tabular_data = []
         headers = ['pair', 'buy count', 'avg profit %', 'cum profit %',
-                   'total profit ' + stake_currency, 'avg duration', 'profit', 'loss']
+                   'tot profit ' + stake_currency, 'tot profit %', 'avg duration',
+                   'profit', 'loss']
         for pair in data:
             result = results[results.pair == pair]
             if skip_nan and result.profit_abs.isnull().all():
@@ -116,6 +127,7 @@ class Backtesting(object):
                 result.profit_percent.mean() * 100.0,
                 result.profit_percent.sum() * 100.0,
                 result.profit_abs.sum(),
+                result.profit_percent.sum() * 100.0 / max_open_trades,
                 str(timedelta(
                     minutes=round(result.trade_duration.mean()))) if not result.empty else '0:00',
                 len(result[result.profit_abs > 0]),
@@ -129,12 +141,15 @@ class Backtesting(object):
             results.profit_percent.mean() * 100.0,
             results.profit_percent.sum() * 100.0,
             results.profit_abs.sum(),
+            results.profit_percent.sum() * 100.0 / max_open_trades,
             str(timedelta(
                 minutes=round(results.trade_duration.mean()))) if not results.empty else '0:00',
             len(results[results.profit_abs > 0]),
             len(results[results.profit_abs < 0])
         ])
-        return tabulate(tabular_data, headers=headers, floatfmt=floatfmt, tablefmt="pipe")
+        # Ignore type as floatfmt does allow tuples but mypy does not know that
+        return tabulate(tabular_data, headers=headers,  # type: ignore
+                        floatfmt=floatfmt, tablefmt="pipe")
 
     def _generate_text_table_sell_reason(self, data: Dict[str, Dict], results: DataFrame) -> str:
         """
@@ -151,11 +166,13 @@ class Backtesting(object):
         Generate summary table per strategy
         """
         stake_currency = str(self.config.get('stake_currency'))
+        max_open_trades = self.config.get('max_open_trades')
 
-        floatfmt = ('s', 'd', '.2f', '.2f', '.8f', 'd', '.1f', '.1f')
+        floatfmt = ('s', 'd', '.2f', '.2f', '.8f', '.2f', 'd', '.1f', '.1f')
         tabular_data = []
         headers = ['Strategy', 'buy count', 'avg profit %', 'cum profit %',
-                   'total profit ' + stake_currency, 'avg duration', 'profit', 'loss']
+                   'tot profit ' + stake_currency, 'tot profit %', 'avg duration',
+                   'profit', 'loss']
         for strategy, results in all_results.items():
             tabular_data.append([
                 strategy,
@@ -163,14 +180,17 @@ class Backtesting(object):
                 results.profit_percent.mean() * 100.0,
                 results.profit_percent.sum() * 100.0,
                 results.profit_abs.sum(),
+                results.profit_percent.sum() * 100.0 / max_open_trades,
                 str(timedelta(
                     minutes=round(results.trade_duration.mean()))) if not results.empty else '0:00',
                 len(results[results.profit_abs > 0]),
                 len(results[results.profit_abs < 0])
             ])
-        return tabulate(tabular_data, headers=headers, floatfmt=floatfmt, tablefmt="pipe")
+        # Ignore type as floatfmt does allow tuples but mypy does not know that
+        return tabulate(tabular_data, headers=headers,  # type: ignore
+                        floatfmt=floatfmt, tablefmt="pipe")
 
-    def _store_backtest_result(self, recordfilename: str, results: DataFrame,
+    def _store_backtest_result(self, recordfilename: Path, results: DataFrame,
                                strategyname: Optional[str] = None) -> None:
 
         records = [(t.pair, t.profit_percent, t.open_time.timestamp(),
@@ -181,18 +201,43 @@ class Backtesting(object):
         if records:
             if strategyname:
                 # Inject strategyname to filename
-                recname = Path(recordfilename)
+                recordfilename = Path.joinpath(
-                recordfilename = str(Path.joinpath(
+                    recordfilename.parent,
-                    recname.parent, f'{recname.stem}-{strategyname}').with_suffix(recname.suffix))
+                    f'{recordfilename.stem}-{strategyname}').with_suffix(recordfilename.suffix)
-            logger.info('Dumping backtest results to %s', recordfilename)
+            logger.info(f'Dumping backtest results to {recordfilename}')
             file_dump_json(recordfilename, records)
 
+    def _get_ticker_list(self, processed) -> Dict[str, DataFrame]:
+        """
+        Helper function to convert a processed tickerlist into a list for performance reasons.
+
+        Used by backtest() - so keep this optimized for performance.
+        """
+        headers = ['date', 'buy', 'open', 'close', 'sell', 'low', 'high']
+        ticker: Dict = {}
+        # Create ticker dict
+        for pair, pair_data in processed.items():
+            pair_data['buy'], pair_data['sell'] = 0, 0  # cleanup from previous run
+
+            ticker_data = self.advise_sell(
+                self.advise_buy(pair_data, {'pair': pair}), {'pair': pair})[headers].copy()
+
+            # to avoid using data from future, we buy/sell with signal from previous candle
+            ticker_data.loc[:, 'buy'] = ticker_data['buy'].shift(1)
+            ticker_data.loc[:, 'sell'] = ticker_data['sell'].shift(1)
+
+            ticker_data.drop(ticker_data.head(1).index, inplace=True)
+
+            # Convert from Pandas to list for performance reasons
+            # (Looping Pandas is slow.)
+            ticker[pair] = [x for x in ticker_data.itertuples()]
+        return ticker
+
     def _get_sell_trade_entry(
             self, pair: str, buy_row: DataFrame,
-            partial_ticker: List, trade_count_lock: Dict, args: Dict) -> Optional[BacktestResult]:
+            partial_ticker: List, trade_count_lock: Dict,
+            stake_amount: float, max_open_trades: int) -> Optional[BacktestResult]:
 
-        stake_amount = args['stake_amount']
-        max_open_trades = args.get('max_open_trades', 0)
         trade = Trade(
             open_rate=buy_row.open,
             open_date=buy_row.date,
@@ -208,25 +253,23 @@ class Backtesting(object):
                 # Increase trade_count_lock for every iteration
                 trade_count_lock[sell_row.date] = trade_count_lock.get(sell_row.date, 0) + 1
 
-            buy_signal = sell_row.buy
+            sell = self.strategy.should_sell(trade, sell_row.open, sell_row.date, sell_row.buy,
-            sell = self.strategy.should_sell(trade, sell_row.open, sell_row.date, buy_signal,
                                              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)
                 # Special handling if high or low hit STOP_LOSS or ROI
                 if sell.sell_type in (SellType.STOP_LOSS, SellType.TRAILING_STOP_LOSS):
                     # Set close_rate to stoploss
                     closerate = trade.stop_loss
                 elif sell.sell_type == (SellType.ROI):
-                    # get entry in min_roi >= to trade duration
+                    roi = self.strategy.min_roi_reached_entry(trade_dur)
-                    roi_entry = max(list(filter(lambda x: trade_dur >= x,
+                    if roi is not None:
-                                                self.strategy.minimal_roi.keys())))
+                        # - (Expected abs profit + open_rate + open_fee) / (fee_close -1)
-                    roi = self.strategy.minimal_roi[roi_entry]
+                        closerate = - (trade.open_rate * roi + trade.open_rate *
-
+                                       (1 + trade.fee_open)) / (trade.fee_close - 1)
-                    # - (Expected abs profit + open_rate + open_fee) / (fee_close -1)
+                    else:
-                    closerate = - (trade.open_rate * roi + trade.open_rate *
+                        # This should not be reached...
-                                   (1 + trade.fee_open)) / (trade.fee_close - 1)
+                        closerate = sell_row.open
                 else:
                     closerate = sell_row.open
 
@@ -280,74 +323,75 @@ class Backtesting(object):
             position_stacking: do we allow position stacking? (default: False)
         :return: DataFrame
         """
-        headers = ['date', 'buy', 'open', 'close', 'sell', 'low', 'high']
+        # Arguments are long and noisy, so this is commented out.
+        # Uncomment if you need to debug the backtest() method.
+#        logger.debug(f"Start backtest, args: {args}")
         processed = args['processed']
+        stake_amount = args['stake_amount']
         max_open_trades = args.get('max_open_trades', 0)
         position_stacking = args.get('position_stacking', False)
         start_date = args['start_date']
         end_date = args['end_date']
         trades = []
         trade_count_lock: Dict = {}
-        ticker: Dict = {}
-        pairs = []
-        # Create ticker dict
-        for pair, pair_data in processed.items():
-            pair_data['buy'], pair_data['sell'] = 0, 0  # cleanup from previous run
 
-            ticker_data = self.advise_sell(
+        # Dict of ticker-lists for performance (looping lists is a lot faster than dataframes)
-                self.advise_buy(pair_data, {'pair': pair}), {'pair': pair})[headers].copy()
+        ticker: Dict = self._get_ticker_list(processed)
-
-            # to avoid using data from future, we buy/sell with signal from previous candle
-            ticker_data.loc[:, 'buy'] = ticker_data['buy'].shift(1)
-            ticker_data.loc[:, 'sell'] = ticker_data['sell'].shift(1)
-
-            ticker_data.drop(ticker_data.head(1).index, inplace=True)
-
-            # Convert from Pandas to list for performance reasons
-            # (Looping Pandas is slow.)
-            ticker[pair] = [x for x in ticker_data.itertuples()]
-            pairs.append(pair)
 
         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.ticker_interval_mins)
-        index = 0
+
-        # Loop timerange and test per pair
+        # Loop timerange and get candle for each pair at that point in time
         while tmp < end_date:
-            # print(f"time: {tmp}")
+
             for i, pair in enumerate(ticker):
+                if pair not in indexes:
+                    indexes[pair] = 0
+
                 try:
-                    row = ticker[pair][index]
+                    row = ticker[pair][indexes[pair]]
                 except IndexError:
-                    # missing Data for one pair ...
+                    # missing Data for one pair at the end.
-                    # Warnings for this are shown by `validate_backtest_data`
+                    # Warnings for this are shown during data loading
                     continue
 
+                # Waits until the time-counter reaches the start of the data for this pair.
+                if row.date > tmp.datetime:
+                    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
 
-                if not position_stacking:
+                if (not position_stacking and pair in lock_pair_until
-                    if pair in lock_pair_until and row.date <= lock_pair_until[pair]:
+                        and row.date <= lock_pair_until[pair]):
-                        continue
+                    # 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
 
-                trade_entry = self._get_sell_trade_entry(pair, row, ticker[pair][index + 1:],
+                # since indexes has been incremented before, we need to go one step back to
-                                                         trade_count_lock, args)
+                # also check the buying candle for sell conditions.
+                trade_entry = self._get_sell_trade_entry(pair, row, ticker[pair][indexes[pair]-1:],
+                                                         trade_count_lock, stake_amount,
+                                                         max_open_trades)
 
                 if trade_entry:
                     lock_pair_until[pair] = trade_entry.close_time
                     trades.append(trade_entry)
                 else:
                     # Set lock_pair_until to end of testing period if trade could not be closed
-                    # This happens only if the buy-signal was with the last candle
+                    lock_pair_until[pair] = end_date.datetime
-                    lock_pair_until[pair] = end_date
 
+            # Move time one configured time_interval ahead.
             tmp += timedelta(minutes=self.ticker_interval_mins)
-            index += 1
         return DataFrame.from_records(trades, columns=BacktestResult._fields)
 
     def start(self) -> None:
@@ -360,23 +404,16 @@ class Backtesting(object):
         logger.info('Using stake_currency: %s ...', self.config['stake_currency'])
         logger.info('Using stake_amount: %s ...', self.config['stake_amount'])
 
-        if self.config.get('live'):
+        timerange = TimeRange.parse_timerange(None if self.config.get(
-            logger.info('Downloading data for all pairs in whitelist ...')
+            'timerange') is None else str(self.config.get('timerange')))
-            self.exchange.refresh_tickers(pairs, self.ticker_interval)
+        data = history.load_data(
-            data = self.exchange._klines
+            datadir=Path(self.config['datadir']) if self.config.get('datadir') else None,
-        else:
+            pairs=pairs,
-            logger.info('Using local backtesting data (using whitelist in given config) ...')
+            ticker_interval=self.ticker_interval,
-
+            refresh_pairs=self.config.get('refresh_pairs', False),
-            timerange = Arguments.parse_timerange(None if self.config.get(
+            exchange=self.exchange,
-                'timerange') is None else str(self.config.get('timerange')))
+            timerange=timerange,
-            data = history.load_data(
+        )
-                datadir=Path(self.config['datadir']) if self.config.get('datadir') else None,
-                pairs=pairs,
-                ticker_interval=self.ticker_interval,
-                refresh_pairs=self.config.get('refresh_pairs', False),
-                exchange=self.exchange,
-                timerange=timerange
-            )
 
         if not data:
             logger.critical("No data found. Terminating.")
@@ -389,6 +426,15 @@ class Backtesting(object):
             max_open_trades = 0
         all_results = {}
 
+        min_date, max_date = history.get_timeframe(data)
+
+        logger.info(
+            'Backtesting with data from %s up to %s (%s days)..',
+            min_date.isoformat(),
+            max_date.isoformat(),
+            (max_date - min_date).days
+        )
+
         for strat in self.strategylist:
             logger.info("Running backtesting for Strategy %s", strat.get_strategy_name())
             self._set_strategy(strat)
@@ -396,17 +442,6 @@ class Backtesting(object):
             # need to reprocess data every time to populate signals
             preprocessed = self.strategy.tickerdata_to_dataframe(data)
 
-            min_date, max_date = optimize.get_timeframe(preprocessed)
-            # Validate dataframe for missing values
-            optimize.validate_backtest_data(preprocessed, min_date, max_date,
-                                            constants.TICKER_INTERVAL_MINUTES[self.ticker_interval])
-            logger.info(
-                'Measuring data from %s up to %s (%s days)..',
-                min_date.isoformat(),
-                max_date.isoformat(),
-                (max_date - min_date).days
-            )
-
             # Execute backtest and print results
             all_results[self.strategy.get_strategy_name()] = self.backtest(
                 {
@@ -422,56 +457,21 @@ class Backtesting(object):
         for strategy, results in all_results.items():
 
             if self.config.get('export', False):
-                self._store_backtest_result(self.config['exportfilename'], results,
+                self._store_backtest_result(Path(self.config['exportfilename']), results,
                                             strategy if len(self.strategylist) > 1 else None)
 
             print(f"Result for strategy {strategy}")
-            print(' BACKTESTING REPORT '.center(119, '='))
+            print(' BACKTESTING REPORT '.center(133, '='))
             print(self._generate_text_table(data, results))
 
-            print(' SELL REASON STATS '.center(119, '='))
+            print(' SELL REASON STATS '.center(133, '='))
             print(self._generate_text_table_sell_reason(data, results))
 
-            print(' LEFT OPEN TRADES REPORT '.center(119, '='))
+            print(' LEFT OPEN TRADES REPORT '.center(133, '='))
             print(self._generate_text_table(data, results.loc[results.open_at_end], True))
             print()
         if len(all_results) > 1:
             # Print Strategy summary table
-            print(' Strategy Summary '.center(119, '='))
+            print(' Strategy Summary '.center(133, '='))
             print(self._generate_text_table_strategy(all_results))
             print('\nFor more details, please look at the detail tables above')
-
-
-def setup_configuration(args: Namespace) -> Dict[str, Any]:
-    """
-    Prepare the configuration for the backtesting
-    :param args: Cli args from Arguments()
-    :return: Configuration
-    """
-    configuration = Configuration(args)
-    config = configuration.get_config()
-
-    # Ensure we do not use Exchange credentials
-    config['exchange']['key'] = ''
-    config['exchange']['secret'] = ''
-
-    if config['stake_amount'] == constants.UNLIMITED_STAKE_AMOUNT:
-        raise DependencyException('stake amount could not be "%s" for backtesting' %
-                                  constants.UNLIMITED_STAKE_AMOUNT)
-
-    return config
-
-
-def start(args: Namespace) -> None:
-    """
-    Start Backtesting script
-    :param args: Cli args from Arguments()
-    :return: None
-    """
-    # Initialize configuration
-    config = setup_configuration(args)
-    logger.info('Starting freqtrade in Backtesting mode')
-
-    # Initialize backtesting object
-    backtesting = Backtesting(config)
-    backtesting.start()

freqtrade/optimize/default_hyperopt.py

@@ -1,51 +1,61 @@
 # pragma pylint: disable=missing-docstring, invalid-name, pointless-string-statement
 
+from functools import reduce
+from typing import Any, Callable, Dict, List
+
 import talib.abstract as ta
 from pandas import DataFrame
-from typing import Dict, Any, Callable, List
+from skopt.space import Categorical, Dimension, Integer
-from functools import reduce
-
-from skopt.space import Categorical, Dimension, Integer, Real
 
 import freqtrade.vendor.qtpylib.indicators as qtpylib
 from freqtrade.optimize.hyperopt_interface import IHyperOpt
 
-class_name = 'DefaultHyperOpts'
-
 
 class DefaultHyperOpts(IHyperOpt):
     """
-    Default hyperopt provided by freqtrade bot.
+    Default hyperopt provided by the Freqtrade bot.
-    You can override it with your own hyperopt
+    You can override it with your own Hyperopt
     """
-
     @staticmethod
     def populate_indicators(dataframe: DataFrame, metadata: dict) -> DataFrame:
+        """
+        Add several indicators needed for buy and sell strategies defined below.
+        """
+        # ADX
         dataframe['adx'] = ta.ADX(dataframe)
+        # MACD
         macd = ta.MACD(dataframe)
         dataframe['macd'] = macd['macd']
         dataframe['macdsignal'] = macd['macdsignal']
+        # MFI
         dataframe['mfi'] = ta.MFI(dataframe)
+        # RSI
         dataframe['rsi'] = ta.RSI(dataframe)
+        # Stochastic Fast
         stoch_fast = ta.STOCHF(dataframe)
         dataframe['fastd'] = stoch_fast['fastd']
+        # Minus-DI
         dataframe['minus_di'] = ta.MINUS_DI(dataframe)
         # Bollinger bands
         bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2)
         dataframe['bb_lowerband'] = bollinger['lower']
+        dataframe['bb_upperband'] = bollinger['upper']
+        # SAR
         dataframe['sar'] = ta.SAR(dataframe)
+
         return dataframe
 
     @staticmethod
     def buy_strategy_generator(params: Dict[str, Any]) -> Callable:
         """
-        Define the buy strategy parameters to be used by hyperopt
+        Define the buy strategy parameters to be used by Hyperopt.
         """
         def populate_buy_trend(dataframe: DataFrame, metadata: dict) -> DataFrame:
             """
-            Buy strategy Hyperopt will build and use
+            Buy strategy Hyperopt will build and use.
             """
             conditions = []
+
             # GUARDS AND TRENDS
             if 'mfi-enabled' in params and params['mfi-enabled']:
                 conditions.append(dataframe['mfi'] < params['mfi-value'])
@@ -57,20 +67,22 @@ class DefaultHyperOpts(IHyperOpt):
                 conditions.append(dataframe['rsi'] < params['rsi-value'])
 
             # TRIGGERS
-            if params['trigger'] == 'bb_lower':
+            if 'trigger' in params:
-                conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
+                if params['trigger'] == 'bb_lower':
-            if params['trigger'] == 'macd_cross_signal':
+                    conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
-                conditions.append(qtpylib.crossed_above(
+                if params['trigger'] == 'macd_cross_signal':
-                    dataframe['macd'], dataframe['macdsignal']
+                    conditions.append(qtpylib.crossed_above(
-                ))
+                        dataframe['macd'], dataframe['macdsignal']
-            if params['trigger'] == 'sar_reversal':
+                    ))
-                conditions.append(qtpylib.crossed_above(
+                if params['trigger'] == 'sar_reversal':
-                    dataframe['close'], dataframe['sar']
+                    conditions.append(qtpylib.crossed_above(
-                ))
+                        dataframe['close'], dataframe['sar']
+                    ))
 
-            dataframe.loc[
+            if conditions:
-                reduce(lambda x, y: x & y, conditions),
+                dataframe.loc[
-                'buy'] = 1
+                    reduce(lambda x, y: x & y, conditions),
+                    'buy'] = 1
 
             return dataframe
 
@@ -79,7 +91,7 @@ class DefaultHyperOpts(IHyperOpt):
     @staticmethod
     def indicator_space() -> List[Dimension]:
         """
-        Define your Hyperopt space for searching strategy parameters
+        Define your Hyperopt space for searching buy strategy parameters.
         """
         return [
             Integer(10, 25, name='mfi-value'),
@@ -94,37 +106,97 @@ class DefaultHyperOpts(IHyperOpt):
         ]
 
     @staticmethod
-    def generate_roi_table(params: Dict) -> Dict[int, float]:
+    def sell_strategy_generator(params: Dict[str, Any]) -> Callable:
         """
-        Generate the ROI table that will be used by Hyperopt
+        Define the sell strategy parameters to be used by Hyperopt.
         """
-        roi_table = {}
+        def populate_sell_trend(dataframe: DataFrame, metadata: dict) -> DataFrame:
-        roi_table[0] = params['roi_p1'] + params['roi_p2'] + params['roi_p3']
+            """
-        roi_table[params['roi_t3']] = params['roi_p1'] + params['roi_p2']
+            Sell strategy Hyperopt will build and use.
-        roi_table[params['roi_t3'] + params['roi_t2']] = params['roi_p1']
+            """
-        roi_table[params['roi_t3'] + params['roi_t2'] + params['roi_t1']] = 0
+            conditions = []
 
-        return roi_table
+            # GUARDS AND TRENDS
+            if 'sell-mfi-enabled' in params and params['sell-mfi-enabled']:
+                conditions.append(dataframe['mfi'] > params['sell-mfi-value'])
+            if 'sell-fastd-enabled' in params and params['sell-fastd-enabled']:
+                conditions.append(dataframe['fastd'] > params['sell-fastd-value'])
+            if 'sell-adx-enabled' in params and params['sell-adx-enabled']:
+                conditions.append(dataframe['adx'] < params['sell-adx-value'])
+            if 'sell-rsi-enabled' in params and params['sell-rsi-enabled']:
+                conditions.append(dataframe['rsi'] > params['sell-rsi-value'])
+
+            # TRIGGERS
+            if 'sell-trigger' in params:
+                if params['sell-trigger'] == 'sell-bb_upper':
+                    conditions.append(dataframe['close'] > dataframe['bb_upperband'])
+                if params['sell-trigger'] == 'sell-macd_cross_signal':
+                    conditions.append(qtpylib.crossed_above(
+                        dataframe['macdsignal'], dataframe['macd']
+                    ))
+                if params['sell-trigger'] == 'sell-sar_reversal':
+                    conditions.append(qtpylib.crossed_above(
+                        dataframe['sar'], dataframe['close']
+                    ))
+
+            if conditions:
+                dataframe.loc[
+                    reduce(lambda x, y: x & y, conditions),
+                    'sell'] = 1
+
+            return dataframe
+
+        return populate_sell_trend
 
     @staticmethod
-    def stoploss_space() -> List[Dimension]:
+    def sell_indicator_space() -> List[Dimension]:
         """
-        Stoploss Value to search
+        Define your Hyperopt space for searching sell strategy parameters.
         """
         return [
-            Real(-0.5, -0.02, name='stoploss'),
+            Integer(75, 100, name='sell-mfi-value'),
+            Integer(50, 100, name='sell-fastd-value'),
+            Integer(50, 100, name='sell-adx-value'),
+            Integer(60, 100, name='sell-rsi-value'),
+            Categorical([True, False], name='sell-mfi-enabled'),
+            Categorical([True, False], name='sell-fastd-enabled'),
+            Categorical([True, False], name='sell-adx-enabled'),
+            Categorical([True, False], name='sell-rsi-enabled'),
+            Categorical(['sell-bb_upper',
+                         'sell-macd_cross_signal',
+                         'sell-sar_reversal'], name='sell-trigger')
         ]
 
-    @staticmethod
+    def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
-    def roi_space() -> List[Dimension]:
         """
-        Values to search for each ROI steps
+        Based on TA indicators. Should be a copy of same method from strategy.
+        Must align to populate_indicators in this file.
+        Only used when --spaces does not include buy space.
         """
-        return [
+        dataframe.loc[
-            Integer(10, 120, name='roi_t1'),
+            (
-            Integer(10, 60, name='roi_t2'),
+                (dataframe['close'] < dataframe['bb_lowerband']) &
-            Integer(10, 40, name='roi_t3'),
+                (dataframe['mfi'] < 16) &
-            Real(0.01, 0.04, name='roi_p1'),
+                (dataframe['adx'] > 25) &
-            Real(0.01, 0.07, name='roi_p2'),
+                (dataframe['rsi'] < 21)
-            Real(0.01, 0.20, name='roi_p3'),
+            ),
-        ]
+            'buy'] = 1
+
+        return dataframe
+
+    def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        """
+        Based on TA indicators. Should be a copy of same method from strategy.
+        Must align to populate_indicators in this file.
+        Only used when --spaces does not include sell space.
+        """
+        dataframe.loc[
+            (
+                (qtpylib.crossed_above(
+                    dataframe['macdsignal'], dataframe['macd']
+                )) &
+                (dataframe['fastd'] > 54)
+            ),
+            'sell'] = 1
+
+        return dataframe

freqtrade/optimize/default_hyperopt_loss.py

@@ -0,0 +1,52 @@
+"""
+DefaultHyperOptLoss
+This module defines the default HyperoptLoss class which is being used for
+Hyperoptimization.
+"""
+from math import exp
+
+from pandas import DataFrame
+
+from freqtrade.optimize.hyperopt import IHyperOptLoss
+
+
+# Set TARGET_TRADES to suit your number concurrent trades so its realistic
+# to the number of days
+TARGET_TRADES = 600
+
+# This is assumed to be expected avg profit * expected trade count.
+# For example, for 0.35% avg per trade (or 0.0035 as ratio) and 1100 trades,
+# expected max profit = 3.85
+# Check that the reported Σ% values do not exceed this!
+# Note, this is ratio. 3.85 stated above means 385Σ%.
+EXPECTED_MAX_PROFIT = 3.0
+
+# Max average trade duration in minutes.
+# If eval ends with higher value, we consider it a failed eval.
+MAX_ACCEPTED_TRADE_DURATION = 300
+
+
+class DefaultHyperOptLoss(IHyperOptLoss):
+    """
+    Defines the default loss function for hyperopt
+    """
+
+    @staticmethod
+    def hyperopt_loss_function(results: DataFrame, trade_count: int,
+                               *args, **kwargs) -> float:
+        """
+        Objective function, returns smaller number for better results
+        This is the Default algorithm
+        Weights are distributed as follows:
+        * 0.4 to trade duration
+        * 0.25: Avoiding trade loss
+        * 1.0 to total profit, compared to the expected value (`EXPECTED_MAX_PROFIT`) defined above
+        """
+        total_profit = results.profit_percent.sum()
+        trade_duration = results.trade_duration.mean()
+
+        trade_loss = 1 - 0.25 * exp(-(trade_count - TARGET_TRADES) ** 2 / 10 ** 5.8)
+        profit_loss = max(0, 1 - total_profit / EXPECTED_MAX_PROFIT)
+        duration_loss = 0.4 * min(trade_duration / MAX_ACCEPTED_TRADE_DURATION, 1)
+        result = trade_loss + profit_loss + duration_loss
+        return result

freqtrade/optimize/edge_cli.py

@@ -4,13 +4,12 @@
 This module contains the edge backtesting interface
 """
 import logging
-from argparse import Namespace
 from typing import Dict, Any
 from tabulate import tabulate
+from freqtrade import constants
 from freqtrade.edge import Edge
 
-from freqtrade.configuration import Configuration
+from freqtrade.configuration import TimeRange
-from freqtrade.arguments import Arguments
 from freqtrade.exchange import Exchange
 from freqtrade.resolvers import StrategyResolver
 
@@ -34,6 +33,7 @@ class EdgeCli(object):
         self.config['exchange']['secret'] = ''
         self.config['exchange']['password'] = ''
         self.config['exchange']['uid'] = ''
+        self.config['stake_amount'] = constants.UNLIMITED_STAKE_AMOUNT
         self.config['dry_run'] = True
         self.exchange = Exchange(self.config)
         self.strategy = StrategyResolver(self.config).strategy
@@ -41,7 +41,7 @@ class EdgeCli(object):
         self.edge = Edge(config, self.exchange, self.strategy)
         self.edge._refresh_pairs = self.config.get('refresh_pairs', False)
 
-        self.timerange = Arguments.parse_timerange(None if self.config.get(
+        self.timerange = TimeRange.parse_timerange(None if self.config.get(
             'timerange') is None else str(self.config.get('timerange')))
 
         self.edge._timerange = self.timerange
@@ -67,40 +67,12 @@ class EdgeCli(object):
                     round(result[1].avg_trade_duration)
                 ])
 
-        return tabulate(tabular_data, headers=headers, floatfmt=floatfmt, tablefmt="pipe")
+        # Ignore type as floatfmt does allow tuples but mypy does not know that
+        return tabulate(tabular_data, headers=headers,  # type: ignore
+                        floatfmt=floatfmt, tablefmt="pipe")
 
     def start(self) -> None:
-        self.edge.calculate()
+        result = self.edge.calculate()
-        print('')  # blank like for readability
+        if result:
-        print(self._generate_edge_table(self.edge._cached_pairs))
+            print('')  # blank line for readability
-
+            print(self._generate_edge_table(self.edge._cached_pairs))
-
-def setup_configuration(args: Namespace) -> Dict[str, Any]:
-    """
-    Prepare the configuration for edge backtesting
-    :param args: Cli args from Arguments()
-    :return: Configuration
-    """
-    configuration = Configuration(args)
-    config = configuration.get_config()
-
-    # Ensure we do not use Exchange credentials
-    config['exchange']['key'] = ''
-    config['exchange']['secret'] = ''
-
-    return config
-
-
-def start(args: Namespace) -> None:
-    """
-    Start Edge script
-    :param args: Cli args from Arguments()
-    :return: None
-    """
-    # Initialize configuration
-    config = setup_configuration(args)
-    logger.info('Starting freqtrade in Edge mode')
-
-    # Initialize Edge object
-    edge_cli = EdgeCli(config)
-    edge_cli.start()

freqtrade/optimize/hyperopt.py

@@ -5,35 +5,39 @@ This module contains the hyperopt logic
 """
 
 import logging
-from argparse import Namespace
-import os
 import sys
-from pathlib import Path
-from math import exp
-import multiprocessing
-from operator import itemgetter
-from typing import Any, Dict, List
 
+from collections import OrderedDict
+from operator import itemgetter
+from pathlib import Path
+from pprint import pprint
+from typing import Any, Dict, List, Optional
+
+import rapidjson
+
+from colorama import init as colorama_init
+from colorama import Fore, Style
+from joblib import Parallel, delayed, dump, load, wrap_non_picklable_objects, cpu_count
 from pandas import DataFrame
-from joblib import Parallel, delayed, dump, load, wrap_non_picklable_objects
 from skopt import Optimizer
 from skopt.space import Dimension
 
-from freqtrade.arguments import Arguments
+from freqtrade.configuration import TimeRange
-from freqtrade.configuration import Configuration
+from freqtrade.data.history import load_data, get_timeframe
-from freqtrade.data.history import load_data
-from freqtrade.optimize import get_timeframe
 from freqtrade.optimize.backtesting import Backtesting
-from freqtrade.resolvers import HyperOptResolver
+# Import IHyperOptLoss to allow users import from this file
+from freqtrade.optimize.hyperopt_loss_interface import IHyperOptLoss  # noqa: F4
+from freqtrade.resolvers.hyperopt_resolver import HyperOptResolver, HyperOptLossResolver
 
 
 logger = logging.getLogger(__name__)
 
+
+INITIAL_POINTS = 30
 MAX_LOSS = 100000  # just a big enough number to be bad result in loss optimization
-TICKERDATA_PICKLE = os.path.join('user_data', 'hyperopt_tickerdata.pkl')
 
 
-class Hyperopt(Backtesting):
+class Hyperopt:
     """
     Hyperopt class, this class contains all the logic to run a hyperopt simulation
 
@@ -42,29 +46,66 @@ class Hyperopt(Backtesting):
     hyperopt.start()
     """
     def __init__(self, config: Dict[str, Any]) -> None:
-        super().__init__(config)
         self.config = config
+        self.backtesting = Backtesting(self.config)
+
         self.custom_hyperopt = HyperOptResolver(self.config).hyperopt
 
-        # set TARGET_TRADES to suit your number concurrent trades so its realistic
+        self.custom_hyperoptloss = HyperOptLossResolver(self.config).hyperoptloss
-        # to the number of days
+        self.calculate_loss = self.custom_hyperoptloss.hyperopt_loss_function
-        self.target_trades = 600
+
-        self.total_tries = config.get('epochs', 0)
+        self.trials_file = (self.config['user_data_dir'] /
+                            'hyperopt_results' / 'hyperopt_results.pickle')
+        self.tickerdata_pickle = (self.config['user_data_dir'] /
+                                  'hyperopt_results' / 'hyperopt_tickerdata.pkl')
+        self.total_epochs = config.get('epochs', 0)
+
         self.current_best_loss = 100
 
-        # max average trade duration in minutes
+        if not self.config.get('hyperopt_continue'):
-        # if eval ends with higher value, we consider it a failed eval
+            self.clean_hyperopt()
-        self.max_accepted_trade_duration = 300
+        else:
-
+            logger.info("Continuing on previous hyperopt results.")
-        # this is expexted avg profit * expected trade count
-        # for example 3.5%, 1100 trades, self.expected_max_profit = 3.85
-        # check that the reported Σ% values do not exceed this!
-        self.expected_max_profit = 3.0
 
         # Previous evaluations
-        self.trials_file = os.path.join('user_data', 'hyperopt_results.pickle')
         self.trials: List = []
 
+        # Populate functions here (hasattr is slow so should not be run during "regular" operations)
+        if hasattr(self.custom_hyperopt, 'populate_buy_trend'):
+            self.backtesting.advise_buy = self.custom_hyperopt.populate_buy_trend  # type: ignore
+
+        if hasattr(self.custom_hyperopt, 'populate_sell_trend'):
+            self.backtesting.advise_sell = self.custom_hyperopt.populate_sell_trend  # type: ignore
+
+        # Use max_open_trades for hyperopt as well, except --disable-max-market-positions is set
+        if self.config.get('use_max_market_positions', True):
+            self.max_open_trades = self.config['max_open_trades']
+        else:
+            logger.debug('Ignoring max_open_trades (--disable-max-market-positions was used) ...')
+            self.max_open_trades = 0
+        self.position_stacking = self.config.get('position_stacking', False),
+
+        if self.has_space('sell'):
+            # Make sure experimental is enabled
+            if 'experimental' not in self.config:
+                self.config['experimental'] = {}
+            self.config['experimental']['use_sell_signal'] = True
+
+    @staticmethod
+    def get_lock_filename(config) -> str:
+
+        return str(config['user_data_dir'] / 'hyperopt.lock')
+
+    def clean_hyperopt(self):
+        """
+        Remove hyperopt pickle files to restart hyperopt.
+        """
+        for f in [self.tickerdata_pickle, self.trials_file]:
+            p = Path(f)
+            if p.is_file():
+                logger.info(f"Removing `{p}`.")
+                p.unlink()
+
     def get_args(self, params):
         dimensions = self.hyperopt_space()
         # Ensure the number of dimensions match
@@ -92,7 +133,7 @@ class Hyperopt(Backtesting):
         """
         logger.info('Reading Trials from \'%s\'', self.trials_file)
         trials = load(self.trials_file)
-        os.remove(self.trials_file)
+        self.trials_file.unlink()
         return trials
 
     def log_trials_result(self) -> None:
@@ -101,127 +142,190 @@ class Hyperopt(Backtesting):
         """
         results = sorted(self.trials, key=itemgetter('loss'))
         best_result = results[0]
-        logger.info(
+        params = best_result['params']
-            'Best result:\n%s\nwith values:\n%s',
+        log_str = self.format_results_logstring(best_result)
-            best_result['result'],
+        print(f"\nBest result:\n\n{log_str}\n")
-            best_result['params']
+
-        )
+        if self.config.get('print_json'):
-        if 'roi_t1' in best_result['params']:
+            result_dict: Dict = {}
-            logger.info('ROI table:\n%s',
+            if self.has_space('buy') or self.has_space('sell'):
-                        self.custom_hyperopt.generate_roi_table(best_result['params']))
+                result_dict['params'] = {}
+            if self.has_space('buy'):
+                result_dict['params'].update({p.name: params.get(p.name)
+                                             for p in self.hyperopt_space('buy')})
+            if self.has_space('sell'):
+                result_dict['params'].update({p.name: params.get(p.name)
+                                             for p in self.hyperopt_space('sell')})
+            if self.has_space('roi'):
+                # Convert keys in min_roi dict to strings because
+                # rapidjson cannot dump dicts with integer keys...
+                # OrderedDict is used to keep the numeric order of the items
+                # in the dict.
+                result_dict['minimal_roi'] = OrderedDict(
+                    (str(k), v) for k, v in self.custom_hyperopt.generate_roi_table(params).items()
+                )
+            if self.has_space('stoploss'):
+                result_dict['stoploss'] = params.get('stoploss')
+            print(rapidjson.dumps(result_dict, default=str, number_mode=rapidjson.NM_NATIVE))
+        else:
+            if self.has_space('buy'):
+                print('Buy hyperspace params:')
+                pprint({p.name: params.get(p.name) for p in self.hyperopt_space('buy')},
+                       indent=4)
+            if self.has_space('sell'):
+                print('Sell hyperspace params:')
+                pprint({p.name: params.get(p.name) for p in self.hyperopt_space('sell')},
+                       indent=4)
+            if self.has_space('roi'):
+                print("ROI table:")
+                pprint(self.custom_hyperopt.generate_roi_table(params), indent=4)
+            if self.has_space('stoploss'):
+                print(f"Stoploss: {params.get('stoploss')}")
 
     def log_results(self, results) -> None:
         """
         Log results if it is better than any previous evaluation
         """
-        if results['loss'] < self.current_best_loss:
+        print_all = self.config.get('print_all', False)
-            current = results['current_tries']
+        is_best_loss = results['loss'] < self.current_best_loss
-            total = results['total_tries']
+        if print_all or is_best_loss:
-            res = results['result']
+            if is_best_loss:
-            loss = results['loss']
+                self.current_best_loss = results['loss']
-            self.current_best_loss = results['loss']
+            log_str = self.format_results_logstring(results)
-            log_msg = f'\n{current:5d}/{total}: {res}. Loss {loss:.5f}'
+            # Colorize output
-            print(log_msg)
+            if self.config.get('print_colorized', False):
+                if results['total_profit'] > 0:
+                    log_str = Fore.GREEN + log_str
+                if print_all and is_best_loss:
+                    log_str = Style.BRIGHT + log_str
+            if print_all:
+                print(log_str)
+            else:
+                print('\n' + log_str)
         else:
             print('.', end='')
             sys.stdout.flush()
 
-    def calculate_loss(self, total_profit: float, trade_count: int, trade_duration: float) -> float:
+    def format_results_logstring(self, results) -> str:
-        """
+        # Output human-friendly index here (starting from 1)
-        Objective function, returns smaller number for more optimal results
+        current = results['current_epoch'] + 1
-        """
+        total = self.total_epochs
-        trade_loss = 1 - 0.25 * exp(-(trade_count - self.target_trades) ** 2 / 10 ** 5.8)
+        res = results['results_explanation']
-        profit_loss = max(0, 1 - total_profit / self.expected_max_profit)
+        loss = results['loss']
-        duration_loss = 0.4 * min(trade_duration / self.max_accepted_trade_duration, 1)
+        log_str = f'{current:5d}/{total}: {res} Objective: {loss:.5f}'
-        result = trade_loss + profit_loss + duration_loss
+        log_str = f'*{log_str}' if results['is_initial_point'] else f' {log_str}'
-        return result
+        return log_str
 
     def has_space(self, space: str) -> bool:
         """
         Tell if a space value is contained in the configuration
         """
-        if space in self.config['spaces'] or 'all' in self.config['spaces']:
+        return any(s in self.config['spaces'] for s in [space, 'all'])
-            return True
-        return False
 
-    def hyperopt_space(self) -> List[Dimension]:
+    def hyperopt_space(self, space: Optional[str] = None) -> List[Dimension]:
         """
-        Return the space to use during Hyperopt
+        Return the dimensions in the hyperoptimization space.
+        :param space: Defines hyperspace to return dimensions for.
+        If None, then the self.has_space() will be used to return dimensions
+        for all hyperspaces used.
         """
         spaces: List[Dimension] = []
-        if self.has_space('buy'):
+        if space == 'buy' or (space is None and self.has_space('buy')):
+            logger.debug("Hyperopt has 'buy' space")
             spaces += self.custom_hyperopt.indicator_space()
-        if self.has_space('roi'):
+        if space == 'sell' or (space is None and self.has_space('sell')):
+            logger.debug("Hyperopt has 'sell' space")
+            spaces += self.custom_hyperopt.sell_indicator_space()
+        if space == 'roi' or (space is None and self.has_space('roi')):
+            logger.debug("Hyperopt has 'roi' space")
             spaces += self.custom_hyperopt.roi_space()
-        if self.has_space('stoploss'):
+        if space == 'stoploss' or (space is None and self.has_space('stoploss')):
+            logger.debug("Hyperopt has 'stoploss' space")
             spaces += self.custom_hyperopt.stoploss_space()
         return spaces
 
     def generate_optimizer(self, _params: Dict) -> Dict:
+        """
+        Used Optimize function. Called once per epoch to optimize whatever is configured.
+        Keep this function as optimized as possible!
+        """
         params = self.get_args(_params)
         if self.has_space('roi'):
-            self.strategy.minimal_roi = self.custom_hyperopt.generate_roi_table(params)
+            self.backtesting.strategy.minimal_roi = self.custom_hyperopt.generate_roi_table(params)
 
         if self.has_space('buy'):
-            self.advise_buy = self.custom_hyperopt.buy_strategy_generator(params)
+            self.backtesting.advise_buy = self.custom_hyperopt.buy_strategy_generator(params)
+
+        if self.has_space('sell'):
+            self.backtesting.advise_sell = self.custom_hyperopt.sell_strategy_generator(params)
 
         if self.has_space('stoploss'):
-            self.strategy.stoploss = params['stoploss']
+            self.backtesting.strategy.stoploss = params['stoploss']
+
+        processed = load(self.tickerdata_pickle)
 
-        processed = load(TICKERDATA_PICKLE)
         min_date, max_date = get_timeframe(processed)
-        results = self.backtest(
+
+        results = self.backtesting.backtest(
             {
                 'stake_amount': self.config['stake_amount'],
                 'processed': processed,
-                'position_stacking': self.config.get('position_stacking', True),
+                'max_open_trades': self.max_open_trades,
+                'position_stacking': self.position_stacking,
                 'start_date': min_date,
                 'end_date': max_date,
             }
         )
-        result_explanation = self.format_results(results)
+        results_explanation = self.format_results(results)
 
-        total_profit = results.profit_percent.sum()
         trade_count = len(results.index)
-        trade_duration = results.trade_duration.mean()
+        total_profit = results.profit_abs.sum()
 
-        if trade_count == 0:
+        # If this evaluation contains too short amount of trades to be
+        # interesting -- consider it as 'bad' (assigned max. loss value)
+        # in order to cast this hyperspace point away from optimization
+        # path. We do not want to optimize 'hodl' strategies.
+        if trade_count < self.config['hyperopt_min_trades']:
             return {
                 'loss': MAX_LOSS,
                 'params': params,
-                'result': result_explanation,
+                'results_explanation': results_explanation,
+                'total_profit': total_profit,
             }
 
-        loss = self.calculate_loss(total_profit, trade_count, trade_duration)
+        loss = self.calculate_loss(results=results, trade_count=trade_count,
+                                   min_date=min_date.datetime, max_date=max_date.datetime)
 
         return {
             'loss': loss,
             'params': params,
-            'result': result_explanation,
+            'results_explanation': results_explanation,
+            'total_profit': total_profit,
         }
 
     def format_results(self, results: DataFrame) -> str:
         """
-        Return the format result in a string
+        Return the formatted results explanation in a string
         """
         trades = len(results.index)
         avg_profit = results.profit_percent.mean() * 100.0
         total_profit = results.profit_abs.sum()
         stake_cur = self.config['stake_currency']
-        profit = results.profit_percent.sum()
+        profit = results.profit_percent.sum() * 100.0
         duration = results.trade_duration.mean()
 
         return (f'{trades:6d} trades. Avg profit {avg_profit: 5.2f}%. '
                 f'Total profit {total_profit: 11.8f} {stake_cur} '
-                f'({profit:.4f}Σ%). Avg duration {duration:5.1f} mins.')
+                f'({profit: 7.2f}Σ%). Avg duration {duration:5.1f} mins.')
 
     def get_optimizer(self, cpu_count) -> Optimizer:
         return Optimizer(
             self.hyperopt_space(),
             base_estimator="ET",
             acq_optimizer="auto",
-            n_initial_points=30,
+            n_initial_points=INITIAL_POINTS,
-            acq_optimizer_kwargs={'n_jobs': cpu_count}
+            acq_optimizer_kwargs={'n_jobs': cpu_count},
+            random_state=self.config.get('hyperopt_random_state', None)
         )
 
     def run_optimizer_parallel(self, parallel, asked) -> List:
@@ -230,7 +334,7 @@ class Hyperopt(Backtesting):
 
     def load_previous_results(self):
         """ read trials file if we have one """
-        if os.path.exists(self.trials_file) and os.path.getsize(self.trials_file) > 0:
+        if self.trials_file.is_file() and self.trials_file.stat().st_size > 0:
             self.trials = self.read_trials()
             logger.info(
                 'Loaded %d previous evaluations from disk.',
@@ -238,75 +342,71 @@ class Hyperopt(Backtesting):
             )
 
     def start(self) -> None:
-        timerange = Arguments.parse_timerange(None if self.config.get(
+        timerange = TimeRange.parse_timerange(None if self.config.get(
             'timerange') is None else str(self.config.get('timerange')))
         data = load_data(
             datadir=Path(self.config['datadir']) if self.config.get('datadir') else None,
             pairs=self.config['exchange']['pair_whitelist'],
-            ticker_interval=self.ticker_interval,
+            ticker_interval=self.backtesting.ticker_interval,
+            refresh_pairs=self.config.get('refresh_pairs', False),
+            exchange=self.backtesting.exchange,
             timerange=timerange
         )
 
-        if self.has_space('buy'):
+        if not data:
-            self.strategy.advise_indicators = \
+            logger.critical("No data found. Terminating.")
-                self.custom_hyperopt.populate_indicators  # type: ignore
+            return
-        dump(self.strategy.tickerdata_to_dataframe(data), TICKERDATA_PICKLE)
+
-        self.exchange = None  # type: ignore
+        min_date, max_date = get_timeframe(data)
+
+        logger.info(
+            'Hyperopting with data from %s up to %s (%s days)..',
+            min_date.isoformat(),
+            max_date.isoformat(),
+            (max_date - min_date).days
+        )
+
+        self.backtesting.strategy.advise_indicators = \
+            self.custom_hyperopt.populate_indicators  # type: ignore
+
+        preprocessed = self.backtesting.strategy.tickerdata_to_dataframe(data)
+
+        dump(preprocessed, self.tickerdata_pickle)
+
+        # We don't need exchange instance anymore while running hyperopt
+        self.backtesting.exchange = None  # type: ignore
+
         self.load_previous_results()
 
-        cpus = multiprocessing.cpu_count()
+        cpus = cpu_count()
         logger.info(f'Found {cpus} CPU cores. Let\'s make them scream!')
+        config_jobs = self.config.get('hyperopt_jobs', -1)
+        logger.info(f'Number of parallel jobs set as: {config_jobs}')
+
+        opt = self.get_optimizer(config_jobs)
+
+        if self.config.get('print_colorized', False):
+            colorama_init(autoreset=True)
 
-        opt = self.get_optimizer(cpus)
-        EVALS = max(self.total_tries // cpus, 1)
         try:
-            with Parallel(n_jobs=cpus) as parallel:
+            with Parallel(n_jobs=config_jobs) as parallel:
+                jobs = parallel._effective_n_jobs()
+                logger.info(f'Effective number of parallel workers used: {jobs}')
+                EVALS = max(self.total_epochs // jobs, 1)
                 for i in range(EVALS):
-                    asked = opt.ask(n_points=cpus)
+                    asked = opt.ask(n_points=jobs)
                     f_val = self.run_optimizer_parallel(parallel, asked)
-                    opt.tell(asked, [i['loss'] for i in f_val])
+                    opt.tell(asked, [v['loss'] for v in f_val])
-
+                    for j in range(jobs):
-                    self.trials += f_val
+                        current = i * jobs + j
-                    for j in range(cpus):
+                        val = f_val[j]
-                        self.log_results({
+                        val['current_epoch'] = current
-                            'loss': f_val[j]['loss'],
+                        val['is_initial_point'] = current < INITIAL_POINTS
-                            'current_tries': i * cpus + j,
+                        self.log_results(val)
-                            'total_tries': self.total_tries,
+                        self.trials.append(val)
-                            'result': f_val[j]['result'],
+                        logger.debug(f"Optimizer epoch evaluated: {val}")
-                        })
         except KeyboardInterrupt:
             print('User interrupted..')
 
         self.save_trials()
         self.log_trials_result()
-
-
-def start(args: Namespace) -> None:
-    """
-    Start Backtesting script
-    :param args: Cli args from Arguments()
-    :return: None
-    """
-
-    # Remove noisy log messages
-    logging.getLogger('hyperopt.tpe').setLevel(logging.WARNING)
-
-    # Initialize configuration
-    # Monkey patch the configuration with hyperopt_conf.py
-    configuration = Configuration(args)
-    logger.info('Starting freqtrade in Hyperopt mode')
-    config = configuration.load_config()
-
-    config['exchange']['key'] = ''
-    config['exchange']['secret'] = ''
-
-    if config.get('strategy') and config.get('strategy') != 'DefaultStrategy':
-        logger.error("Please don't use --strategy for hyperopt.")
-        logger.error(
-            "Read the documentation at "
-            "https://github.com/freqtrade/freqtrade/blob/develop/docs/hyperopt.md "
-            "to understand how to configure hyperopt.")
-        raise ValueError("--strategy configured but not supported for hyperopt")
-    # Initialize backtesting object
-    hyperopt = Hyperopt(config)
-    hyperopt.start()

freqtrade/optimize/hyperopt_interface.py

@@ -7,7 +7,7 @@ from abc import ABC, abstractmethod
 from typing import Dict, Any, Callable, List
 
 from pandas import DataFrame
-from skopt.space import Dimension
+from skopt.space import Dimension, Integer, Real
 
 
 class IHyperOpt(ABC):
@@ -20,47 +20,86 @@ class IHyperOpt(ABC):
         stoploss -> float: optimal stoploss designed for the strategy
         ticker_interval -> int: value of the ticker interval to use for the strategy
     """
+    ticker_interval: str
 
     @staticmethod
     @abstractmethod
     def populate_indicators(dataframe: DataFrame, metadata: dict) -> DataFrame:
         """
-        Populate indicators that will be used in the Buy and Sell strategy
+        Populate indicators that will be used in the Buy and Sell strategy.
-        :param dataframe: Raw data from the exchange and parsed by parse_ticker_dataframe()
+        :param dataframe: Raw data from the exchange and parsed by parse_ticker_dataframe().
-        :return: a Dataframe with all mandatory indicators for the strategies
+        :return: A Dataframe with all mandatory indicators for the strategies.
         """
 
     @staticmethod
     @abstractmethod
     def buy_strategy_generator(params: Dict[str, Any]) -> Callable:
         """
-        Create a buy strategy generator
+        Create a buy strategy generator.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def sell_strategy_generator(params: Dict[str, Any]) -> Callable:
+        """
+        Create a sell strategy generator.
         """
 
     @staticmethod
     @abstractmethod
     def indicator_space() -> List[Dimension]:
         """
-        Create an indicator space
+        Create an indicator space.
         """
 
     @staticmethod
     @abstractmethod
+    def sell_indicator_space() -> List[Dimension]:
+        """
+        Create a sell indicator space.
+        """
+
+    @staticmethod
     def generate_roi_table(params: Dict) -> Dict[int, float]:
         """
-        Create an roi table
+        Create a ROI table.
+
+        Generates the ROI table that will be used by Hyperopt.
+        You may override it in your custom Hyperopt class.
         """
+        roi_table = {}
+        roi_table[0] = params['roi_p1'] + params['roi_p2'] + params['roi_p3']
+        roi_table[params['roi_t3']] = params['roi_p1'] + params['roi_p2']
+        roi_table[params['roi_t3'] + params['roi_t2']] = params['roi_p1']
+        roi_table[params['roi_t3'] + params['roi_t2'] + params['roi_t1']] = 0
+
+        return roi_table
 
     @staticmethod
-    @abstractmethod
     def stoploss_space() -> List[Dimension]:
         """
-        Create a stoploss space
+        Create a stoploss space.
+
+        Defines range of stoploss values to search.
+        You may override it in your custom Hyperopt class.
         """
+        return [
+            Real(-0.5, -0.02, name='stoploss'),
+        ]
 
     @staticmethod
-    @abstractmethod
     def roi_space() -> List[Dimension]:
         """
-        Create a roi space
+        Create a ROI space.
+
+        Defines values to search for each ROI steps.
+        You may override it in your custom Hyperopt class.
         """
+        return [
+            Integer(10, 120, name='roi_t1'),
+            Integer(10, 60, name='roi_t2'),
+            Integer(10, 40, name='roi_t3'),
+            Real(0.01, 0.04, name='roi_p1'),
+            Real(0.01, 0.07, name='roi_p2'),
+            Real(0.01, 0.20, name='roi_p3'),
+        ]

freqtrade/optimize/hyperopt_loss_interface.py

@@ -0,0 +1,25 @@
+"""
+IHyperOptLoss interface
+This module defines the interface for the loss-function for hyperopts
+"""
+
+from abc import ABC, abstractmethod
+from datetime import datetime
+
+from pandas import DataFrame
+
+
+class IHyperOptLoss(ABC):
+    """
+    Interface for freqtrade hyperopts Loss functions.
+    Defines the custom loss function (`hyperopt_loss_function()` which is evaluated every epoch.)
+    """
+    ticker_interval: str
+
+    @staticmethod
+    @abstractmethod
+    def hyperopt_loss_function(results: DataFrame, trade_count: int,
+                               min_date: datetime, max_date: datetime, *args, **kwargs) -> float:
+        """
+        Objective function, returns smaller number for better results
+        """

freqtrade/optimize/hyperopt_loss_onlyprofit.py

@@ -0,0 +1,38 @@
+"""
+OnlyProfitHyperOptLoss
+
+This module defines the alternative HyperOptLoss class which can be used for
+Hyperoptimization.
+"""
+from pandas import DataFrame
+
+from freqtrade.optimize.hyperopt import IHyperOptLoss
+
+
+# This is assumed to be expected avg profit * expected trade count.
+# For example, for 0.35% avg per trade (or 0.0035 as ratio) and 1100 trades,
+# expected max profit = 3.85
+#
+# Note, this is ratio. 3.85 stated above means 385Σ%, 3.0 means 300Σ%.
+#
+# In this implementation it's only used in calculation of the resulting value
+# of the objective function as a normalization coefficient and does not
+# represent any limit for profits as in the Freqtrade legacy default loss function.
+EXPECTED_MAX_PROFIT = 3.0
+
+
+class OnlyProfitHyperOptLoss(IHyperOptLoss):
+    """
+    Defines the loss function for hyperopt.
+
+    This implementation takes only profit into account.
+    """
+
+    @staticmethod
+    def hyperopt_loss_function(results: DataFrame, trade_count: int,
+                               *args, **kwargs) -> float:
+        """
+        Objective function, returns smaller number for better results.
+        """
+        total_profit = results.profit_percent.sum()
+        return 1 - total_profit / EXPECTED_MAX_PROFIT

freqtrade/optimize/hyperopt_loss_sharpe.py

@@ -0,0 +1,45 @@
+"""
+SharpeHyperOptLoss
+
+This module defines the alternative HyperOptLoss class which can be used for
+Hyperoptimization.
+"""
+from datetime import datetime
+
+from pandas import DataFrame
+import numpy as np
+
+from freqtrade.optimize.hyperopt import IHyperOptLoss
+
+
+class SharpeHyperOptLoss(IHyperOptLoss):
+    """
+    Defines the loss function for hyperopt.
+
+    This implementation uses the Sharpe Ratio calculation.
+    """
+
+    @staticmethod
+    def hyperopt_loss_function(results: DataFrame, trade_count: int,
+                               min_date: datetime, max_date: datetime,
+                               *args, **kwargs) -> float:
+        """
+        Objective function, returns smaller number for more optimal results.
+
+        Uses Sharpe Ratio calculation.
+        """
+        total_profit = results.profit_percent
+        days_period = (max_date - min_date).days
+
+        # adding slippage of 0.1% per trade
+        total_profit = total_profit - 0.0005
+        expected_yearly_return = total_profit.sum() / days_period
+
+        if (np.std(total_profit) != 0.):
+            sharp_ratio = expected_yearly_return / np.std(total_profit) * np.sqrt(365)
+        else:
+            # Define high (negative) sharpe ratio to be clear that this is NOT optimal.
+            sharp_ratio = -20.
+
+        # print(expected_yearly_return, np.std(total_profit), sharp_ratio)
+        return -sharp_ratio

freqtrade/pairlist/IPairList.py

@@ -60,32 +60,27 @@ class IPairList(ABC):
     def _validate_whitelist(self, whitelist: List[str]) -> List[str]:
         """
         Check available markets and remove pair from whitelist if necessary
-        :param whitelist: the sorted list (based on BaseVolume) of pairs the user might want to
+        :param whitelist: the sorted list of pairs the user might want to trade
-        trade
+        :return: the list of pairs the user wants to trade without those unavailable or
-        :return: the list of pairs the user wants to trade without the one unavailable or
         black_listed
         """
-        sanitized_whitelist = whitelist
+        markets = self._freqtrade.exchange.markets
-        markets = self._freqtrade.exchange.get_markets()
 
-        # Filter to markets in stake currency
+        sanitized_whitelist = set()
-        markets = [m for m in markets if m['quote'] == self._config['stake_currency']]
+        for pair in whitelist:
-        known_pairs = set()
+            # pair is not in the generated dynamic market, or in the blacklist ... ignore it
-
+            if (pair in self.blacklist or pair not in markets
-        for market in markets:
+                    or not pair.endswith(self._config['stake_currency'])):
-            pair = market['symbol']
+                logger.warning(f"Pair {pair} is not compatible with exchange "
-            # pair is not int the generated dynamic market, or in the blacklist ... ignore it
+                               f"{self._freqtrade.exchange.name} or contained in "
-            if pair not in whitelist or pair in self.blacklist:
+                               f"your blacklist. Removing it from whitelist..")
                 continue
-            # else the pair is valid
+            # Check if market is active
-            known_pairs.add(pair)
+            market = markets[pair]
-            # Market is not active
             if not market['active']:
-                sanitized_whitelist.remove(pair)
+                logger.info(f"Ignoring {pair} from whitelist. Market is not active.")
-                logger.info(
+                continue
-                    'Ignoring %s from whitelist. Market is not active.',
+            sanitized_whitelist.add(pair)
-                    pair
-                )
 
         # We need to remove pairs that are unknown
-        return [x for x in sanitized_whitelist if x in known_pairs]
+        return list(sanitized_whitelist)

freqtrade/pairlist/VolumePairList.py

@@ -1,5 +1,5 @@
 """
-Static List provider
+Volume PairList provider
 
 Provides lists as configured in config.json
 
@@ -26,6 +26,7 @@ class VolumePairList(IPairList):
                 'for "pairlist.config.number_assets"')
         self._number_pairs = self._whitelistconf['number_assets']
         self._sort_key = self._whitelistconf.get('sort_key', 'quoteVolume')
+        self._precision_filter = self._whitelistconf.get('precision_filter', False)
 
         if not self._freqtrade.exchange.exchange_has('fetchTickers'):
             raise OperationalException(
@@ -52,9 +53,8 @@ class VolumePairList(IPairList):
         -> Please overwrite in subclasses
         """
         # Generate dynamic whitelist
-        pairs = self._gen_pair_whitelist(self._config['stake_currency'], self._sort_key)
+        self._whitelist = self._gen_pair_whitelist(
-        # Validate whitelist to only have active market pairs
+            self._config['stake_currency'], self._sort_key)[:self._number_pairs]
-        self._whitelist = self._validate_whitelist(pairs)[:self._number_pairs]
 
     @cached(TTLCache(maxsize=1, ttl=1800))
     def _gen_pair_whitelist(self, base_currency: str, key: str) -> List[str]:
@@ -68,8 +68,29 @@ class VolumePairList(IPairList):
         tickers = self._freqtrade.exchange.get_tickers()
         # check length so that we make sure that '/' is actually in the string
         tickers = [v for k, v in tickers.items()
-                   if len(k.split('/')) == 2 and k.split('/')[1] == base_currency]
+                   if (len(k.split('/')) == 2 and k.split('/')[1] == base_currency
-
+                       and v[key] is not None)]
         sorted_tickers = sorted(tickers, reverse=True, key=lambda t: t[key])
-        pairs = [s['symbol'] for s in sorted_tickers]
+        # Validate whitelist to only have active market pairs
+        valid_pairs = self._validate_whitelist([s['symbol'] for s in sorted_tickers])
+        valid_tickers = [t for t in sorted_tickers if t["symbol"] in valid_pairs]
+
+        if self._freqtrade.strategy.stoploss is not None and self._precision_filter:
+
+            stop_prices = [self._freqtrade.get_target_bid(t["symbol"], t)
+                           * (1 - abs(self._freqtrade.strategy.stoploss)) for t in valid_tickers]
+            rates = [sp * 0.99 for sp in stop_prices]
+            logger.debug("\n".join([f"{sp} : {r}" for sp, r in zip(stop_prices[:10], rates[:10])]))
+            for i, t in enumerate(valid_tickers):
+                sp = self._freqtrade.exchange.symbol_price_prec(t["symbol"], stop_prices[i])
+                r = self._freqtrade.exchange.symbol_price_prec(t["symbol"], rates[i])
+                logger.debug(f"{t['symbol']} - {sp} : {r}")
+                if sp <= r:
+                    logger.info(f"Removed {t['symbol']} from whitelist, "
+                                f"because stop price {sp} would be <= stop limit {r}")
+                    valid_tickers.remove(t)
+
+        pairs = [s['symbol'] for s in valid_tickers]
+        logger.info(f"Searching pairs: {self._whitelist}")
+
         return pairs

freqtrade/persistence.py

@@ -5,7 +5,7 @@ This module contains the class to persist trades into SQLite
 import logging
 from datetime import datetime
 from decimal import Decimal
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 import arrow
 from sqlalchemy import (Boolean, Column, DateTime, Float, Integer, String,
@@ -25,15 +25,16 @@ _DECL_BASE: Any = declarative_base()
 _SQL_DOCS_URL = 'http://docs.sqlalchemy.org/en/latest/core/engines.html#database-urls'
 
 
-def init(config: Dict) -> None:
+def init(db_url: str, clean_open_orders: bool = False) -> None:
     """
     Initializes this module with the given config,
     registers all known command handlers
     and starts polling for message updates
-    :param config: config to use
+    :param db_url: Database to use
+    :param clean_open_orders: Remove open orders from the database.
+        Useful for dry-run or if all orders have been reset on the exchange.
     :return: None
     """
-    db_url = config.get('db_url', None)
     kwargs = {}
 
     # Take care of thread ownership if in-memory db
@@ -57,7 +58,7 @@ def init(config: Dict) -> None:
     check_migrate(engine)
 
     # Clean dry_run DB if the db is not in-memory
-    if config.get('dry_run', False) and db_url != 'sqlite://':
+    if clean_open_orders and db_url != 'sqlite://':
         clean_dry_run_db()
 
 
@@ -83,7 +84,7 @@ def check_migrate(engine) -> None:
         logger.debug(f'trying {table_back_name}')
 
     # Check for latest column
-    if not has_column(cols, 'stoploss_order_id'):
+    if not has_column(cols, 'stop_loss_pct'):
         logger.info(f'Running database migration - backup available as {table_back_name}')
 
         fee_open = get_column_def(cols, 'fee_open', 'fee')
@@ -91,9 +92,13 @@ def check_migrate(engine) -> None:
         open_rate_requested = get_column_def(cols, 'open_rate_requested', 'null')
         close_rate_requested = get_column_def(cols, 'close_rate_requested', 'null')
         stop_loss = get_column_def(cols, 'stop_loss', '0.0')
+        stop_loss_pct = get_column_def(cols, 'stop_loss_pct', 'null')
         initial_stop_loss = get_column_def(cols, 'initial_stop_loss', '0.0')
+        initial_stop_loss_pct = get_column_def(cols, 'initial_stop_loss_pct', 'null')
         stoploss_order_id = get_column_def(cols, 'stoploss_order_id', 'null')
+        stoploss_last_update = get_column_def(cols, 'stoploss_last_update', 'null')
         max_rate = get_column_def(cols, 'max_rate', '0.0')
+        min_rate = get_column_def(cols, 'min_rate', 'null')
         sell_reason = get_column_def(cols, 'sell_reason', 'null')
         strategy = get_column_def(cols, 'strategy', 'null')
         ticker_interval = get_column_def(cols, 'ticker_interval', 'null')
@@ -111,7 +116,9 @@ def check_migrate(engine) -> None:
                 (id, exchange, pair, is_open, fee_open, fee_close, open_rate,
                 open_rate_requested, close_rate, close_rate_requested, close_profit,
                 stake_amount, amount, open_date, close_date, open_order_id,
-                stop_loss, initial_stop_loss, stoploss_order_id, max_rate, sell_reason, strategy,
+                stop_loss, stop_loss_pct, initial_stop_loss, initial_stop_loss_pct,
+                stoploss_order_id, stoploss_last_update,
+                max_rate, min_rate, sell_reason, strategy,
                 ticker_interval
                 )
             select id, lower(exchange),
@@ -126,10 +133,12 @@ def check_migrate(engine) -> None:
                 open_rate, {open_rate_requested} open_rate_requested, close_rate,
                 {close_rate_requested} close_rate_requested, close_profit,
                 stake_amount, amount, open_date, close_date, open_order_id,
-                {stop_loss} stop_loss, {initial_stop_loss} initial_stop_loss,
+                {stop_loss} stop_loss, {stop_loss_pct} stop_loss_pct,
-                {stoploss_order_id} stoploss_order_id, {max_rate} max_rate,
+                {initial_stop_loss} initial_stop_loss,
-                {sell_reason} sell_reason, {strategy} strategy,
+                {initial_stop_loss_pct} initial_stop_loss_pct,
-                {ticker_interval} ticker_interval
+                {stoploss_order_id} stoploss_order_id, {stoploss_last_update} stoploss_last_update,
+                {max_rate} max_rate, {min_rate} min_rate, {sell_reason} sell_reason,
+                {strategy} strategy, {ticker_interval} ticker_interval
                 from {table_back_name}
              """)
 
@@ -181,12 +190,20 @@ class Trade(_DECL_BASE):
     open_order_id = Column(String)
     # absolute value of the stop loss
     stop_loss = Column(Float, nullable=True, default=0.0)
+    # percentage value of the stop loss
+    stop_loss_pct = Column(Float, nullable=True)
     # absolute value of the initial stop loss
     initial_stop_loss = Column(Float, nullable=True, default=0.0)
+    # percentage value of the initial stop loss
+    initial_stop_loss_pct = Column(Float, nullable=True)
     # stoploss order id which is on exchange
     stoploss_order_id = Column(String, nullable=True, index=True)
+    # last update time of the stoploss order on exchange
+    stoploss_last_update = Column(DateTime, nullable=True)
     # absolute value of the highest reached price
     max_rate = Column(Float, nullable=True, default=0.0)
+    # Lowest price reached
+    min_rate = Column(Float, nullable=True)
     sell_reason = Column(String, nullable=True)
     strategy = Column(String, nullable=True)
     ticker_interval = Column(Integer, nullable=True)
@@ -197,8 +214,42 @@ class Trade(_DECL_BASE):
         return (f'Trade(id={self.id}, pair={self.pair}, amount={self.amount:.8f}, '
                 f'open_rate={self.open_rate:.8f}, open_since={open_since})')
 
+    def to_json(self) -> Dict[str, Any]:
+        return {
+            'trade_id': self.id,
+            'pair': self.pair,
+            'open_date_hum': arrow.get(self.open_date).humanize(),
+            'open_date': self.open_date.strftime("%Y-%m-%d %H:%M:%S"),
+            'close_date_hum': (arrow.get(self.close_date).humanize()
+                               if self.close_date else None),
+            'close_date': (self.close_date.strftime("%Y-%m-%d %H:%M:%S")
+                           if self.close_date else None),
+            'open_rate': self.open_rate,
+            'close_rate': self.close_rate,
+            'amount': round(self.amount, 8),
+            'stake_amount': round(self.stake_amount, 8),
+            'stop_loss': self.stop_loss,
+            'stop_loss_pct': (self.stop_loss_pct * 100) if self.stop_loss_pct else None,
+            'initial_stop_loss': self.initial_stop_loss,
+            'initial_stop_loss_pct': (self.initial_stop_loss_pct * 100
+                                      if self.initial_stop_loss_pct else None),
+        }
+
+    def adjust_min_max_rates(self, current_price: float):
+        """
+        Adjust the max_rate and min_rate.
+        """
+        self.max_rate = max(current_price, self.max_rate or self.open_rate)
+        self.min_rate = min(current_price, self.min_rate or self.open_rate)
+
     def adjust_stop_loss(self, current_price: float, stoploss: float, initial: bool = False):
-        """this adjusts the stop loss to it's most recently observed setting"""
+        """
+        This adjusts the stop loss to it's most recently observed setting
+        :param current_price: Current rate the asset is traded
+        :param stoploss: Stoploss as factor (sample -0.05 -> -5% below current price).
+        :param initial: Called to initiate stop_loss.
+            Skips everything if self.stop_loss is already set.
+        """
 
         if initial and not (self.stop_loss is None or self.stop_loss == 0):
             # Don't modify if called with initial and nothing to do
@@ -206,23 +257,21 @@ class Trade(_DECL_BASE):
 
         new_loss = float(current_price * (1 - abs(stoploss)))
 
-        # keeping track of the highest observed rate for this trade
-        if self.max_rate is None:
-            self.max_rate = current_price
-        else:
-            if current_price > self.max_rate:
-                self.max_rate = current_price
-
         # no stop loss assigned yet
         if not self.stop_loss:
             logger.debug("assigning new stop loss")
             self.stop_loss = new_loss
+            self.stop_loss_pct = -1 * abs(stoploss)
             self.initial_stop_loss = new_loss
+            self.initial_stop_loss_pct = -1 * abs(stoploss)
+            self.stoploss_last_update = datetime.utcnow()
 
         # evaluate if the stop loss needs to be updated
         else:
             if new_loss > self.stop_loss:  # stop losses only walk up, never down!
                 self.stop_loss = new_loss
+                self.stop_loss_pct = -1 * abs(stoploss)
+                self.stoploss_last_update = datetime.utcnow()
                 logger.debug("adjusted stop loss")
             else:
                 logger.debug("keeping current stop loss")
@@ -260,6 +309,7 @@ class Trade(_DECL_BASE):
             logger.info('%s_SELL has been fulfilled for %s.', order_type.upper(), self)
         elif order_type == 'stop_loss_limit':
             self.stoploss_order_id = None
+            self.close_rate_requested = self.stop_loss
             logger.info('STOP_LOSS_LIMIT is hit for %s.', self)
             self.close(order['average'])
         else:
@@ -365,3 +415,29 @@ class Trade(_DECL_BASE):
             .filter(Trade.is_open.is_(True))\
             .scalar()
         return total_open_stake_amount or 0
+
+    @staticmethod
+    def get_open_trades() -> List[Any]:
+        """
+        Query trades from persistence layer
+        """
+        return Trade.query.filter(Trade.is_open.is_(True)).all()
+
+    @staticmethod
+    def stoploss_reinitialization(desired_stoploss):
+        """
+        Adjust initial Stoploss to desired stoploss for all open trades.
+        """
+        for trade in Trade.get_open_trades():
+            logger.info("Found open trade: %s", trade)
+
+            # skip case if trailing-stop changed the stoploss already.
+            if (trade.stop_loss == trade.initial_stop_loss
+               and trade.initial_stop_loss_pct != desired_stoploss):
+                # Stoploss value got changed
+
+                logger.info(f"Stoploss for {trade} needs adjustment.")
+                # Force reset of stoploss
+                trade.stop_loss = None
+                trade.adjust_stop_loss(trade.open_rate, desired_stoploss)
+                logger.info(f"new stoploss: {trade.stop_loss}, ")

freqtrade/plot/plotting.py

@@ -0,0 +1,323 @@
+import logging
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import pandas as pd
+
+from freqtrade.configuration import TimeRange
+from freqtrade.data import history
+from freqtrade.data.btanalysis import (combine_tickers_with_mean,
+                                       create_cum_profit, load_trades)
+from freqtrade.exchange import Exchange
+from freqtrade.resolvers import ExchangeResolver, StrategyResolver
+
+logger = logging.getLogger(__name__)
+
+
+try:
+    from plotly.subplots import make_subplots
+    from plotly.offline import plot
+    import plotly.graph_objects as go
+except ImportError:
+    logger.exception("Module plotly not found \n Please install using `pip install plotly`")
+    exit(1)
+
+
+def init_plotscript(config):
+    """
+    Initialize objects needed for plotting
+    :return: Dict with tickers, trades, pairs and strategy
+    """
+    exchange: Optional[Exchange] = None
+
+    # Exchange is only needed when downloading data!
+    if config.get("refresh_pairs", False):
+        exchange = ExchangeResolver(config.get('exchange', {}).get('name'),
+                                    config).exchange
+
+    strategy = StrategyResolver(config).strategy
+    if "pairs" in config:
+        pairs = config["pairs"]
+    else:
+        pairs = config["exchange"]["pair_whitelist"]
+
+    # Set timerange to use
+    timerange = TimeRange.parse_timerange(config.get("timerange"))
+
+    tickers = history.load_data(
+        datadir=Path(str(config.get("datadir"))),
+        pairs=pairs,
+        ticker_interval=config['ticker_interval'],
+        refresh_pairs=config.get('refresh_pairs', False),
+        timerange=timerange,
+        exchange=exchange,
+    )
+
+    trades = load_trades(config)
+    return {"tickers": tickers,
+            "trades": trades,
+            "pairs": pairs,
+            "strategy": strategy,
+            }
+
+
+def add_indicators(fig, row, indicators: List[str], data: pd.DataFrame) -> make_subplots:
+    """
+    Generator all the indicator selected by the user for a specific row
+    :param fig: Plot figure to append to
+    :param row: row number for this plot
+    :param indicators: List of indicators present in the dataframe
+    :param data: candlestick DataFrame
+    """
+    for indicator in indicators:
+        if indicator in data:
+            # TODO: Figure out why scattergl causes problems
+            scattergl = go.Scatter(
+                x=data['date'],
+                y=data[indicator].values,
+                mode='lines',
+                name=indicator
+            )
+            fig.add_trace(scattergl, row, 1)
+        else:
+            logger.info(
+                'Indicator "%s" ignored. Reason: This indicator is not found '
+                'in your strategy.',
+                indicator
+            )
+
+    return fig
+
+
+def add_profit(fig, row, data: pd.DataFrame, column: str, name: str) -> make_subplots:
+    """
+    Add profit-plot
+    :param fig: Plot figure to append to
+    :param row: row number for this plot
+    :param data: candlestick DataFrame
+    :param column: Column to use for plot
+    :param name: Name to use
+    :return: fig with added profit plot
+    """
+    profit = go.Scattergl(
+        x=data.index,
+        y=data[column],
+        name=name,
+    )
+    fig.add_trace(profit, row, 1)
+
+    return fig
+
+
+def plot_trades(fig, trades: pd.DataFrame) -> make_subplots:
+    """
+    Add trades to "fig"
+    """
+    # Trades can be empty
+    if trades is not None and len(trades) > 0:
+        trade_buys = go.Scatter(
+            x=trades["open_time"],
+            y=trades["open_rate"],
+            mode='markers',
+            name='trade_buy',
+            marker=dict(
+                symbol='square-open',
+                size=11,
+                line=dict(width=2),
+                color='green'
+            )
+        )
+        # Create description for sell summarizing the trade
+        desc = trades.apply(lambda row: f"{round(row['profitperc'], 3)}%, {row['sell_reason']}, "
+                                        f"{row['duration']}min",
+                            axis=1)
+        trade_sells = go.Scatter(
+            x=trades["close_time"],
+            y=trades["close_rate"],
+            text=desc,
+            mode='markers',
+            name='trade_sell',
+            marker=dict(
+                symbol='square-open',
+                size=11,
+                line=dict(width=2),
+                color='red'
+            )
+        )
+        fig.add_trace(trade_buys, 1, 1)
+        fig.add_trace(trade_sells, 1, 1)
+    else:
+        logger.warning("No trades found.")
+    return fig
+
+
+def generate_candlestick_graph(pair: str, data: pd.DataFrame, trades: pd.DataFrame = None,
+                               indicators1: List[str] = [],
+                               indicators2: List[str] = [],) -> go.Figure:
+    """
+    Generate the graph from the data generated by Backtesting or from DB
+    Volume will always be ploted in row2, so Row 1 and 3 are to our disposal for custom indicators
+    :param pair: Pair to Display on the graph
+    :param data: OHLCV DataFrame containing indicators and buy/sell signals
+    :param trades: All trades created
+    :param indicators1: List containing Main plot indicators
+    :param indicators2: List containing Sub plot indicators
+    :return: None
+    """
+
+    # Define the graph
+    fig = make_subplots(
+        rows=3,
+        cols=1,
+        shared_xaxes=True,
+        row_width=[1, 1, 4],
+        vertical_spacing=0.0001,
+    )
+    fig['layout'].update(title=pair)
+    fig['layout']['yaxis1'].update(title='Price')
+    fig['layout']['yaxis2'].update(title='Volume')
+    fig['layout']['yaxis3'].update(title='Other')
+    fig['layout']['xaxis']['rangeslider'].update(visible=False)
+
+    # Common information
+    candles = go.Candlestick(
+        x=data.date,
+        open=data.open,
+        high=data.high,
+        low=data.low,
+        close=data.close,
+        name='Price'
+    )
+    fig.add_trace(candles, 1, 1)
+
+    if 'buy' in data.columns:
+        df_buy = data[data['buy'] == 1]
+        if len(df_buy) > 0:
+            buys = go.Scatter(
+                x=df_buy.date,
+                y=df_buy.close,
+                mode='markers',
+                name='buy',
+                marker=dict(
+                    symbol='triangle-up-dot',
+                    size=9,
+                    line=dict(width=1),
+                    color='green',
+                )
+            )
+            fig.add_trace(buys, 1, 1)
+        else:
+            logger.warning("No buy-signals found.")
+
+    if 'sell' in data.columns:
+        df_sell = data[data['sell'] == 1]
+        if len(df_sell) > 0:
+            sells = go.Scatter(
+                x=df_sell.date,
+                y=df_sell.close,
+                mode='markers',
+                name='sell',
+                marker=dict(
+                    symbol='triangle-down-dot',
+                    size=9,
+                    line=dict(width=1),
+                    color='red',
+                )
+            )
+            fig.add_trace(sells, 1, 1)
+        else:
+            logger.warning("No sell-signals found.")
+
+    if 'bb_lowerband' in data and 'bb_upperband' in data:
+        bb_lower = go.Scattergl(
+            x=data.date,
+            y=data.bb_lowerband,
+            name='BB lower',
+            line={'color': 'rgba(255,255,255,0)'},
+        )
+        bb_upper = go.Scattergl(
+            x=data.date,
+            y=data.bb_upperband,
+            name='BB upper',
+            fill="tonexty",
+            fillcolor="rgba(0,176,246,0.2)",
+            line={'color': 'rgba(255,255,255,0)'},
+        )
+        fig.add_trace(bb_lower, 1, 1)
+        fig.add_trace(bb_upper, 1, 1)
+
+    # Add indicators to main plot
+    fig = add_indicators(fig=fig, row=1, indicators=indicators1, data=data)
+
+    fig = plot_trades(fig, trades)
+
+    # Volume goes to row 2
+    volume = go.Bar(
+        x=data['date'],
+        y=data['volume'],
+        name='Volume'
+    )
+    fig.add_trace(volume, 2, 1)
+
+    # Add indicators to seperate row
+    fig = add_indicators(fig=fig, row=3, indicators=indicators2, data=data)
+
+    return fig
+
+
+def generate_profit_graph(pairs: str, tickers: Dict[str, pd.DataFrame],
+                          trades: pd.DataFrame) -> go.Figure:
+    # Combine close-values for all pairs, rename columns to "pair"
+    df_comb = combine_tickers_with_mean(tickers, "close")
+
+    # Add combined cumulative profit
+    df_comb = create_cum_profit(df_comb, trades, 'cum_profit')
+
+    # Plot the pairs average close prices, and total profit growth
+    avgclose = go.Scattergl(
+        x=df_comb.index,
+        y=df_comb['mean'],
+        name='Avg close price',
+    )
+
+    fig = make_subplots(rows=3, cols=1, shared_xaxes=True, row_width=[1, 1, 1])
+    fig['layout'].update(title="Profit plot")
+
+    fig.add_trace(avgclose, 1, 1)
+    fig = add_profit(fig, 2, df_comb, 'cum_profit', 'Profit')
+
+    for pair in pairs:
+        profit_col = f'cum_profit_{pair}'
+        df_comb = create_cum_profit(df_comb, trades[trades['pair'] == pair], profit_col)
+
+        fig = add_profit(fig, 3, df_comb, profit_col, f"Profit {pair}")
+
+    return fig
+
+
+def generate_plot_filename(pair, ticker_interval) -> str:
+    """
+    Generate filenames per pair/ticker_interval to be used for storing plots
+    """
+    pair_name = pair.replace("/", "_")
+    file_name = 'freqtrade-plot-' + pair_name + '-' + ticker_interval + '.html'
+
+    logger.info('Generate plot file for %s', pair)
+
+    return file_name
+
+
+def store_plot_file(fig, filename: str, directory: Path, auto_open: bool = False) -> None:
+    """
+    Generate a plot html file from pre populated fig plotly object
+    :param fig: Plotly Figure to plot
+    :param pair: Pair to plot (used as filename and Plot title)
+    :param ticker_interval: Used as part of the filename
+    :return: None
+    """
+    directory.mkdir(parents=True, exist_ok=True)
+
+    _filename = directory.joinpath(filename)
+    plot(fig, filename=str(_filename),
+         auto_open=auto_open)
+    logger.info(f"Stored plot as {_filename}")

freqtrade/resolvers/__init__.py

@@ -1,4 +1,6 @@
 from freqtrade.resolvers.iresolver import IResolver  # noqa: F401
-from freqtrade.resolvers.hyperopt_resolver import HyperOptResolver  # noqa: F401
+from freqtrade.resolvers.exchange_resolver import ExchangeResolver  # noqa: F401
+# Don't import HyperoptResolver to avoid loading the whole Optimize tree
+# from freqtrade.resolvers.hyperopt_resolver import HyperOptResolver  # noqa: F401
 from freqtrade.resolvers.pairlist_resolver import PairListResolver  # noqa: F401
 from freqtrade.resolvers.strategy_resolver import StrategyResolver  # noqa: F401

freqtrade/resolvers/exchange_resolver.py

@@ -0,0 +1,57 @@
+"""
+This module loads custom exchanges
+"""
+import logging
+
+from freqtrade.exchange import Exchange
+import freqtrade.exchange as exchanges
+from freqtrade.resolvers import IResolver
+
+logger = logging.getLogger(__name__)
+
+
+class ExchangeResolver(IResolver):
+    """
+    This class contains all the logic to load a custom exchange class
+    """
+
+    __slots__ = ['exchange']
+
+    def __init__(self, exchange_name: str, config: dict) -> None:
+        """
+        Load the custom class from config parameter
+        :param config: configuration dictionary
+        """
+        exchange_name = exchange_name.title()
+        try:
+            self.exchange = self._load_exchange(exchange_name, kwargs={'config': config})
+        except ImportError:
+            logger.info(
+                f"No {exchange_name} specific subclass found. Using the generic class instead.")
+        if not hasattr(self, "exchange"):
+            self.exchange = Exchange(config)
+
+    def _load_exchange(
+            self, exchange_name: str, kwargs: dict) -> Exchange:
+        """
+        Loads the specified exchange.
+        Only checks for exchanges exported in freqtrade.exchanges
+        :param exchange_name: name of the module to import
+        :return: Exchange instance or None
+        """
+
+        try:
+            ex_class = getattr(exchanges, exchange_name)
+
+            exchange = ex_class(kwargs['config'])
+            if exchange:
+                logger.info(f"Using resolved exchange '{exchange_name}'...")
+                return exchange
+        except AttributeError:
+            # Pass and raise ImportError instead
+            pass
+
+        raise ImportError(
+            f"Impossible to load Exchange '{exchange_name}'. This class does not exist "
+            "or contains Python code errors."
+        )

freqtrade/resolvers/hyperopt_resolver.py

@@ -7,8 +7,10 @@ import logging
 from pathlib import Path
 from typing import Optional, Dict
 
-from freqtrade.constants import DEFAULT_HYPEROPT
+from freqtrade import OperationalException
+from freqtrade.constants import DEFAULT_HYPEROPT, DEFAULT_HYPEROPT_LOSS
 from freqtrade.optimize.hyperopt_interface import IHyperOpt
+from freqtrade.optimize.hyperopt_loss_interface import IHyperOptLoss
 from freqtrade.resolvers import IResolver
 
 logger = logging.getLogger(__name__)
@@ -21,7 +23,65 @@ class HyperOptResolver(IResolver):
 
     __slots__ = ['hyperopt']
 
-    def __init__(self, config: Optional[Dict] = None) -> None:
+    def __init__(self, config: Dict) -> None:
+        """
+        Load the custom class from config parameter
+        :param config: configuration dictionary
+        """
+
+        # Verify the hyperopt is in the configuration, otherwise fallback to the default hyperopt
+        hyperopt_name = config.get('hyperopt') or DEFAULT_HYPEROPT
+        self.hyperopt = self._load_hyperopt(hyperopt_name, config,
+                                            extra_dir=config.get('hyperopt_path'))
+
+        # Assign ticker_interval to be used in hyperopt
+        self.hyperopt.__class__.ticker_interval = str(config['ticker_interval'])
+
+        if not hasattr(self.hyperopt, 'populate_buy_trend'):
+            logger.warning("Custom Hyperopt does not provide populate_buy_trend. "
+                           "Using populate_buy_trend from DefaultStrategy.")
+        if not hasattr(self.hyperopt, 'populate_sell_trend'):
+            logger.warning("Custom Hyperopt does not provide populate_sell_trend. "
+                           "Using populate_sell_trend from DefaultStrategy.")
+
+    def _load_hyperopt(
+            self, hyperopt_name: str, config: Dict, extra_dir: Optional[str] = None) -> IHyperOpt:
+        """
+        Search and loads the specified hyperopt.
+        :param hyperopt_name: name of the module to import
+        :param config: configuration dictionary
+        :param extra_dir: additional directory to search for the given hyperopt
+        :return: HyperOpt instance or None
+        """
+        current_path = Path(__file__).parent.parent.joinpath('optimize').resolve()
+
+        abs_paths = [
+            config['user_data_dir'].joinpath('hyperopts'),
+            current_path,
+        ]
+
+        if extra_dir:
+            # Add extra hyperopt directory on top of search paths
+            abs_paths.insert(0, Path(extra_dir).resolve())
+
+        hyperopt = self._load_object(paths=abs_paths, object_type=IHyperOpt,
+                                     object_name=hyperopt_name)
+        if hyperopt:
+            return hyperopt
+        raise OperationalException(
+            f"Impossible to load Hyperopt '{hyperopt_name}'. This class does not exist "
+            "or contains Python code errors."
+        )
+
+
+class HyperOptLossResolver(IResolver):
+    """
+    This class contains all the logic to load custom hyperopt loss class
+    """
+
+    __slots__ = ['hyperoptloss']
+
+    def __init__(self, config: Dict = None) -> None:
         """
         Load the custom class from config parameter
         :param config: configuration dictionary or None
@@ -29,39 +89,44 @@ class HyperOptResolver(IResolver):
         config = config or {}
 
         # Verify the hyperopt is in the configuration, otherwise fallback to the default hyperopt
-        hyperopt_name = config.get('hyperopt') or DEFAULT_HYPEROPT
+        hyperopt_name = config.get('hyperopt_loss') or DEFAULT_HYPEROPT_LOSS
-        self.hyperopt = self._load_hyperopt(hyperopt_name, extra_dir=config.get('hyperopt_path'))
+        self.hyperoptloss = self._load_hyperoptloss(
+            hyperopt_name, config, extra_dir=config.get('hyperopt_path'))
 
-    def _load_hyperopt(
+        # Assign ticker_interval to be used in hyperopt
-            self, hyperopt_name: str, extra_dir: Optional[str] = None) -> IHyperOpt:
+        self.hyperoptloss.__class__.ticker_interval = str(config['ticker_interval'])
+
+        if not hasattr(self.hyperoptloss, 'hyperopt_loss_function'):
+            raise OperationalException(
+                f"Found hyperopt {hyperopt_name} does not implement `hyperopt_loss_function`.")
+
+    def _load_hyperoptloss(
+            self, hyper_loss_name: str, config: Dict,
+            extra_dir: Optional[str] = None) -> IHyperOptLoss:
         """
-        Search and loads the specified hyperopt.
+        Search and loads the specified hyperopt loss class.
-        :param hyperopt_name: name of the module to import
+        :param hyper_loss_name: name of the module to import
+        :param config: configuration dictionary
         :param extra_dir: additional directory to search for the given hyperopt
-        :return: HyperOpt instance or None
+        :return: HyperOptLoss instance or None
         """
         current_path = Path(__file__).parent.parent.joinpath('optimize').resolve()
 
         abs_paths = [
-            current_path.parent.parent.joinpath('user_data/hyperopts'),
+            config['user_data_dir'].joinpath('hyperopts'),
             current_path,
         ]
 
         if extra_dir:
             # Add extra hyperopt directory on top of search paths
-            abs_paths.insert(0, Path(extra_dir))
+            abs_paths.insert(0, Path(extra_dir).resolve())
 
-        for _path in abs_paths:
+        hyperoptloss = self._load_object(paths=abs_paths, object_type=IHyperOptLoss,
-            try:
+                                         object_name=hyper_loss_name)
-                hyperopt = self._search_object(directory=_path, object_type=IHyperOpt,
+        if hyperoptloss:
-                                               object_name=hyperopt_name)
+            return hyperoptloss
-                if hyperopt:
-                    logger.info('Using resolved hyperopt %s from \'%s\'', hyperopt_name, _path)
-                    return hyperopt
-            except FileNotFoundError:
-                logger.warning('Path "%s" does not exist', _path.relative_to(Path.cwd()))
 
-        raise ImportError(
+        raise OperationalException(
-            "Impossible to load Hyperopt '{}'. This class does not exist"
+            f"Impossible to load HyperoptLoss '{hyper_loss_name}'. This class does not exist "
-            " or contains Python code errors".format(hyperopt_name)
+            "or contains Python code errors."
         )

freqtrade/resolvers/iresolver.py

@@ -7,7 +7,7 @@ import importlib.util
 import inspect
 import logging
 from pathlib import Path
-from typing import Optional, Type, Any
+from typing import Any, List, Optional, Tuple, Type, Union
 
 logger = logging.getLogger(__name__)
 
@@ -29,9 +29,14 @@ class IResolver(object):
         """
 
         # Generate spec based on absolute path
-        spec = importlib.util.spec_from_file_location('unknown', str(module_path))
+        # Pass object_name as first argument to have logging print a reasonable name.
+        spec = importlib.util.spec_from_file_location(object_name, str(module_path))
         module = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(module)  # type: ignore # importlib does not use typehints
+        try:
+            spec.loader.exec_module(module)  # type: ignore # importlib does not use typehints
+        except (ModuleNotFoundError, SyntaxError) as err:
+            # Catch errors in case a specific module is not installed
+            logger.warning(f"Could not import {module_path} due to '{err}'")
 
         valid_objects_gen = (
             obj for name, obj in inspect.getmembers(module, inspect.isclass)
@@ -41,21 +46,45 @@ class IResolver(object):
 
     @staticmethod
     def _search_object(directory: Path, object_type, object_name: str,
-                       kwargs: dict = {}) -> Optional[Any]:
+                       kwargs: dict = {}) -> Union[Tuple[Any, Path], Tuple[None, None]]:
         """
         Search for the objectname in the given directory
         :param directory: relative or absolute directory path
         :return: object instance
         """
-        logger.debug('Searching for %s %s in \'%s\'', object_type.__name__, object_name, directory)
+        logger.debug("Searching for %s %s in '%s'", object_type.__name__, object_name, directory)
         for entry in directory.iterdir():
             # Only consider python files
             if not str(entry).endswith('.py'):
                 logger.debug('Ignoring %s', entry)
                 continue
+            module_path = entry.resolve()
             obj = IResolver._get_valid_object(
-                object_type, Path.resolve(directory.joinpath(entry)), object_name
+                object_type, module_path, object_name
             )
             if obj:
-                return obj(**kwargs)
+                return (obj(**kwargs), module_path)
+        return (None, None)
+
+    @staticmethod
+    def _load_object(paths: List[Path], object_type, object_name: str,
+                     kwargs: dict = {}) -> Optional[Any]:
+        """
+        Try to load object from path list.
+        """
+
+        for _path in paths:
+            try:
+                (module, module_path) = IResolver._search_object(directory=_path,
+                                                                 object_type=object_type,
+                                                                 object_name=object_name,
+                                                                 kwargs=kwargs)
+                if module:
+                    logger.info(
+                        f"Using resolved {object_type.__name__.lower()[1:]} {object_name} "
+                        f"from '{module_path}'...")
+                    return module
+            except FileNotFoundError:
+                logger.warning('Path "%s" does not exist.', _path.resolve())
+
         return None

freqtrade/resolvers/pairlist_resolver.py

@@ -6,6 +6,7 @@ This module load custom hyperopts
 import logging
 from pathlib import Path
 
+from freqtrade import OperationalException
 from freqtrade.pairlist.IPairList import IPairList
 from freqtrade.resolvers import IResolver
 
@@ -24,36 +25,30 @@ class PairListResolver(IResolver):
         Load the custom class from config parameter
         :param config: configuration dictionary or None
         """
-        self.pairlist = self._load_pairlist(pairlist_name, kwargs={'freqtrade': freqtrade,
+        self.pairlist = self._load_pairlist(pairlist_name, config, kwargs={'freqtrade': freqtrade,
-                                                                   'config': config})
+                                                                           'config': config})
 
     def _load_pairlist(
-            self, pairlist_name: str, kwargs: dict) -> IPairList:
+            self, pairlist_name: str, config: dict, kwargs: dict) -> IPairList:
         """
         Search and loads the specified pairlist.
         :param pairlist_name: name of the module to import
+        :param config: configuration dictionary
         :param extra_dir: additional directory to search for the given pairlist
         :return: PairList instance or None
         """
         current_path = Path(__file__).parent.parent.joinpath('pairlist').resolve()
 
         abs_paths = [
-            current_path.parent.parent.joinpath('user_data/pairlist'),
+            config['user_data_dir'].joinpath('pairlist'),
             current_path,
         ]
 
-        for _path in abs_paths:
+        pairlist = self._load_object(paths=abs_paths, object_type=IPairList,
-            try:
+                                     object_name=pairlist_name, kwargs=kwargs)
-                pairlist = self._search_object(directory=_path, object_type=IPairList,
+        if pairlist:
-                                               object_name=pairlist_name,
+            return pairlist
-                                               kwargs=kwargs)
+        raise OperationalException(
-                if pairlist:
+            f"Impossible to load Pairlist '{pairlist_name}'. This class does not exist "
-                    logger.info('Using resolved pairlist %s from \'%s\'', pairlist_name, _path)
+            "or contains Python code errors."
-                    return pairlist
-            except FileNotFoundError:
-                logger.warning('Path "%s" does not exist', _path.relative_to(Path.cwd()))
-
-        raise ImportError(
-            "Impossible to load Pairlist '{}'. This class does not exist"
-            " or contains Python code errors".format(pairlist_name)
         )

freqtrade/resolvers/strategy_resolver.py

@@ -3,15 +3,15 @@
 """
 This module load custom strategies
 """
-import inspect
 import logging
 import tempfile
 from base64 import urlsafe_b64decode
 from collections import OrderedDict
+from inspect import getfullargspec
 from pathlib import Path
 from typing import Dict, Optional
 
-from freqtrade import constants
+from freqtrade import constants, OperationalException
 from freqtrade.resolvers import IResolver
 from freqtrade.strategy import import_strategy
 from freqtrade.strategy.interface import IStrategy
@@ -39,59 +39,70 @@ class StrategyResolver(IResolver):
                                                        config=config,
                                                        extra_dir=config.get('strategy_path'))
 
+        # make sure experimental dict is available
+        if 'experimental' not in config:
+            config['experimental'] = {}
+
         # Set attributes
         # Check if we need to override configuration
-        if 'minimal_roi' in config:
+        # (Attribute name,                              default, experimental)
-            self.strategy.minimal_roi = config['minimal_roi']
+        attributes = [("minimal_roi",                     {"0": 10.0}, False),
-            logger.info("Override strategy 'minimal_roi' with value in config file: %s.",
+                      ("ticker_interval",                 None,        False),
-                        config['minimal_roi'])
+                      ("stoploss",                        None,        False),
-        else:
+                      ("trailing_stop",                   None,        False),
-            config['minimal_roi'] = self.strategy.minimal_roi
+                      ("trailing_stop_positive",          None,        False),
+                      ("trailing_stop_positive_offset",   0.0,         False),
+                      ("trailing_only_offset_is_reached", None,        False),
+                      ("process_only_new_candles",        None,        False),
+                      ("order_types",                     None,        False),
+                      ("order_time_in_force",             None,        False),
+                      ("stake_currency",                  None,        False),
+                      ("stake_amount",                    None,        False),
+                      ("use_sell_signal",                 False,       True),
+                      ("sell_profit_only",                False,       True),
+                      ("ignore_roi_if_buy_signal",        False,       True),
+                      ]
+        for attribute, default, experimental in attributes:
+            if experimental:
+                self._override_attribute_helper(config['experimental'], attribute, default)
+            else:
+                self._override_attribute_helper(config, attribute, default)
 
-        if 'stoploss' in config:
+        # Loop this list again to have output combined
-            self.strategy.stoploss = config['stoploss']
+        for attribute, _, exp in attributes:
-            logger.info(
+            if exp and attribute in config['experimental']:
-                "Override strategy 'stoploss' with value in config file: %s.", config['stoploss']
+                logger.info("Strategy using %s: %s", attribute, config['experimental'][attribute])
-            )
+            elif attribute in config:
-        else:
+                logger.info("Strategy using %s: %s", attribute, config[attribute])
-            config['stoploss'] = self.strategy.stoploss
 
-        if 'ticker_interval' in config:
+        # Sort and apply type conversions
-            self.strategy.ticker_interval = config['ticker_interval']
+        self.strategy.minimal_roi = OrderedDict(sorted(
-            logger.info(
+            {int(key): value for (key, value) in self.strategy.minimal_roi.items()}.items(),
-                "Override strategy 'ticker_interval' with value in config file: %s.",
+            key=lambda t: t[0]))
-                config['ticker_interval']
+        self.strategy.stoploss = float(self.strategy.stoploss)
-            )
-        else:
-            config['ticker_interval'] = self.strategy.ticker_interval
 
-        if 'process_only_new_candles' in config:
+        self._strategy_sanity_validations()
-            self.strategy.process_only_new_candles = config['process_only_new_candles']
-            logger.info(
-                "Override process_only_new_candles 'process_only_new_candles' "
-                "with value in config file: %s.", config['process_only_new_candles']
-            )
-        else:
-            config['process_only_new_candles'] = self.strategy.process_only_new_candles
 
-        if 'order_types' in config:
+    def _override_attribute_helper(self, config, attribute: str, default):
-            self.strategy.order_types = config['order_types']
+        """
-            logger.info(
+        Override attributes in the strategy.
-                "Override strategy 'order_types' with value in config file: %s.",
+        Prevalence:
-                config['order_types']
+        - Configuration
-            )
+        - Strategy
-        else:
+        - default (if not None)
-            config['order_types'] = self.strategy.order_types
+        """
-
+        if attribute in config:
-        if 'order_time_in_force' in config:
+            setattr(self.strategy, attribute, config[attribute])
-            self.strategy.order_time_in_force = config['order_time_in_force']
+            logger.info("Override strategy '%s' with value in config file: %s.",
-            logger.info(
+                        attribute, config[attribute])
-                "Override strategy 'order_time_in_force' with value in config file: %s.",
+        elif hasattr(self.strategy, attribute):
-                config['order_time_in_force']
+            config[attribute] = getattr(self.strategy, attribute)
-            )
+        # Explicitly check for None here as other "falsy" values are possible
-        else:
+        elif default is not None:
-            config['order_time_in_force'] = self.strategy.order_time_in_force
+            setattr(self.strategy, attribute, default)
+            config[attribute] = default
 
+    def _strategy_sanity_validations(self):
         if not all(k in self.strategy.order_types for k in constants.REQUIRED_ORDERTYPES):
             raise ImportError(f"Impossible to load Strategy '{self.strategy.__class__.__name__}'. "
                               f"Order-types mapping is incomplete.")
@@ -100,12 +111,6 @@ class StrategyResolver(IResolver):
             raise ImportError(f"Impossible to load Strategy '{self.strategy.__class__.__name__}'. "
                               f"Order-time-in-force mapping is incomplete.")
 
-        # Sort and apply type conversions
-        self.strategy.minimal_roi = OrderedDict(sorted(
-            {int(key): value for (key, value) in self.strategy.minimal_roi.items()}.items(),
-            key=lambda t: t[0]))
-        self.strategy.stoploss = float(self.strategy.stoploss)
-
     def _load_strategy(
             self, strategy_name: str, config: dict, extra_dir: Optional[str] = None) -> IStrategy:
         """
@@ -118,7 +123,7 @@ class StrategyResolver(IResolver):
         current_path = Path(__file__).parent.parent.joinpath('strategy').resolve()
 
         abs_paths = [
-            Path.cwd().joinpath('user_data/strategies'),
+            config['user_data_dir'].joinpath('strategies'),
             current_path,
         ]
 
@@ -127,7 +132,7 @@ class StrategyResolver(IResolver):
             abs_paths.insert(0, Path(extra_dir).resolve())
 
         if ":" in strategy_name:
-            logger.info("loading base64 endocded strategy")
+            logger.info("loading base64 encoded strategy")
             strat = strategy_name.split(":")
 
             if len(strat) == 2:
@@ -142,24 +147,21 @@ class StrategyResolver(IResolver):
                 # register temp path with the bot
                 abs_paths.insert(0, temp.resolve())
 
-        for _path in abs_paths:
+        strategy = self._load_object(paths=abs_paths, object_type=IStrategy,
+                                     object_name=strategy_name, kwargs={'config': config})
+        if strategy:
+            strategy._populate_fun_len = len(getfullargspec(strategy.populate_indicators).args)
+            strategy._buy_fun_len = len(getfullargspec(strategy.populate_buy_trend).args)
+            strategy._sell_fun_len = len(getfullargspec(strategy.populate_sell_trend).args)
+
             try:
-                strategy = self._search_object(directory=_path, object_type=IStrategy,
+                return import_strategy(strategy, config=config)
-                                               object_name=strategy_name, kwargs={'config': config})
+            except TypeError as e:
-                if strategy:
+                logger.warning(
-                    logger.info('Using resolved strategy %s from \'%s\'', strategy_name, _path)
+                    f"Impossible to load strategy '{strategy_name}'. "
-                    strategy._populate_fun_len = len(
+                    f"Error: {e}")
-                        inspect.getfullargspec(strategy.populate_indicators).args)
-                    strategy._buy_fun_len = len(
-                        inspect.getfullargspec(strategy.populate_buy_trend).args)
-                    strategy._sell_fun_len = len(
-                        inspect.getfullargspec(strategy.populate_sell_trend).args)
 
-                    return import_strategy(strategy, config=config)
+        raise OperationalException(
-            except FileNotFoundError:
+            f"Impossible to load Strategy '{strategy_name}'. This class does not exist "
-                logger.warning('Path "%s" does not exist', _path.relative_to(Path.cwd()))
+            "or contains Python code errors."
-
-        raise ImportError(
-            "Impossible to load Strategy '{}'. This class does not exist"
-            " or contains Python code errors".format(strategy_name)
         )

freqtrade/rpc/api_server.py

@@ -0,0 +1,375 @@
+import logging
+import threading
+from datetime import date, datetime
+from ipaddress import IPv4Address
+from typing import Dict
+
+from arrow import Arrow
+from flask import Flask, jsonify, request
+from flask.json import JSONEncoder
+from werkzeug.serving import make_server
+
+from freqtrade.__init__ import __version__
+from freqtrade.rpc.rpc import RPC, RPCException
+
+logger = logging.getLogger(__name__)
+
+BASE_URI = "/api/v1"
+
+
+class ArrowJSONEncoder(JSONEncoder):
+    def default(self, obj):
+        try:
+            if isinstance(obj, Arrow):
+                return obj.for_json()
+            elif isinstance(obj, date):
+                return obj.strftime("%Y-%m-%d")
+            elif isinstance(obj, datetime):
+                return obj.strftime("%Y-%m-%d %H:%M:%S")
+            iterable = iter(obj)
+        except TypeError:
+            pass
+        else:
+            return list(iterable)
+        return JSONEncoder.default(self, obj)
+
+
+class ApiServer(RPC):
+    """
+    This class runs api server and provides rpc.rpc functionality to it
+
+    This class starts a none blocking thread the api server runs within
+    """
+
+    def rpc_catch_errors(func):
+
+        def func_wrapper(self, *args, **kwargs):
+
+            try:
+                return func(self, *args, **kwargs)
+            except RPCException as e:
+                logger.exception("API Error calling %s: %s", func.__name__, e)
+                return self.rest_error(f"Error querying {func.__name__}: {e}")
+
+        return func_wrapper
+
+    def check_auth(self, username, password):
+        return (username == self._config['api_server'].get('username') and
+                password == self._config['api_server'].get('password'))
+
+    def require_login(func):
+
+        def func_wrapper(self, *args, **kwargs):
+
+            auth = request.authorization
+            if auth and self.check_auth(auth.username, auth.password):
+                return func(self, *args, **kwargs)
+            else:
+                return jsonify({"error": "Unauthorized"}), 401
+
+        return func_wrapper
+
+    def __init__(self, freqtrade) -> None:
+        """
+        Init the api server, and init the super class RPC
+        :param freqtrade: Instance of a freqtrade bot
+        :return: None
+        """
+        super().__init__(freqtrade)
+
+        self._config = freqtrade.config
+        self.app = Flask(__name__)
+        self.app.json_encoder = ArrowJSONEncoder
+
+        # Register application handling
+        self.register_rest_rpc_urls()
+
+        thread = threading.Thread(target=self.run, daemon=True)
+        thread.start()
+
+    def cleanup(self) -> None:
+        logger.info("Stopping API Server")
+        self.srv.shutdown()
+
+    def run(self):
+        """
+        Method that runs flask app in its own thread forever.
+        Section to handle configuration and running of the Rest server
+        also to check and warn if not bound to a loopback, warn on security risk.
+        """
+        rest_ip = self._config['api_server']['listen_ip_address']
+        rest_port = self._config['api_server']['listen_port']
+
+        logger.info(f'Starting HTTP Server at {rest_ip}:{rest_port}')
+        if not IPv4Address(rest_ip).is_loopback:
+            logger.warning("SECURITY WARNING - Local Rest Server listening to external connections")
+            logger.warning("SECURITY WARNING - This is insecure please set to your loopback,"
+                           "e.g 127.0.0.1 in config.json")
+
+        if not self._config['api_server'].get('password'):
+            logger.warning("SECURITY WARNING - No password for local REST Server defined. "
+                           "Please make sure that this is intentional!")
+
+        # Run the Server
+        logger.info('Starting Local Rest Server.')
+        try:
+            self.srv = make_server(rest_ip, rest_port, self.app)
+            self.srv.serve_forever()
+        except Exception:
+            logger.exception("Api server failed to start.")
+        logger.info('Local Rest Server started.')
+
+    def send_msg(self, msg: Dict[str, str]) -> None:
+        """
+        We don't push to endpoints at the moment.
+        Take a look at webhooks for that functionality.
+        """
+        pass
+
+    def rest_dump(self, return_value):
+        """ Helper function to jsonify object for a webserver """
+        return jsonify(return_value)
+
+    def rest_error(self, error_msg):
+        return jsonify({"error": error_msg}), 502
+
+    def register_rest_rpc_urls(self):
+        """
+        Registers flask app URLs that are calls to functonality in rpc.rpc.
+
+        First two arguments passed are /URL and 'Label'
+        Label can be used as a shortcut when refactoring
+        :return:
+        """
+        self.app.register_error_handler(404, self.page_not_found)
+
+        # Actions to control the bot
+        self.app.add_url_rule(f'{BASE_URI}/start', 'start',
+                              view_func=self._start, methods=['POST'])
+        self.app.add_url_rule(f'{BASE_URI}/stop', 'stop', view_func=self._stop, methods=['POST'])
+        self.app.add_url_rule(f'{BASE_URI}/stopbuy', 'stopbuy',
+                              view_func=self._stopbuy, methods=['POST'])
+        self.app.add_url_rule(f'{BASE_URI}/reload_conf', 'reload_conf',
+                              view_func=self._reload_conf, methods=['POST'])
+        # Info commands
+        self.app.add_url_rule(f'{BASE_URI}/balance', 'balance',
+                              view_func=self._balance, methods=['GET'])
+        self.app.add_url_rule(f'{BASE_URI}/count', 'count', view_func=self._count, methods=['GET'])
+        self.app.add_url_rule(f'{BASE_URI}/daily', 'daily', view_func=self._daily, methods=['GET'])
+        self.app.add_url_rule(f'{BASE_URI}/edge', 'edge', view_func=self._edge, methods=['GET'])
+        self.app.add_url_rule(f'{BASE_URI}/profit', 'profit',
+                              view_func=self._profit, methods=['GET'])
+        self.app.add_url_rule(f'{BASE_URI}/performance', 'performance',
+                              view_func=self._performance, methods=['GET'])
+        self.app.add_url_rule(f'{BASE_URI}/status', 'status',
+                              view_func=self._status, methods=['GET'])
+        self.app.add_url_rule(f'{BASE_URI}/version', 'version',
+                              view_func=self._version, methods=['GET'])
+
+        # Combined actions and infos
+        self.app.add_url_rule(f'{BASE_URI}/blacklist', 'blacklist', view_func=self._blacklist,
+                              methods=['GET', 'POST'])
+        self.app.add_url_rule(f'{BASE_URI}/whitelist', 'whitelist', view_func=self._whitelist,
+                              methods=['GET'])
+        self.app.add_url_rule(f'{BASE_URI}/forcebuy', 'forcebuy',
+                              view_func=self._forcebuy, methods=['POST'])
+        self.app.add_url_rule(f'{BASE_URI}/forcesell', 'forcesell', view_func=self._forcesell,
+                              methods=['POST'])
+
+        # TODO: Implement the following
+        # help (?)
+
+    @require_login
+    def page_not_found(self, error):
+        """
+        Return "404 not found", 404.
+        """
+        return self.rest_dump({
+            'status': 'error',
+            'reason': f"There's no API call for {request.base_url}.",
+            'code': 404
+        }), 404
+
+    @require_login
+    @rpc_catch_errors
+    def _start(self):
+        """
+        Handler for /start.
+        Starts TradeThread in bot if stopped.
+        """
+        msg = self._rpc_start()
+        return self.rest_dump(msg)
+
+    @require_login
+    @rpc_catch_errors
+    def _stop(self):
+        """
+        Handler for /stop.
+        Stops TradeThread in bot if running
+        """
+        msg = self._rpc_stop()
+        return self.rest_dump(msg)
+
+    @require_login
+    @rpc_catch_errors
+    def _stopbuy(self):
+        """
+        Handler for /stopbuy.
+        Sets max_open_trades to 0 and gracefully sells all open trades
+        """
+        msg = self._rpc_stopbuy()
+        return self.rest_dump(msg)
+
+    @require_login
+    @rpc_catch_errors
+    def _version(self):
+        """
+        Prints the bot's version
+        """
+        return self.rest_dump({"version": __version__})
+
+    @require_login
+    @rpc_catch_errors
+    def _reload_conf(self):
+        """
+        Handler for /reload_conf.
+        Triggers a config file reload
+        """
+        msg = self._rpc_reload_conf()
+        return self.rest_dump(msg)
+
+    @require_login
+    @rpc_catch_errors
+    def _count(self):
+        """
+        Handler for /count.
+        Returns the number of trades running
+        """
+        msg = self._rpc_count()
+        return self.rest_dump(msg)
+
+    @require_login
+    @rpc_catch_errors
+    def _daily(self):
+        """
+        Returns the last X days trading stats summary.
+
+        :return: stats
+        """
+        timescale = request.args.get('timescale', 7)
+        timescale = int(timescale)
+
+        stats = self._rpc_daily_profit(timescale,
+                                       self._config['stake_currency'],
+                                       self._config['fiat_display_currency']
+                                       )
+
+        return self.rest_dump(stats)
+
+    @require_login
+    @rpc_catch_errors
+    def _edge(self):
+        """
+        Returns information related to Edge.
+        :return: edge stats
+        """
+        stats = self._rpc_edge()
+
+        return self.rest_dump(stats)
+
+    @require_login
+    @rpc_catch_errors
+    def _profit(self):
+        """
+        Handler for /profit.
+
+        Returns a cumulative profit statistics
+        :return: stats
+        """
+        logger.info("LocalRPC - Profit Command Called")
+
+        stats = self._rpc_trade_statistics(self._config['stake_currency'],
+                                           self._config['fiat_display_currency']
+                                           )
+
+        return self.rest_dump(stats)
+
+    @require_login
+    @rpc_catch_errors
+    def _performance(self):
+        """
+        Handler for /performance.
+
+        Returns a cumulative performance statistics
+        :return: stats
+        """
+        logger.info("LocalRPC - performance Command Called")
+
+        stats = self._rpc_performance()
+
+        return self.rest_dump(stats)
+
+    @require_login
+    @rpc_catch_errors
+    def _status(self):
+        """
+        Handler for /status.
+
+        Returns the current status of the trades in json format
+        """
+        results = self._rpc_trade_status()
+        return self.rest_dump(results)
+
+    @require_login
+    @rpc_catch_errors
+    def _balance(self):
+        """
+        Handler for /balance.
+
+        Returns the current status of the trades in json format
+        """
+        results = self._rpc_balance(self._config.get('fiat_display_currency', ''))
+        return self.rest_dump(results)
+
+    @require_login
+    @rpc_catch_errors
+    def _whitelist(self):
+        """
+        Handler for /whitelist.
+        """
+        results = self._rpc_whitelist()
+        return self.rest_dump(results)
+
+    @require_login
+    @rpc_catch_errors
+    def _blacklist(self):
+        """
+        Handler for /blacklist.
+        """
+        add = request.json.get("blacklist", None) if request.method == 'POST' else None
+        results = self._rpc_blacklist(add)
+        return self.rest_dump(results)
+
+    @require_login
+    @rpc_catch_errors
+    def _forcebuy(self):
+        """
+        Handler for /forcebuy.
+        """
+        asset = request.json.get("pair")
+        price = request.json.get("price", None)
+        trade = self._rpc_forcebuy(asset, price)
+        if trade:
+            return self.rest_dump(trade.to_json())
+        else:
+            return self.rest_dump({"status": f"Error buying pair {asset}."})
+
+    @require_login
+    @rpc_catch_errors
+    def _forcesell(self):
+        """
+        Handler for /forcesell.
+        """
+        tradeid = request.json.get("tradeid")
+        results = self._rpc_forcesell(tradeid)
+        return self.rest_dump(results)

freqtrade/rpc/rpc.py

@@ -10,7 +10,7 @@ from typing import Dict, Any, List, Optional
 
 import arrow
 import sqlalchemy as sql
-from numpy import mean, nan_to_num, NAN
+from numpy import mean, NAN
 from pandas import DataFrame
 
 from freqtrade import TemporaryError, DependencyException
@@ -48,6 +48,11 @@ class RPCException(Exception):
     def __str__(self):
         return self.message
 
+    def __json__(self):
+        return {
+            'msg': self.message
+        }
+
 
 class RPC(object):
     """
@@ -83,7 +88,7 @@ class RPC(object):
         a remotely exposed function
         """
         # Fetch open trade
-        trades = Trade.query.filter(Trade.is_open.is_(True)).all()
+        trades = Trade.get_open_trades()
         if not trades:
             raise RPCException('no active trade')
         else:
@@ -94,31 +99,27 @@ class RPC(object):
                     order = self._freqtrade.exchange.get_order(trade.open_order_id, trade.pair)
                 # calculate profit and send message to user
                 try:
-                    current_rate = self._freqtrade.exchange.get_ticker(trade.pair, False)['bid']
+                    current_rate = self._freqtrade.get_sell_rate(trade.pair, False)
                 except DependencyException:
                     current_rate = NAN
                 current_profit = trade.calc_profit_percent(current_rate)
                 fmt_close_profit = (f'{round(trade.close_profit * 100, 2):.2f}%'
                                     if trade.close_profit else None)
-                results.append(dict(
+                trade_dict = trade.to_json()
-                    trade_id=trade.id,
+                trade_dict.update(dict(
-                    pair=trade.pair,
+                    base_currency=self._freqtrade.config['stake_currency'],
-                    market_url=self._freqtrade.exchange.get_pair_detail_url(trade.pair),
-                    date=arrow.get(trade.open_date),
-                    open_rate=trade.open_rate,
-                    close_rate=trade.close_rate,
-                    current_rate=current_rate,
-                    amount=round(trade.amount, 8),
                     close_profit=fmt_close_profit,
+                    current_rate=current_rate,
                     current_profit=round(current_profit * 100, 2),
                     open_order='({} {} rem={:.8f})'.format(
-                      order['type'], order['side'], order['remaining']
+                        order['type'], order['side'], order['remaining']
                     ) if order else None,
                 ))
+                results.append(trade_dict)
             return results
 
     def _rpc_status_table(self) -> DataFrame:
-        trades = Trade.query.filter(Trade.is_open.is_(True)).all()
+        trades = Trade.get_open_trades()
         if not trades:
             raise RPCException('no active order')
         else:
@@ -126,7 +127,7 @@ class RPC(object):
             for trade in trades:
                 # calculate profit and send message to user
                 try:
-                    current_rate = self._freqtrade.exchange.get_ticker(trade.pair, False)['bid']
+                    current_rate = self._freqtrade.get_sell_rate(trade.pair, False)
                 except DependencyException:
                     current_rate = NAN
                 trade_perc = (100 * trade.calc_profit_percent(current_rate))
@@ -194,9 +195,9 @@ class RPC(object):
         trades = Trade.query.order_by(Trade.id).all()
 
         profit_all_coin = []
-        profit_all_percent = []
+        profit_all_perc = []
         profit_closed_coin = []
-        profit_closed_percent = []
+        profit_closed_perc = []
         durations = []
 
         for trade in trades:
@@ -210,11 +211,11 @@ class RPC(object):
             if not trade.is_open:
                 profit_percent = trade.calc_profit_percent()
                 profit_closed_coin.append(trade.calc_profit())
-                profit_closed_percent.append(profit_percent)
+                profit_closed_perc.append(profit_percent)
             else:
                 # Get current rate
                 try:
-                    current_rate = self._freqtrade.exchange.get_ticker(trade.pair, False)['bid']
+                    current_rate = self._freqtrade.get_sell_rate(trade.pair, False)
                 except DependencyException:
                     current_rate = NAN
                 profit_percent = trade.calc_profit_percent(rate=current_rate)
@@ -222,7 +223,7 @@ class RPC(object):
             profit_all_coin.append(
                 trade.calc_profit(rate=Decimal(trade.close_rate or current_rate))
             )
-            profit_all_percent.append(profit_percent)
+            profit_all_perc.append(profit_percent)
 
         best_pair = Trade.session.query(
             Trade.pair, sql.func.sum(Trade.close_profit).label('profit_sum')
@@ -237,7 +238,8 @@ class RPC(object):
 
         # Prepare data to display
         profit_closed_coin_sum = round(sum(profit_closed_coin), 8)
-        profit_closed_percent = round(nan_to_num(mean(profit_closed_percent)) * 100, 2)
+        profit_closed_percent = (round(mean(profit_closed_perc) * 100, 2) if profit_closed_perc
+                                 else 0.0)
         profit_closed_fiat = self._fiat_converter.convert_amount(
             profit_closed_coin_sum,
             stake_currency,
@@ -245,7 +247,7 @@ class RPC(object):
         ) if self._fiat_converter else 0
 
         profit_all_coin_sum = round(sum(profit_all_coin), 8)
-        profit_all_percent = round(nan_to_num(mean(profit_all_percent)) * 100, 2)
+        profit_all_percent = round(mean(profit_all_perc) * 100, 2) if profit_all_perc else 0.0
         profit_all_fiat = self._fiat_converter.convert_amount(
             profit_all_coin_sum,
             stake_currency,
@@ -280,11 +282,13 @@ class RPC(object):
                 rate = 1.0
             else:
                 try:
-                    if coin == 'USDT':
+                    pair = self._freqtrade.exchange.get_valid_pair_combination(coin, "BTC")
-                        rate = 1.0 / self._freqtrade.exchange.get_ticker('BTC/USDT', False)['bid']
+                    if pair.startswith("BTC"):
+                        rate = 1.0 / self._freqtrade.get_sell_rate(pair, False)
                     else:
-                        rate = self._freqtrade.exchange.get_ticker(coin + '/BTC', False)['bid']
+                        rate = self._freqtrade.get_sell_rate(pair, False)
                 except (TemporaryError, DependencyException):
+                    logger.warning(f" Could not get rate for pair {coin}.")
                     continue
             est_btc: float = rate * balance['total']
             total = total + est_btc
@@ -296,7 +300,10 @@ class RPC(object):
                 'est_btc': est_btc,
             })
         if total == 0.0:
-            raise RPCException('all balances are zero')
+            if self._freqtrade.config.get('dry_run', False):
+                raise RPCException('Running in Dry Run, balances are not available.')
+            else:
+                raise RPCException('All balances are zero.')
 
         symbol = fiat_display_currency
         value = self._fiat_converter.convert_amount(total, 'BTC',
@@ -329,7 +336,17 @@ class RPC(object):
         self._freqtrade.state = State.RELOAD_CONF
         return {'status': 'reloading config ...'}
 
-    def _rpc_forcesell(self, trade_id) -> None:
+    def _rpc_stopbuy(self) -> Dict[str, str]:
+        """
+        Handler to stop buying, but handle open trades gracefully.
+        """
+        if self._freqtrade.state == State.RUNNING:
+            # Set 'max_open_trades' to 0
+            self._freqtrade.config['max_open_trades'] = 0
+
+        return {'status': 'No more buy will occur from now. Run /reload_conf to reset.'}
+
+    def _rpc_forcesell(self, trade_id) -> Dict[str, str]:
         """
         Handler for forcesell <id>.
         Sells the given trade at current price
@@ -357,7 +374,7 @@ class RPC(object):
                     return
 
             # Get current rate and execute sell
-            current_rate = self._freqtrade.exchange.get_ticker(trade.pair, False)['bid']
+            current_rate = self._freqtrade.get_sell_rate(trade.pair, False)
             self._freqtrade.execute_sell(trade, current_rate, SellType.FORCE_SELL)
         # ---- EOF def _exec_forcesell ----
 
@@ -366,10 +383,10 @@ class RPC(object):
 
         if trade_id == 'all':
             # Execute sell for all open orders
-            for trade in Trade.query.filter(Trade.is_open.is_(True)).all():
+            for trade in Trade.get_open_trades():
                 _exec_forcesell(trade)
             Trade.session.flush()
-            return
+            return {'result': 'Created sell orders for all open trades.'}
 
         # Query for trade
         trade = Trade.query.filter(
@@ -384,6 +401,7 @@ class RPC(object):
 
         _exec_forcesell(trade)
         Trade.session.flush()
+        return {'result': f'Created sell order for trade {trade_id}.'}
 
     def _rpc_forcebuy(self, pair: str, price: Optional[float]) -> Optional[Trade]:
         """
@@ -437,17 +455,43 @@ class RPC(object):
             for pair, rate, count in pair_rates
         ]
 
-    def _rpc_count(self) -> List[Trade]:
+    def _rpc_count(self) -> Dict[str, float]:
         """ Returns the number of trades running """
         if self._freqtrade.state != State.RUNNING:
             raise RPCException('trader is not running')
 
-        return Trade.query.filter(Trade.is_open.is_(True)).all()
+        trades = Trade.get_open_trades()
+        return {
+            'current': len(trades),
+            'max': float(self._freqtrade.config['max_open_trades']),
+            'total_stake': sum((trade.open_rate * trade.amount) for trade in trades)
+        }
 
     def _rpc_whitelist(self) -> Dict:
         """ Returns the currently active whitelist"""
         res = {'method': self._freqtrade.pairlists.name,
-               'length': len(self._freqtrade.pairlists.whitelist),
+               'length': len(self._freqtrade.active_pair_whitelist),
                'whitelist': self._freqtrade.active_pair_whitelist
                }
         return res
+
+    def _rpc_blacklist(self, add: List[str] = None) -> Dict:
+        """ Returns the currently active blacklist"""
+        if add:
+            stake_currency = self._freqtrade.config.get('stake_currency')
+            for pair in add:
+                if (pair.endswith(stake_currency)
+                        and pair not in self._freqtrade.pairlists.blacklist):
+                    self._freqtrade.pairlists.blacklist.append(pair)
+
+        res = {'method': self._freqtrade.pairlists.name,
+               'length': len(self._freqtrade.pairlists.blacklist),
+               'blacklist': self._freqtrade.pairlists.blacklist,
+               }
+        return res
+
+    def _rpc_edge(self) -> List[Dict[str, Any]]:
+        """ Returns information related to Edge """
+        if not self._freqtrade.edge:
+            raise RPCException(f'Edge is not enabled.')
+        return self._freqtrade.edge.accepted_pairs()

freqtrade/rpc/rpc_manager.py

@@ -2,7 +2,7 @@
 This module contains class to manage RPC communications (Telegram, Slack, ...)
 """
 import logging
-from typing import List, Dict, Any
+from typing import Any, Dict, List
 
 from freqtrade.rpc import RPC, RPCMessageType
 
@@ -29,6 +29,12 @@ class RPCManager(object):
             from freqtrade.rpc.webhook import Webhook
             self.registered_modules.append(Webhook(freqtrade))
 
+        # Enable local rest api server for cmd line control
+        if freqtrade.config.get('api_server', {}).get('enabled', False):
+            logger.info('Enabling rpc.api_server')
+            from freqtrade.rpc.api_server import ApiServer
+            self.registered_modules.append(ApiServer(freqtrade))
+
     def cleanup(self) -> None:
         """ Stops all enabled rpc modules """
         logger.info('Cleaning up rpc modules ...')
@@ -61,6 +67,8 @@ class RPCManager(object):
         stake_currency = config['stake_currency']
         stake_amount = config['stake_amount']
         minimal_roi = config['minimal_roi']
+        stoploss = config['stoploss']
+        trailing_stop = config['trailing_stop']
         ticker_interval = config['ticker_interval']
         exchange_name = config['exchange']['name']
         strategy_name = config.get('strategy', '')
@@ -69,6 +77,7 @@ class RPCManager(object):
             'status': f'*Exchange:* `{exchange_name}`\n'
                       f'*Stake per trade:* `{stake_amount} {stake_currency}`\n'
                       f'*Minimum ROI:* `{minimal_roi}`\n'
+                      f'*{"Trailing " if trailing_stop else ""}Stoploss:* `{stoploss}`\n'
                       f'*Ticker Interval:* `{ticker_interval}`\n'
                       f'*Strategy:* `{strategy_name}`'
         })

freqtrade/rpc/telegram.py

@@ -4,7 +4,7 @@
 This module manage Telegram communication
 """
 import logging
-from typing import Any, Callable, Dict
+from typing import Any, Callable, Dict, List
 
 from tabulate import tabulate
 from telegram import Bot, ParseMode, ReplyKeyboardMarkup, Update
@@ -20,7 +20,10 @@ logger = logging.getLogger(__name__)
 logger.debug('Included module rpc.telegram ...')
 
 
-def authorized_only(command_handler: Callable[[Any, Bot, Update], None]) -> Callable[..., Any]:
+MAX_TELEGRAM_MESSAGE_LENGTH = 4096
+
+
+def authorized_only(command_handler: Callable[..., None]) -> Callable[..., Any]:
     """
     Decorator to check if the message comes from the correct chat_id
     :param command_handler: Telegram CommandHandler
@@ -91,7 +94,10 @@ class Telegram(RPC):
             CommandHandler('daily', self._daily),
             CommandHandler('count', self._count),
             CommandHandler('reload_conf', self._reload_conf),
+            CommandHandler('stopbuy', self._stopbuy),
             CommandHandler('whitelist', self._whitelist),
+            CommandHandler('blacklist', self._blacklist, pass_args=True),
+            CommandHandler('edge', self._edge),
             CommandHandler('help', self._help),
             CommandHandler('version', self._version),
         ]
@@ -125,8 +131,8 @@ class Telegram(RPC):
             else:
                 msg['stake_amount_fiat'] = 0
 
-            message = ("*{exchange}:* Buying [{pair}]({market_url})\n"
+            message = ("*{exchange}:* Buying {pair}\n"
-                       "with limit `{limit:.8f}\n"
+                       "at rate `{limit:.8f}\n"
                        "({stake_amount:.6f} {stake_currency}").format(**msg)
 
             if msg.get('fiat_currency', None):
@@ -137,8 +143,8 @@ class Telegram(RPC):
             msg['amount'] = round(msg['amount'], 8)
             msg['profit_percent'] = round(msg['profit_percent'] * 100, 2)
 
-            message = ("*{exchange}:* Selling [{pair}]({market_url})\n"
+            message = ("*{exchange}:* Selling {pair}\n"
-                       "*Limit:* `{limit:.8f}`\n"
+                       "*Rate:* `{limit:.8f}`\n"
                        "*Amount:* `{amount:.8f}`\n"
                        "*Open Rate:* `{open_rate:.8f}`\n"
                        "*Current Rate:* `{current_rate:.8f}`\n"
@@ -187,25 +193,36 @@ class Telegram(RPC):
 
         try:
             results = self._rpc_trade_status()
-            # pre format data
-            for result in results:
-                result['date'] = result['date'].humanize()
 
-            messages = [
+            messages = []
-                "*Trade ID:* `{trade_id}`\n"
+            for r in results:
-                "*Current Pair:* [{pair}]({market_url})\n"
+                lines = [
-                "*Open Since:* `{date}`\n"
+                    "*Trade ID:* `{trade_id}` `(since {open_date_hum})`",
-                "*Amount:* `{amount}`\n"
+                    "*Current Pair:* {pair}",
-                "*Open Rate:* `{open_rate:.8f}`\n"
+                    "*Amount:* `{amount} ({stake_amount} {base_currency})`",
-                "*Close Rate:* `{close_rate}`\n"
+                    "*Open Rate:* `{open_rate:.8f}`",
-                "*Current Rate:* `{current_rate:.8f}`\n"
+                    "*Close Rate:* `{close_rate}`" if r['close_rate'] else "",
-                "*Close Profit:* `{close_profit}`\n"
+                    "*Current Rate:* `{current_rate:.8f}`",
-                "*Current Profit:* `{current_profit:.2f}%`\n"
+                    "*Close Profit:* `{close_profit}`" if r['close_profit'] else "",
-                "*Open Order:* `{open_order}`".format(**result)
+                    "*Current Profit:* `{current_profit:.2f}%`",
-                for result in results
+
-            ]
+                    # Adding initial stoploss only if it is different from stoploss
+                    "*Initial Stoploss:* `{initial_stop_loss:.8f}` " +
+                    ("`({initial_stop_loss_pct:.2f}%)`" if r['initial_stop_loss_pct'] else "")
+                    if r['stop_loss'] != r['initial_stop_loss'] else "",
+
+                    # Adding stoploss and stoploss percentage only if it is not None
+                    "*Stoploss:* `{stop_loss:.8f}` " +
+                    ("`({stop_loss_pct:.2f}%)`" if r['stop_loss_pct'] else ""),
+
+                    "*Open Order:* `{open_order}`" if r['open_order'] else ""
+                ]
+                # Filter empty lines using list-comprehension
+                messages.append("\n".join([l for l in lines if l]).format(**r))
+
             for msg in messages:
                 self._send_msg(msg, bot=bot)
+
         except RPCException as e:
             self._send_msg(str(e), bot=bot)
 
@@ -246,14 +263,15 @@ class Telegram(RPC):
                 stake_cur,
                 fiat_disp_cur
             )
-            stats = tabulate(stats,
+            stats_tab = tabulate(stats,
-                             headers=[
+                                 headers=[
-                                 'Day',
+                                     'Day',
-                                 f'Profit {stake_cur}',
+                                     f'Profit {stake_cur}',
-                                 f'Profit {fiat_disp_cur}'
+                                     f'Profit {fiat_disp_cur}',
-                             ],
+                                     f'Trades'
-                             tablefmt='simple')
+                                 ],
-            message = f'<b>Daily Profit over the last {timescale} days</b>:\n<pre>{stats}</pre>'
+                                 tablefmt='simple')
+            message = f'<b>Daily Profit over the last {timescale} days</b>:\n<pre>{stats_tab}</pre>'
             self._send_msg(message, bot=bot, parse_mode=ParseMode.HTML)
         except RPCException as e:
             self._send_msg(str(e), bot=bot)
@@ -311,13 +329,20 @@ class Telegram(RPC):
             output = ''
             for currency in result['currencies']:
                 if currency['est_btc'] > 0.0001:
-                    output += "*{currency}:*\n" \
+                    curr_output = "*{currency}:*\n" \
                             "\t`Available: {available: .8f}`\n" \
                             "\t`Balance: {balance: .8f}`\n" \
                             "\t`Pending: {pending: .8f}`\n" \
                             "\t`Est. BTC: {est_btc: .8f}`\n".format(**currency)
                 else:
-                    output += "*{currency}:* not showing <1$ amount \n".format(**currency)
+                    curr_output = "*{currency}:* not showing <1$ amount \n".format(**currency)
+
+                # Handle overflowing messsage length
+                if len(output + curr_output) >= MAX_TELEGRAM_MESSAGE_LENGTH:
+                    self._send_msg(output, bot=bot)
+                    output = curr_output
+                else:
+                    output += curr_output
 
             output += "\n*Estimated Value*:\n" \
                       "\t`BTC: {total: .8f}`\n" \
@@ -362,6 +387,18 @@ class Telegram(RPC):
         msg = self._rpc_reload_conf()
         self._send_msg('Status: `{status}`'.format(**msg), bot=bot)
 
+    @authorized_only
+    def _stopbuy(self, bot: Bot, update: Update) -> None:
+        """
+        Handler for /stop_buy.
+        Sets max_open_trades to 0 and gracefully sells all open trades
+        :param bot: telegram bot
+        :param update: message update
+        :return: None
+        """
+        msg = self._rpc_stopbuy()
+        self._send_msg('Status: `{status}`'.format(**msg), bot=bot)
+
     @authorized_only
     def _forcesell(self, bot: Bot, update: Update) -> None:
         """
@@ -374,7 +411,9 @@ class Telegram(RPC):
 
         trade_id = update.message.text.replace('/forcesell', '').strip()
         try:
-            self._rpc_forcesell(trade_id)
+            msg = self._rpc_forcesell(trade_id)
+            self._send_msg('Forcesell Result: `{result}`'.format(**msg), bot=bot)
+
         except RPCException as e:
             self._send_msg(str(e), bot=bot)
 
@@ -428,12 +467,10 @@ class Telegram(RPC):
         :return: None
         """
         try:
-            trades = self._rpc_count()
+            counts = self._rpc_count()
-            message = tabulate({
+            message = tabulate({k: [v] for k, v in counts.items()},
-                'current': [len(trades)],
+                               headers=['current', 'max', 'total stake'],
-                'max': [self._config['max_open_trades']],
+                               tablefmt='simple')
-                'total stake': [sum((trade.open_rate * trade.amount) for trade in trades)]
-            }, headers=['current', 'max', 'total stake'], tablefmt='simple')
             message = "<pre>{}</pre>".format(message)
             logger.debug(message)
             self._send_msg(message, parse_mode=ParseMode.HTML)
@@ -457,6 +494,38 @@ class Telegram(RPC):
         except RPCException as e:
             self._send_msg(str(e), bot=bot)
 
+    @authorized_only
+    def _blacklist(self, bot: Bot, update: Update, args: List[str]) -> None:
+        """
+        Handler for /blacklist
+        Shows the currently active blacklist
+        """
+        try:
+
+            blacklist = self._rpc_blacklist(args)
+
+            message = f"Blacklist contains {blacklist['length']} pairs\n"
+            message += f"`{', '.join(blacklist['blacklist'])}`"
+
+            logger.debug(message)
+            self._send_msg(message)
+        except RPCException as e:
+            self._send_msg(str(e), bot=bot)
+
+    @authorized_only
+    def _edge(self, bot: Bot, update: Update) -> None:
+        """
+        Handler for /edge
+        Shows information related to Edge
+        """
+        try:
+            edge_pairs = self._rpc_edge()
+            edge_pairs_tab = tabulate(edge_pairs, headers='keys', tablefmt='simple')
+            message = f'<b>Edge only validated following pairs:</b>\n<pre>{edge_pairs_tab}</pre>'
+            self._send_msg(message, bot=bot, parse_mode=ParseMode.HTML)
+        except RPCException as e:
+            self._send_msg(str(e), bot=bot)
+
     @authorized_only
     def _help(self, bot: Bot, update: Update) -> None:
         """
@@ -466,6 +535,8 @@ class Telegram(RPC):
         :param update: message update
         :return: None
         """
+        forcebuy_text = "*/forcebuy <pair> [<rate>]:* `Instantly buys the given pair. " \
+                        "Optionally takes a rate at which to buy.` \n"
         message = "*/start:* `Starts the trader`\n" \
                   "*/stop:* `Stops the trader`\n" \
                   "*/status [table]:* `Lists all open trades`\n" \
@@ -473,13 +544,18 @@ class Telegram(RPC):
                   "*/profit:* `Lists cumulative profit from all finished trades`\n" \
                   "*/forcesell <trade_id>|all:* `Instantly sells the given trade or all trades, " \
                   "regardless of profit`\n" \
+                  f"{forcebuy_text if self._config.get('forcebuy_enable', False) else '' }" \
                   "*/performance:* `Show performance of each finished trade grouped by pair`\n" \
                   "*/daily <n>:* `Shows profit or loss per day, over the last n days`\n" \
                   "*/count:* `Show number of trades running compared to allowed number of trades`" \
                   "\n" \
                   "*/balance:* `Show account balance per currency`\n" \
+                  "*/stopbuy:* `Stops buying, but handles open trades gracefully` \n" \
                   "*/reload_conf:* `Reload configuration file` \n" \
                   "*/whitelist:* `Show current whitelist` \n" \
+                  "*/blacklist [pair]:* `Show current blacklist, or adds one or more pairs " \
+                  "to the blacklist.` \n" \
+                  "*/edge:* `Shows validated pairs by Edge if it is enabeld` \n" \
                   "*/help:* `This help message`\n" \
                   "*/version:* `Show version`"
 

freqtrade/state.py

@@ -3,13 +3,26 @@
 """
 Bot state constant
 """
-import enum
+from enum import Enum
 
 
-class State(enum.Enum):
+class State(Enum):
     """
     Bot application states
     """
-    RUNNING = 0
+    RUNNING = 1
-    STOPPED = 1
+    STOPPED = 2
-    RELOAD_CONF = 2
+    RELOAD_CONF = 3
+
+
+class RunMode(Enum):
+    """
+    Bot running mode (backtest, hyperopt, ...)
+    can be "live", "dry-run", "backtest", "edge", "hyperopt".
+    """
+    LIVE = "live"
+    DRY_RUN = "dry_run"
+    BACKTEST = "backtest"
+    EDGE = "edge"
+    HYPEROPT = "hyperopt"
+    OTHER = "other"  # Used for plotting scripts and test

freqtrade/strategy/__init__.py

@@ -6,6 +6,7 @@ from freqtrade.strategy.interface import IStrategy
 # Import Default-Strategy to have hyperopt correctly resolve
 from freqtrade.strategy.default_strategy import DefaultStrategy  # noqa: F401
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -16,7 +17,6 @@ def import_strategy(strategy: IStrategy, config: dict) -> IStrategy:
     """
 
     # Copy all attributes from base class and class
-
     comb = {**strategy.__class__.__dict__, **strategy.__dict__}
 
     # Delete '_abc_impl' from dict as deepcopy fails on 3.7 with
@@ -26,6 +26,7 @@ def import_strategy(strategy: IStrategy, config: dict) -> IStrategy:
         del comb['_abc_impl']
 
     attr = deepcopy(comb)
+
     # Adjust module name
     attr['__module__'] = 'freqtrade.strategy'
 

freqtrade/strategy/default_strategy.py

@@ -42,6 +42,19 @@ class DefaultStrategy(IStrategy):
         'sell': 'gtc',
     }
 
+    def informative_pairs(self):
+        """
+        Define additional, informative pair/interval combinations to be cached from the exchange.
+        These pair/interval combinations are non-tradeable, unless they are part
+        of the whitelist as well.
+        For more information, please consult the documentation
+        :return: List of tuples in the format (pair, interval)
+            Sample: return [("ETH/USDT", "5m"),
+                            ("BTC/USDT", "15m"),
+                            ]
+        """
+        return []
+
     def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
         """
         Adds several different TA indicators to the given DataFrame

freqtrade/strategy/interface.py

@@ -4,16 +4,19 @@ This module defines the interface to apply for strategies
 """
 import logging
 from abc import ABC, abstractmethod
-from datetime import datetime
+from datetime import datetime, timezone
 from enum import Enum
-from typing import Dict, List, NamedTuple, Tuple
+from typing import Dict, List, NamedTuple, Optional, Tuple
 import warnings
 
 import arrow
 from pandas import DataFrame
 
-from freqtrade import constants
+from freqtrade.data.dataprovider import DataProvider
+from freqtrade.exchange import timeframe_to_minutes
 from freqtrade.persistence import Trade
+from freqtrade.wallets import Wallets
+
 
 logger = logging.getLogger(__name__)
 
@@ -67,6 +70,12 @@ class IStrategy(ABC):
     # associated stoploss
     stoploss: float
 
+    # trailing stoploss
+    trailing_stop: bool = False
+    trailing_stop_positive: float
+    trailing_stop_positive_offset: float
+    trailing_only_offset_is_reached = False
+
     # associated ticker interval
     ticker_interval: str
 
@@ -75,7 +84,8 @@ class IStrategy(ABC):
         'buy': 'limit',
         'sell': 'limit',
         'stoploss': 'limit',
-        'stoploss_on_exchange': False
+        'stoploss_on_exchange': False,
+        'stoploss_on_exchange_interval': 60,
     }
 
     # Optional time in force
@@ -87,12 +97,17 @@ class IStrategy(ABC):
     # run "populate_indicators" only for new candle
     process_only_new_candles: bool = False
 
-    # Dict to determine if analysis is necessary
+    # Class level variables (intentional) containing
-    _last_candle_seen_per_pair: Dict[str, datetime] = {}
+    # the dataprovider (dp) (access to other candles, historic data, ...)
+    # and wallets - access to the current balance.
+    dp: DataProvider
+    wallets: Wallets
 
     def __init__(self, config: dict) -> None:
         self.config = config
-        self._last_candle_seen_per_pair = {}
+        # Dict to determine if analysis is necessary
+        self._last_candle_seen_per_pair: Dict[str, datetime] = {}
+        self._pair_locked_until: Dict[str, datetime] = {}
 
     @abstractmethod
     def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
@@ -121,17 +136,65 @@ class IStrategy(ABC):
         :return: DataFrame with sell column
         """
 
+    def informative_pairs(self) -> List[Tuple[str, str]]:
+        """
+        Define additional, informative pair/interval combinations to be cached from the exchange.
+        These pair/interval combinations are non-tradeable, unless they are part
+        of the whitelist as well.
+        For more information, please consult the documentation
+        :return: List of tuples in the format (pair, interval)
+            Sample: return [("ETH/USDT", "5m"),
+                            ("BTC/USDT", "15m"),
+                            ]
+        """
+        return []
+
     def get_strategy_name(self) -> str:
         """
         Returns strategy class name
         """
         return self.__class__.__name__
 
+    def lock_pair(self, pair: str, until: datetime) -> None:
+        """
+        Locks pair until a given timestamp happens.
+        Locked pairs are not analyzed, and are prevented from opening new trades.
+        :param pair: Pair to lock
+        :param until: datetime in UTC until the pair should be blocked from opening new trades.
+                Needs to be timezone aware `datetime.now(timezone.utc)`
+        """
+        self._pair_locked_until[pair] = until
+
+    def is_pair_locked(self, pair: str) -> bool:
+        """
+        Checks if a pair is currently locked
+        """
+        if pair not in self._pair_locked_until:
+            return False
+        return self._pair_locked_until[pair] >= datetime.now(timezone.utc)
+
     def analyze_ticker(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
         """
         Parses the given ticker history and returns a populated DataFrame
         add several TA indicators and buy signal to it
-        :return DataFrame with ticker data and indicator data
+        :param dataframe: Dataframe containing ticker data
+        :param metadata: Metadata dictionary with additional data (e.g. 'pair')
+        :return: DataFrame with ticker data and indicator data
+        """
+        logger.debug("TA Analysis Launched")
+        dataframe = self.advise_indicators(dataframe, metadata)
+        dataframe = self.advise_buy(dataframe, metadata)
+        dataframe = self.advise_sell(dataframe, metadata)
+        return dataframe
+
+    def _analyze_ticker_internal(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        """
+        Parses the given ticker history and returns a populated DataFrame
+        add several TA indicators and buy signal to it
+        WARNING: Used internally only, may skip analysis if `process_only_new_candles` is set.
+        :param dataframe: Dataframe containing ticker data
+        :param metadata: Metadata dictionary with additional data (e.g. 'pair')
+        :return: DataFrame with ticker data and indicator data
         """
 
         pair = str(metadata.get('pair'))
@@ -141,19 +204,16 @@ class IStrategy(ABC):
         if (not self.process_only_new_candles or
                 self._last_candle_seen_per_pair.get(pair, None) != dataframe.iloc[-1]['date']):
             # Defs that only make change on new candle data.
-            logging.debug("TA Analysis Launched")
+            dataframe = self.analyze_ticker(dataframe, metadata)
-            dataframe = self.advise_indicators(dataframe, metadata)
-            dataframe = self.advise_buy(dataframe, metadata)
-            dataframe = self.advise_sell(dataframe, metadata)
             self._last_candle_seen_per_pair[pair] = dataframe.iloc[-1]['date']
         else:
-            logging.debug("Skippinig TA Analysis for already analyzed candle")
+            logger.debug("Skipping TA Analysis for already analyzed candle")
             dataframe['buy'] = 0
             dataframe['sell'] = 0
 
         # Other Defs in strategy that want to be called every loop here
         # twitter_sell = self.watch_twitter_feed(dataframe, metadata)
-        logging.debug("Loop Analysis Launched")
+        logger.debug("Loop Analysis Launched")
 
         return dataframe
 
@@ -171,7 +231,7 @@ class IStrategy(ABC):
             return False, False
 
         try:
-            dataframe = self.analyze_ticker(dataframe, {'pair': pair})
+            dataframe = self._analyze_ticker_internal(dataframe, {'pair': pair})
         except ValueError as error:
             logger.warning(
                 'Unable to analyze ticker for pair %s: %s',
@@ -195,7 +255,7 @@ class IStrategy(ABC):
 
         # Check if dataframe is out of date
         signal_date = arrow.get(latest['date'])
-        interval_minutes = constants.TICKER_INTERVAL_MINUTES[interval]
+        interval_minutes = timeframe_to_minutes(interval)
         offset = self.config.get('exchange', {}).get('outdated_offset', 5)
         if signal_date < (arrow.utcnow().shift(minutes=-(interval_minutes * 2 + offset))):
             logger.warning(
@@ -219,8 +279,11 @@ class IStrategy(ABC):
                     sell: bool, low: float = None, high: float = None,
                     force_stoploss: float = 0) -> SellCheckTuple:
         """
-        This function evaluate if on the condition required to trigger a sell has been reached
+        This function evaluates if one of the conditions required to trigger a sell
-        if the threshold is reached and updates the trade record.
+        has been reached, which can either be a stop-loss, ROI or sell-signal.
+        :param low: Only used during backtesting to simulate stoploss
+        :param high: Only used during backtesting, to simulate ROI
+        :param force_stoploss: Externally provided stoploss
         :return: True if trade should be sold, False otherwise
         """
 
@@ -228,17 +291,16 @@ class IStrategy(ABC):
         current_rate = low or rate
         current_profit = trade.calc_profit_percent(current_rate)
 
-        if self.order_types.get('stoploss_on_exchange'):
+        trade.adjust_min_max_rates(high or current_rate)
-            stoplossflag = SellCheckTuple(sell_flag=False, sell_type=SellType.NONE)
+
-        else:
+        stoplossflag = self.stop_loss_reached(current_rate=current_rate, trade=trade,
-            stoplossflag = self.stop_loss_reached(current_rate=current_rate, trade=trade,
+                                              current_time=date, current_profit=current_profit,
-                                                  current_time=date, current_profit=current_profit,
+                                              force_stoploss=force_stoploss, high=high)
-                                                  force_stoploss=force_stoploss)
 
         if stoplossflag.sell_flag:
             return stoplossflag
 
-        # Set current rate to low for backtesting sell
+        # Set current rate to high for backtesting sell
         current_rate = high or rate
         current_profit = trade.calc_profit_percent(current_rate)
         experimental = self.config.get('experimental', {})
@@ -262,8 +324,9 @@ class IStrategy(ABC):
 
         return SellCheckTuple(sell_flag=False, sell_type=SellType.NONE)
 
-    def stop_loss_reached(self, current_rate: float, trade: Trade, current_time: datetime,
+    def stop_loss_reached(self, current_rate: float, trade: Trade,
-                          current_profit: float, force_stoploss: float) -> SellCheckTuple:
+                          current_time: datetime, current_profit: float,
+                          force_stoploss: float, high: float = None) -> SellCheckTuple:
         """
         Based on current profit of the trade and configured (trailing) stoploss,
         decides to sell or not
@@ -271,14 +334,39 @@ class IStrategy(ABC):
         """
 
         trailing_stop = self.config.get('trailing_stop', False)
+        stop_loss_value = force_stoploss if force_stoploss else self.stoploss
 
-        trade.adjust_stop_loss(trade.open_rate, force_stoploss if force_stoploss
+        # Initiate stoploss with open_rate. Does nothing if stoploss is already set.
-                               else self.stoploss, initial=True)
+        trade.adjust_stop_loss(trade.open_rate, stop_loss_value, initial=True)
+
+        if trailing_stop:
+            # trailing stoploss handling
+            sl_offset = self.config.get('trailing_stop_positive_offset') or 0.0
+            tsl_only_offset = self.config.get('trailing_only_offset_is_reached', False)
+
+            # Make sure current_profit is calculated using high for backtesting.
+            high_profit = current_profit if not high else trade.calc_profit_percent(high)
+
+            # Don't update stoploss if trailing_only_offset_is_reached is true.
+            if not (tsl_only_offset and high_profit < sl_offset):
+                # Specific handling for trailing_stop_positive
+                if 'trailing_stop_positive' in self.config and high_profit > sl_offset:
+                    # Ignore mypy error check in configuration that this is a float
+                    stop_loss_value = self.config.get('trailing_stop_positive')  # type: ignore
+                    logger.debug(f"using positive stop loss: {stop_loss_value} "
+                                 f"offset: {sl_offset:.4g} profit: {current_profit:.4f}%")
+
+                trade.adjust_stop_loss(high or current_rate, stop_loss_value)
+
+        # evaluate if the stoploss was hit if stoploss is not on exchange
+        if ((self.stoploss is not None) and
+            (trade.stop_loss >= current_rate) and
+                (not self.order_types.get('stoploss_on_exchange'))):
 
-        # evaluate if the stoploss was hit
-        if self.stoploss is not None and trade.stop_loss >= current_rate:
             selltype = SellType.STOP_LOSS
-            if trailing_stop:
+
+            # If initial stoploss is not the same as current one then it is trailing.
+            if trade.initial_stop_loss != trade.stop_loss:
                 selltype = SellType.TRAILING_STOP_LOSS
                 logger.debug(
                     f"HIT STOP: current price at {current_rate:.6f}, "
@@ -290,42 +378,34 @@ class IStrategy(ABC):
             logger.debug('Stop loss hit.')
             return SellCheckTuple(sell_flag=True, sell_type=selltype)
 
-        # update the stop loss afterwards, after all by definition it's supposed to be hanging
-        if trailing_stop:
-
-            # check if we have a special stop loss for positive condition
-            # and if profit is positive
-            stop_loss_value = self.stoploss
-            sl_offset = self.config.get('trailing_stop_positive_offset', 0.0)
-
-            if 'trailing_stop_positive' in self.config and current_profit > sl_offset:
-
-                # Ignore mypy error check in configuration that this is a float
-                stop_loss_value = self.config.get('trailing_stop_positive')  # type: ignore
-                logger.debug(f"using positive stop loss mode: {stop_loss_value} "
-                             f"with offset {sl_offset:.4g} "
-                             f"since we have profit {current_profit:.4f}%")
-
-            trade.adjust_stop_loss(current_rate, stop_loss_value)
-
         return SellCheckTuple(sell_flag=False, sell_type=SellType.NONE)
 
+    def min_roi_reached_entry(self, trade_dur: int) -> Optional[float]:
+        """
+        Based on trade duration defines the ROI entry that may have been reached.
+        :param trade_dur: trade duration in minutes
+        :return: minimal ROI entry value or None if none proper ROI entry was found.
+        """
+        # Get highest entry in ROI dict where key <= trade-duration
+        roi_list = list(filter(lambda x: x <= trade_dur, self.minimal_roi.keys()))
+        if not roi_list:
+            return None
+        roi_entry = max(roi_list)
+        return self.minimal_roi[roi_entry]
+
     def min_roi_reached(self, trade: Trade, current_profit: float, current_time: datetime) -> bool:
         """
-        Based an earlier trade and current price and ROI configuration, decides whether bot should
+        Based on trade duration, current price and ROI configuration, decides whether bot should
-        sell
+        sell. Requires current_profit to be in percent!!
-        :return True if bot should sell at current rate
+        :return: True if bot should sell at current rate
         """
-
         # Check if time matches and current rate is above threshold
-        time_diff = (current_time.timestamp() - trade.open_date.timestamp()) / 60
+        trade_dur = int((current_time.timestamp() - trade.open_date.timestamp()) // 60)
-        for duration, threshold in self.minimal_roi.items():
+        roi = self.min_roi_reached_entry(trade_dur)
-            if time_diff <= duration:
+        if roi is None:
-                return False
+            return False
-            if current_profit > threshold:
+        else:
-                return True
+            return current_profit > roi
-
-        return False
 
     def tickerdata_to_dataframe(self, tickerdata: Dict[str, List]) -> Dict[str, DataFrame]:
         """
@@ -342,6 +422,7 @@ class IStrategy(ABC):
         :param metadata: Additional information, like the currently traded pair
         :return: a Dataframe with all mandatory indicators for the strategies
         """
+        logger.debug(f"Populating indicators for pair {metadata.get('pair')}.")
         if self._populate_fun_len == 2:
             warnings.warn("deprecated - check out the Sample strategy to see "
                           "the current function headers!", DeprecationWarning)
@@ -357,6 +438,7 @@ class IStrategy(ABC):
         :param pair: Additional information, like the currently traded pair
         :return: DataFrame with buy column
         """
+        logger.debug(f"Populating buy signals for pair {metadata.get('pair')}.")
         if self._buy_fun_len == 2:
             warnings.warn("deprecated - check out the Sample strategy to see "
                           "the current function headers!", DeprecationWarning)
@@ -372,6 +454,7 @@ class IStrategy(ABC):
         :param pair: Additional information, like the currently traded pair
         :return: DataFrame with sell column
         """
+        logger.debug(f"Populating sell signals for pair {metadata.get('pair')}.")
         if self._sell_fun_len == 2:
             warnings.warn("deprecated - check out the Sample strategy to see "
                           "the current function headers!", DeprecationWarning)