Merge pull request #1578 from freqtrade/release/0.18.1

Release/0.18.1

.pyup.yml

@@ -1,4 +1,33 @@
 # autogenerated pyup.io config file
 # see https://pyup.io/docs/configuration/ for all available options
 
-schedule: every day
+# 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
+  - requirements-plot.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,9 +1,15 @@
 sudo: true
 os:
 - linux
+dist: xenial
 language: python
 python:
 - 3.6
+services:
+  - docker
+env:
+  global:
+    - IMAGE_NAME=freqtradeorg/freqtrade
 addons:
   apt:
     packages:
@@ -11,28 +17,43 @@ addons:
     - libdw-dev
     - binutils-dev
 install:
-- ./install_ta-lib.sh
+- cd build_helpers && ./install_ta-lib.sh; cd ..
 - export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH
-- pip install --upgrade flake8 coveralls pytest-random-order pytest-asyncio mypy
-- pip install -r requirements.txt
+- pip install --upgrade pytest-random-order
+- pip install -r requirements-dev.txt
 - pip install -e .
 jobs:
   include:
-    - script:
+    - stage: tests
+      script:
       - pytest --cov=freqtrade --cov-config=.coveragerc freqtrade/tests/
-      - coveralls
+      name: pytest
     - script:
       - cp config.json.example config.json
       - python freqtrade/main.py --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
+      name: hyperopt
     - script: flake8 freqtrade
+      name: flake8
     - script: mypy freqtrade
+      name: mypy
+
+    - stage: docker
+      if: branch in (master, develop, feat/improve_travis) AND (type in (push, cron))
+      script:
+        - build_helpers/publish_docker.sh
+      name: "Build and test and push docker image"
+
+after_success:
+  - coveralls
+
 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
-    - ta-lib
+    - /usr/local/lib

CONTRIBUTING.md

@@ -1,43 +1,52 @@
-# Contribute to freqtrade
+# Contributing
 
-Feel like our bot is missing a feature? We welcome your pull requests! Few pointers for contributions:
+## Contribute to freqtrade
+
+Feel like our bot is missing a feature? We welcome your pull requests! 
+
+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.
+
+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).
+- 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)
 or in a [issue](https://github.com/freqtrade/freqtrade/issues) before a PR.
 
+## Getting started
 
-**Before sending the PR:**
+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.
 
-## 1. Run unit tests
+## Before sending the PR:
+
+### 1. Run unit tests
 
 All unit tests must pass. If a unit test is broken, change your code to 
 make it pass. It means you have introduced a regression.
 
-**Test the whole project**
+#### Test the whole project
+
 ```bash
 pytest freqtrade
 ```
 
-**Test only one file**
+#### Test only one file
+
 ```bash
 pytest freqtrade/tests/test_<file_name>.py
 ```
 
-**Test only one method from one file**
+#### Test only one method from one file
+
 ```bash
 pytest freqtrade/tests/test_<file_name>.py::test_<method_name>
 ```
 
-## 2. Test if your code is PEP8 compliant
-**Install packages** (If not already installed)
-```bash
-pip3.6 install flake8 coveralls
-``` 
-**Run Flake8**
+### 2. Test if your code is PEP8 compliant
+
+#### Run Flake8
+
 ```bash
 flake8 freqtrade
 ```
@@ -47,16 +56,64 @@ To help with that, we encourage you to install the git pre-commit
 hook that will warn you when you try to commit code that fails these checks. 
 Guide for installing them is [here](http://flake8.pycqa.org/en/latest/user/using-hooks.html).
 
-## 3. Test if all type-hints are correct
+### 3. Test if all type-hints are correct
 
-**Install packages** (If not already installed)
-
-``` bash
-pip3.6 install mypy
-```
-
-**Run mypy**
+#### Run mypy
 
 ``` bash
 mypy freqtrade
 ```
+
+## (Core)-Committer Guide
+
+### Process: Pull Requests
+
+How to prioritize pull requests, from most to least important:
+
+1. Fixes for broken tests. Broken means broken on any supported platform or Python version.
+1. Extra tests to cover corner cases.
+1. Minor edits to docs.
+1. Bug fixes.
+1. Major edits to docs.
+1. Features.
+
+Ensure that each pull request meets all requirements in the Contributing document.
+
+### Process: Issues
+
+If an issue is a bug that needs an urgent fix, mark it for the next patch release.
+Then either fix it or mark as please-help.
+
+For other issues: encourage friendly discussion, moderate debate, offer your thoughts.
+
+### Process: Your own code changes
+
+All code changes, regardless of who does them, need to be reviewed and merged by someone else.
+This rule applies to all the core committers.
+
+Exceptions:
+
+- Minor corrections and fixes to pull requests submitted by others.
+- While making a formal release, the release manager can make necessary, appropriate changes.
+- Small documentation changes that reinforce existing subject matter. Most commonly being, but not limited to spelling and grammar corrections.
+
+### Responsibilities
+
+- Ensure cross-platform compatibility for every change that's accepted. Windows, Mac & Linux.
+- Ensure no malicious code is introduced into the core code.
+- Create issues for any major changes and enhancements that you wish to make. Discuss things transparently and get community feedback.
+- Keep feature versions as small as possible, preferably one new feature per version.
+- Be welcoming to newcomers and encourage diverse new contributors from all backgrounds. See the Python Community Code of Conduct (https://www.python.org/psf/codeofconduct/).
+
+### Becoming a Committer
+
+Contributors may be given commit privileges. Preference will be given to those with:
+
+1. Past contributions to FreqTrade and other related open-source projects. Contributions to FreqTrade include both code (both accepted and pending) and friendly participation in the issue tracker and Pull request reviews. Quantity and quality are considered.
+1. A coding style that the other core committers find simple, minimal, and clean.
+1. Access to resources for cross-platform development and testing.
+1. Time to devote to the project regularly.
+
+Beeing a Committer does not grant write permission on `develop` or `master` for security reasons (Users trust FreqTrade with their Exchange API keys).
+
+After beeing Committer for some time, a Committer may be named Core Committer and given full repository access.

Dockerfile

@@ -1,19 +1,20 @@
-FROM python:3.7.0-slim-stretch
+FROM python:3.7.2-slim-stretch
 
-# Install TA-lib
-RUN apt-get update && apt-get -y install curl build-essential && apt-get clean
-RUN curl -L http://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz | \
-  tar xzvf - && \
-  cd ta-lib && \
-  sed -i "s|0.00000001|0.000000000000000001 |g" src/ta_func/ta_utility.h && \
-  ./configure && make && make install && \
-  cd .. && rm -rf ta-lib
-ENV LD_LIBRARY_PATH /usr/local/lib
+RUN apt-get update \
+    && apt-get -y install curl build-essential \
+    && apt-get clean \
+    && pip install --upgrade pip
 
 # Prepare environment
 RUN mkdir /freqtrade
 WORKDIR /freqtrade
 
+# Install TA-lib
+COPY build_helpers/* /tmp/
+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/
 RUN pip install numpy --no-cache-dir \

Dockerfile.develop

@@ -0,0 +1,9 @@
+FROM freqtradeorg/freqtrade:develop
+
+# Install dependencies
+COPY requirements-dev.txt /freqtrade/
+RUN pip install numpy --no-cache-dir \
+  && pip install -r requirements-dev.txt --no-cache-dir
+
+# Empty the ENTRYPOINT to allow all commands
+ENTRYPOINT []

Dockerfile.technical

@@ -0,0 +1,6 @@
+FROM freqtradeorg/freqtrade:develop
+
+RUN apt-get update \
+    && apt-get -y install git \
+    && apt-get clean \
+    && pip install git+https://github.com/berlinguyinca/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,43 +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] **Persistence**: Persistence is achieved through sqlite
+- [x] **Based on Python 3.6+**: For botting on any operating system - Windows, macOS and Linux.
+- [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] **Whitelist crypto-currencies**: Select which crypto-currency you want to trade.
+- [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)
-- [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)
- 
-
 ## Quick start
 
 Freqtrade provides a Linux/macOS script to install all dependencies and help you to configure the bot.
@@ -75,63 +60,52 @@ 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]
-               [--strategy-path PATH] [--dynamic-whitelist [INT]]
-               [--dry-run-db]
-               {backtesting,hyperopt} ...
+               [--strategy-path PATH] [--customhyperopt NAME]
+               [--dynamic-whitelist [INT]] [--db-url PATH]
+               {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
+    edge                edge module
     hyperopt            hyperopt module
 
 optional arguments:
   -h, --help            show this help message and exit
-  -v, --verbose         be verbose
-  --version             show program's version number and exit
+  -v, --verbose         verbose mode (-vv for more, -vvv to get all messages)
+  --version             show program\'s version number and exit
   -c PATH, --config PATH
                         specify configuration file (default: config.json)
   -d PATH, --datadir PATH
-                        path to backtest data (default:
-                        freqtrade/tests/testdata
+                        path to backtest data
   -s NAME, --strategy NAME
                         specify strategy class name (default: DefaultStrategy)
   --strategy-path PATH  specify additional strategy lookup path
+  --customhyperopt NAME
+                        specify hyperopt class name (default:
+                        DefaultHyperOpts)
   --dynamic-whitelist [INT]
                         dynamically generate and update whitelist based on 24h
-                        BaseVolume (Default 20 currencies)
-  --dry-run-db          Force dry run to use a local DB
-                        "tradesv3.dry_run.sqlite" instead of memory DB. Work
-                        only if dry_run is enabled.
+                        BaseVolume (default: 20) DEPRECATED.
+  --db-url PATH         Override trades database URL, this is useful if
+                        dry_run is enabled or in custom deployments (default:
+                        None)
 ```
 
 ### 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
@@ -190,10 +164,14 @@ in the bug reports.
 ### [Pull Requests](https://github.com/freqtrade/freqtrade/pulls)
 
 Feel like our bot is missing a feature? We welcome your pull requests!
+
 Please read our
 [Contributing document](https://github.com/freqtrade/freqtrade/blob/develop/CONTRIBUTING.md)
 to understand the requirements before sending your pull-requests.
 
+Coding is not a neccessity to contribute - maybe start with improving our documentation?
+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.
 
 **Important:** Always create your PR against the `develop` branch, not `master`.

build_helpers/install_ta-lib.sh

@@ -0,0 +1,11 @@
+if [ ! -f "/usr/local/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 \
+  && make \
+  && which sudo && sudo make install || make install \
+  && cd ..
+else
+  echo "TA-lib already installed, skipping installation"
+fi

build_helpers/publish_docker.sh

@@ -0,0 +1,60 @@
+#!/bin/sh
+# - export TAG=`if [ "$TRAVIS_BRANCH" == "develop" ]; then echo "latest"; else echo $TRAVIS_BRANCH ; fi`
+# Replace / with _ to create a valid tag
+TAG=$(echo "${TRAVIS_BRANCH}" | sed -e "s/\//_/")
+
+
+# Add commit and commit_message to docker container
+echo "${TRAVIS_COMMIT} ${TRAVIS_COMMIT_MESSAGE}" > freqtrade_commit
+
+if [ "${TRAVIS_EVENT_TYPE}" = "cron" ]; then
+    echo "event ${TRAVIS_EVENT_TYPE}: full rebuild - skipping cache"
+    docker build -t freqtrade:${TAG} .
+else
+    echo "event ${TRAVIS_EVENT_TYPE}: building with cache"
+    # Pull last build to avoid rebuilding the whole image
+    docker pull ${IMAGE_NAME}:${TAG}
+    docker build --cache-from ${IMAGE_NAME}:${TAG} -t freqtrade:${TAG} .
+fi
+
+if [ $? -ne 0 ]; then
+    echo "failed building image"
+    return 1
+fi
+
+# Run backtest
+docker run --rm -it -v $(pwd)/config.json.example:/freqtrade/config.json:ro freqtrade:${TAG} --datadir freqtrade/tests/testdata backtesting
+
+if [ $? -ne 0 ]; then
+    echo "failed running backtest"
+    return 1
+fi
+
+# Tag image for upload
+docker tag freqtrade:$TAG ${IMAGE_NAME}:$TAG
+if [ $? -ne 0 ]; then
+    echo "failed tagging image"
+    return 1
+fi
+
+# Tag as latest for develop builds
+if [ "${TRAVIS_BRANCH}" = "develop" ]; then
+    docker tag freqtrade:$TAG ${IMAGE_NAME}:latest
+fi
+
+# Login
+echo "$DOCKER_PASS" | docker login -u $DOCKER_USER --password-stdin
+
+if [ $? -ne 0 ]; then
+    echo "failed login"
+    return 1
+fi
+
+# Show all available images
+docker images
+
+docker push ${IMAGE_NAME}
+if [ $? -ne 0 ]; then
+    echo "failed pushing repo"
+    return 1
+fi

config.json.example

@@ -28,7 +28,10 @@
         "name": "bittrex",
         "key": "your_exchange_key",
         "secret": "your_exchange_secret",
-        "ccxt_rate_limit": true,
+        "ccxt_config": {"enableRateLimit": true},
+        "ccxt_async_config": {
+            "enableRateLimit": false
+        },
         "pair_whitelist": [
             "ETH/BTC",
             "LTC/BTC",
@@ -50,12 +53,28 @@
         "sell_profit_only": false,
         "ignore_roi_if_buy_signal": false
     },
+    "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": true,
         "token": "your_telegram_token",
         "chat_id": "your_telegram_chat_id"
     },
     "initial_state": "running",
+    "forcebuy_enable": false,
     "internals": {
         "process_throttle_secs": 5
     }

config_binance.json.example

@@ -0,0 +1,83 @@
+{
+    "max_open_trades": 3,
+    "stake_currency": "BTC",
+    "stake_amount": 0.05,
+    "fiat_display_currency": "USD",
+    "ticker_interval" : "5m",
+    "dry_run": true,
+    "trailing_stop": false,
+    "unfilledtimeout": {
+        "buy": 10,
+        "sell": 30
+    },
+    "bid_strategy": {
+        "ask_last_balance": 0.0,
+        "use_order_book": false,
+        "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": "binance",
+        "key": "your_exchange_key",
+        "secret": "your_exchange_secret",
+        "ccxt_config": {"enableRateLimit": true},
+        "ccxt_async_config": {
+            "enableRateLimit": false
+        },
+        "pair_whitelist": [
+            "AST/BTC",
+            "ETC/BTC",
+            "ETH/BTC",
+            "EOS/BTC",
+            "IOTA/BTC",
+            "LTC/BTC",
+            "MTH/BTC",
+            "NCASH/BTC",
+            "TNT/BTC",
+            "XMR/BTC",
+            "XLM/BTC",
+            "XRP/BTC"
+        ],
+        "pair_blacklist": [
+            "BNB/BTC"
+        ]
+    },
+    "experimental": {
+        "use_sell_signal": false,
+        "sell_profit_only": false,
+        "ignore_roi_if_buy_signal": false
+    },
+    "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
+    }
+}

config_full.json.example

@@ -3,6 +3,7 @@
     "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,
@@ -33,11 +34,33 @@
         "order_book_min": 1,
         "order_book_max": 9
     },
+    "order_types": {
+        "buy": "limit",
+        "sell": "limit",
+        "stoploss": "market",
+        "stoploss_on_exchange": "false",
+        "stoploss_on_exchange_interval": 60
+    },
+    "order_time_in_force": {
+        "buy": "gtc",
+        "sell": "gtc",
+    },
+    "pairlist": {
+        "method": "VolumePairList",
+        "config": {
+            "number_assets": 20,
+            "sort_key": "quoteVolume"
+        }
+    },
     "exchange": {
         "name": "bittrex",
         "key": "your_exchange_key",
         "secret": "your_exchange_secret",
-        "ccxt_rate_limit": true,
+        "ccxt_config": {"enableRateLimit": true},
+        "ccxt_async_config": {
+            "enableRateLimit": false,
+            "aiohttp_trust_env": false
+        },
         "pair_whitelist": [
             "ETH/BTC",
             "LTC/BTC",
@@ -55,6 +78,21 @@
         ],
         "outdated_offset": 5
     },
+    "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
+    },
     "experimental": {
         "use_sell_signal": false,
         "sell_profit_only": false,
@@ -67,6 +105,7 @@
     },
     "db_url": "sqlite:///tradesv3.sqlite",
     "initial_state": "running",
+    "forcebuy_enable": false,
     "internals": {
         "process_throttle_secs": 5
     },

docs/backtesting.md

@@ -3,11 +3,6 @@
 This page explains how to validate your strategy performance by using
 Backtesting.
 
-## Table of Contents
-
-- [Test your strategy with Backtesting](#test-your-strategy-with-backtesting)
-- [Understand the backtesting result](#understand-the-backtesting-result)
-
 ## Test your strategy with Backtesting
 
 Now you have good Buy and Sell strategies, you want to test it against
@@ -171,53 +166,65 @@ The most important in the backtesting is to understand the result.
 A backtesting result will look like that:
 
 ```
-======================================== BACKTESTING REPORT =========================================
-| pair     |   buy count |   avg profit % |   total profit BTC |   avg duration |   profit |   loss |
-|:---------|------------:|---------------:|-------------------:|---------------:|---------:|-------:|
-| ETH/BTC  |          44 |           0.18 |         0.00159118 |           50.9 |       44 |      0 |
-| LTC/BTC  |          27 |           0.10 |         0.00051931 |          103.1 |       26 |      1 |
-| ETC/BTC  |          24 |           0.05 |         0.00022434 |          166.0 |       22 |      2 |
-| DASH/BTC |          29 |           0.18 |         0.00103223 |          192.2 |       29 |      0 |
-| ZEC/BTC  |          65 |          -0.02 |        -0.00020621 |          202.7 |       62 |      3 |
-| XLM/BTC  |          35 |           0.02 |         0.00012877 |          242.4 |       32 |      3 |
-| BCH/BTC  |          12 |           0.62 |         0.00149284 |           50.0 |       12 |      0 |
-| POWR/BTC |          21 |           0.26 |         0.00108215 |          134.8 |       21 |      0 |
-| ADA/BTC  |          54 |          -0.19 |        -0.00205202 |          191.3 |       47 |      7 |
-| XMR/BTC  |          24 |          -0.43 |        -0.00206013 |          120.6 |       20 |      4 |
-| TOTAL    |         335 |           0.03 |         0.00175246 |          157.9 |      315 |     20 |
-2018-06-13 06:57:27,347 - freqtrade.optimize.backtesting - INFO -
-====================================== LEFT OPEN TRADES REPORT ======================================
-| pair     |   buy count |   avg profit % |   total profit BTC |   avg duration |   profit |   loss |
-|:---------|------------:|---------------:|-------------------:|---------------:|---------:|-------:|
-| ETH/BTC  |           3 |           0.16 |         0.00009619 |           25.0 |        3 |      0 |
-| LTC/BTC  |           1 |          -1.00 |        -0.00020118 |         1085.0 |        0 |      1 |
-| ETC/BTC  |           2 |          -1.80 |        -0.00071933 |         1092.5 |        0 |      2 |
-| DASH/BTC |           0 |         nan    |         0.00000000 |          nan   |        0 |      0 |
-| ZEC/BTC  |           3 |          -4.27 |        -0.00256826 |         1301.7 |        0 |      3 |
-| XLM/BTC  |           3 |          -1.11 |        -0.00066744 |          965.0 |        0 |      3 |
-| BCH/BTC  |           0 |         nan    |         0.00000000 |          nan   |        0 |      0 |
-| POWR/BTC |           0 |         nan    |         0.00000000 |          nan   |        0 |      0 |
-| ADA/BTC  |           7 |          -3.58 |        -0.00503604 |          850.0 |        0 |      7 |
-| XMR/BTC  |           4 |          -3.79 |        -0.00303456 |          291.2 |        0 |      4 |
-| TOTAL    |          23 |          -2.63 |        -0.01213062 |          750.4 |        3 |     20 |
-
+========================================================= BACKTESTING REPORT ========================================================
+| pair     |   buy count |   avg profit % |   cum profit % |   tot profit BTC |   tot profit % | avg duration   |   profit |   loss |
+|:---------|------------:|---------------:|---------------:|-----------------:|---------------:|:---------------|---------:|-------:|
+| ADA/BTC  |          35 |          -0.11 |          -3.88 |      -0.00019428 |          -1.94 | 4:35:00        |       14 |     21 |
+| ARK/BTC  |          11 |          -0.41 |          -4.52 |      -0.00022647 |          -2.26 | 2:03:00        |        3 |      8 |
+| BTS/BTC  |          32 |           0.31 |           9.78 |       0.00048938 |           4.89 | 5:05:00        |       18 |     14 |
+| DASH/BTC |          13 |          -0.08 |          -1.07 |      -0.00005343 |          -0.53 | 4:39:00        |        6 |      7 |
+| ENG/BTC  |          18 |           1.36 |          24.54 |       0.00122807 |          12.27 | 2:50:00        |        8 |     10 |
+| EOS/BTC  |          36 |           0.08 |           3.06 |       0.00015304 |           1.53 | 3:34:00        |       16 |     20 |
+| ETC/BTC  |          26 |           0.37 |           9.51 |       0.00047576 |           4.75 | 6:14:00        |       11 |     15 |
+| ETH/BTC  |          33 |           0.30 |           9.96 |       0.00049856 |           4.98 | 7:31:00        |       16 |     17 |
+| IOTA/BTC |          32 |           0.03 |           1.09 |       0.00005444 |           0.54 | 3:12:00        |       14 |     18 |
+| LSK/BTC  |          15 |           1.75 |          26.26 |       0.00131413 |          13.13 | 2:58:00        |        6 |      9 |
+| LTC/BTC  |          32 |          -0.04 |          -1.38 |      -0.00006886 |          -0.69 | 4:49:00        |       11 |     21 |
+| NANO/BTC |          17 |           1.26 |          21.39 |       0.00107058 |          10.70 | 1:55:00        |       10 |      7 |
+| NEO/BTC  |          23 |           0.82 |          18.97 |       0.00094936 |           9.48 | 2:59:00        |       10 |     13 |
+| 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 |
+| XMR/BTC  |          23 |          -0.18 |          -4.13 |      -0.00020696 |          -2.07 | 5:30:00        |       12 |     11 |
+| XRP/BTC  |          35 |           0.66 |          22.96 |       0.00114897 |          11.48 | 3:49:00        |       12 |     23 |
+| ZEC/BTC  |          22 |          -0.46 |         -10.18 |      -0.00050971 |          -5.09 | 2:22:00        |        7 |     15 |
+| TOTAL    |         429 |           0.36 |         152.41 |       0.00762792 |          76.20 | 4:12:00        |      186 |    243 |
+========================================================= SELL REASON STATS =========================================================
+| Sell Reason        |   Count |
+|:-------------------|--------:|
+| trailing_stop_loss |     205 |
+| stop_loss          |     166 |
+| sell_signal        |      56 |
+| 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
-`52.9` min, with a performance of `-0.41%` (loss), that means it has 
-lost a total of `-0.00348593 BTC`.
+We understand the bot has made `429` trades for an average duration of
+`4:12:00`, with a performance of `76.20%` (profit), that means it has
+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
@@ -256,15 +263,15 @@ There will be an additional table comparing win/losses of the different strategi
 Detailed output for all strategies one after the other will be available, so make sure to scroll up.
 
 ```
-=================================================== Strategy Summary ====================================================
-| Strategy   |   buy count |   avg profit % |   cum profit % |   total profit ETH | avg duration    |   profit |   loss |
-|:-----------|------------:|---------------:|---------------:|-------------------:|:----------------|---------:|-------:|
-| Strategy1  |          19 |          -0.76 |         -14.39 |        -0.01440287 | 15:48:00        |       15 |      4 |
-| Strategy2  |           6 |          -2.73 |         -16.40 |        -0.01641299 | 1 day, 14:12:00 |        3 |      3 |
+=========================================================== Strategy Summary ===========================================================
+| Strategy    |   buy count |   avg profit % |   cum profit % |   tot profit BTC |   tot profit % | avg duration   |   profit |   loss |
+|:------------|------------:|---------------:|---------------:|-----------------:|---------------:|:---------------|---------:|-------:|
+| Strategy1   |         429 |           0.36 |         152.41 |       0.00762792 |          76.20 | 4:12:00        |      186 |    243 |
+| 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-optimization.md

@@ -1,17 +1,8 @@
-# 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)
-- [Add more Indicator](#add-more-indicator)
-- [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
@@ -33,87 +24,43 @@ 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`.
 
+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`
+
+### Anatomy of a strategy
+
 A strategy file contains all the information needed to build a good strategy:
 
+- Indicators
 - Buy strategy rules
 - Sell strategy rules
 - Minimal ROI recommended
-- Stoploss recommended
+- Stoploss strongly recommended
 
 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
-python3 ./freqtrade/main.py --strategy AwesomeStrategy
-```
-
-### Specify custom strategy location
-
-If you want to use a strategy from a different folder you can pass `--strategy-path`
-
 ```bash
-python3 ./freqtrade/main.py --strategy AwesomeStrategy --strategy-path /some/folder
+python3 ./freqtrade/main.py --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.**
 
-### Buy strategy
+!!! 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.
 
-Edit the method `populate_buy_trend()` into your strategy file to update your buy strategy.
+### Customize Indicators
 
-Sample from `user_data/strategies/test_strategy.py`:
-
-```python
-def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
-    """
-    Based on TA indicators, populates the buy signal for the given dataframe
-    :param dataframe: DataFrame populated with indicators
-    :param metadata: Additional information, like the currently traded pair
-    :return: DataFrame with buy column
-    """
-    dataframe.loc[
-        (
-            (dataframe['adx'] > 30) &
-            (dataframe['tema'] <= dataframe['bb_middleband']) &
-            (dataframe['tema'] > dataframe['tema'].shift(1))
-        ),
-        'buy'] = 1
-
-    return dataframe
-```
-
-### Sell strategy
-
-Edit the method `populate_sell_trend()` into your strategy file to update your sell strategy.
-Please note that the sell-signal is only used if `use_sell_signal` is set to true in the configuration.
-
-Sample from `user_data/strategies/test_strategy.py`:
-
-```python
-def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
-    """
-    Based on TA indicators, populates the sell signal for the given dataframe
-    :param dataframe: DataFrame populated with indicators
-    :param metadata: Additional information, like the currently traded pair
-    :return: DataFrame with buy column
-    """
-    dataframe.loc[
-        (
-            (dataframe['adx'] > 70) &
-            (dataframe['tema'] > dataframe['bb_middleband']) &
-            (dataframe['tema'] < dataframe['tema'].shift(1))
-        ),
-        'sell'] = 1
-    return dataframe
-```
-
-## Add more Indicators
-
-As you have seen, 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.
+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.
 
 You should only add the indicators used in either `populate_buy_trend()`, `populate_sell_trend()`, or to populate another indicator, otherwise performance may suffer.
 
+It's important to always return the dataframe without removing/modifying the columns `"open", "high", "low", "close", "volume"`, otherwise these fields would contain something unexpected.
+
 Sample:
 
 ```python
@@ -157,21 +104,260 @@ def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame
     return dataframe
 ```
 
+
+!!! Note "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).<br/>
+    Then uncomment indicators you need.
+
+### Buy signal rules
+
+Edit the method `populate_buy_trend()` in your strategy file to update your buy strategy.
+
+It's important to always return the dataframe without removing/modifying the columns `"open", "high", "low", "close", "volume"`, otherwise these fields would contain something unexpected.
+
+This will method will also define a new column, `"buy"`, which needs to contain 1 for buys, and 0 for "no action".
+
+Sample from `user_data/strategies/test_strategy.py`:
+
+```python
+def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+    """
+    Based on TA indicators, populates the buy signal for the given dataframe
+    :param dataframe: DataFrame populated with indicators
+    :param metadata: Additional information, like the currently traded pair
+    :return: DataFrame with buy column
+    """
+    dataframe.loc[
+        (
+            (dataframe['adx'] > 30) &
+            (dataframe['tema'] <= dataframe['bb_middleband']) &
+            (dataframe['tema'] > dataframe['tema'].shift(1))
+        ),
+        'buy'] = 1
+
+    return dataframe
+```
+
+### Sell signal rules
+
+Edit the method `populate_sell_trend()` into your strategy file to update your sell strategy.
+Please note that the sell-signal is only used if `use_sell_signal` is set to true in the configuration.
+
+It's important to always return the dataframe without removing/modifying the columns `"open", "high", "low", "close", "volume"`, otherwise these fields would contain something unexpected.
+
+This will method will also define a new column, `"sell"`, which needs to contain 1 for sells, and 0 for "no action".
+
+Sample from `user_data/strategies/test_strategy.py`:
+
+```python
+def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+    """
+    Based on TA indicators, populates the sell signal for the given dataframe
+    :param dataframe: DataFrame populated with indicators
+    :param metadata: Additional information, like the currently traded pair
+    :return: DataFrame with buy column
+    """
+    dataframe.loc[
+        (
+            (dataframe['adx'] > 70) &
+            (dataframe['tema'] > dataframe['bb_middleband']) &
+            (dataframe['tema'] < dataframe['tema'].shift(1))
+        ),
+        'sell'] = 1
+    return dataframe
+```
+
+### Minimal ROI
+
+This dict defines the minimal Return On Investment (ROI) a trade should reach before selling, independent from the sell signal.
+
+It is of the following format, with the dict key (left side of the colon) being the minutes passed since the trade opened, and the value (right side of the colon) being the percentage.
+
+```python
+minimal_roi = {
+    "40": 0.0,
+    "30": 0.01,
+    "20": 0.02,
+    "0": 0.04
+}
+```
+
+The above configuration would therefore mean:
+
+- Sell whenever 4% profit was reached
+- Sell when 2% profit was reached (in effect after 20 minutes)
+- Sell when 1% profit was reached (in effect after 30 minutes)
+- Sell when trade is non-loosing (in effect after 40 minutes)
+
+The calculation does include fees.
+
+To disable ROI completely, set it to an insanely high number:
+
+```python
+minimal_roi = {
+    "0": 100
+}
+```
+
+While technically not completely disabled, this would sell once the trade reaches 10000% Profit.
+
+### Stoploss
+
+Setting a stoploss is highly recommended to protect your capital from strong moves against you.
+
+Sample:
+
+``` python
+stoploss = -0.10
+```
+
+This would signify a stoploss of -10%.
+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).
+
+### Ticker interval
+
+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`.
 
-### Want more indicator examples
+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)
 
-Look into the [user_data/strategies/test_strategy.py](https://github.com/freqtrade/freqtrade/blob/develop/user_data/strategies/test_strategy.py).
-Then uncomment indicators you need.
+### 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.
+
+!!!Note:
+    The DataProvier is currently not available during backtesting / hyperopt, but this is planned for the future.
+
+All methods return `None` in case of failure (do not raise an exception).
+
+Please always check if the `DataProvider` is available to avoid failures during backtesting.
+
+#### 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 all pairs in the whitelist, returns DataFrame or empty DataFrame
+- `historic_ohlcv(pair, ticker_interval)` - Data stored on disk
+- `runmode` - Property containing the current runmode.
+
+#### ohlcv / historic_ohlcv
+
+``` python
+if self.dp:
+    if dp.runmode == 'live':
+        if ('ETH/BTC', ticker_interval) in self.dp.available_pairs:
+            data_eth = self.dp.ohlcv(pair='ETH/BTC',
+                                     ticker_interval=ticker_interval)
+    else:
+        # Get historic ohlcv data (cached on disk).
+        history_eth = self.dp.historic_ohlcv(pair='ETH/BTC',
+                                             ticker_interval='1h')
+```
+
+!!! Warning: Warning about backtesting
+    Be carefull when using dataprovider in backtesting. `historic_ohlcv()` 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).
+
+#### 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
 
 ### Where is the default strategy?
 
 The default buy strategy is located in the file
 [freqtrade/default_strategy.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/strategy/default_strategy.py).
 
+### Specify custom strategy location
+
+If you want to use a strategy from a different folder you can pass `--strategy-path`
+
+```bash
+python3 ./freqtrade/main.py --strategy AwesomeStrategy --strategy-path /some/folder
+```
+
 ### Further strategy ideas
 
 To get additional Ideas for strategies, head over to our [strategy repository](https://github.com/freqtrade/freqtrade-strategies). Feel free to use them as they are - but results will depend on the current market situation, pairs used etc. - therefore please backtest the strategy for your exchange/desired pairs first, evaluate carefully, use at your own risk.
@@ -183,4 +369,4 @@ We also got a *strategy-sharing* channel in our [Slack community](https://join.s
 ## 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/bot-usage.md

@@ -1,32 +1,28 @@
-# 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
-
-- [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]
-                 [--strategy-path PATH] [--dynamic-whitelist [INT]]
-                 [--db-url PATH]
-                 {backtesting,hyperopt} ...
+usage: main.py [-h] [-v] [--version] [-c PATH] [-d PATH] [-s NAME]
+               [--strategy-path PATH] [--customhyperopt NAME]
+               [--dynamic-whitelist [INT]] [--db-url PATH]
+               {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
+    edge                edge module
     hyperopt            hyperopt module
 
 optional arguments:
   -h, --help            show this help message and exit
-  -v, --verbose         be verbose
-  --version             show program's version number and exit
+  -v, --verbose         verbose mode (-vv for more, -vvv to get all messages)
+  --version             show program\'s version number and exit
   -c PATH, --config PATH
                         specify configuration file (default: config.json)
   -d PATH, --datadir PATH
@@ -34,12 +30,15 @@ optional arguments:
   -s NAME, --strategy NAME
                         specify strategy class name (default: DefaultStrategy)
   --strategy-path PATH  specify additional strategy lookup path
+  --customhyperopt NAME
+                        specify hyperopt class name (default:
+                        DefaultHyperOpts)
   --dynamic-whitelist [INT]
                         dynamically generate and update whitelist based on 24h
-                        BaseVolume (default: 20)
+                        BaseVolume (default: 20) DEPRECATED.
   --db-url PATH         Override trades database URL, this is useful if
                         dry_run is enabled or in custom deployments (default:
-                        sqlite:///tradesv3.sqlite)
+                        None)
 ```
 
 ### How to use a different config file?
@@ -51,7 +50,7 @@ default, the bot will load the file `./config.json`
 python3 ./freqtrade/main.py -c path/far/far/away/config.json
 ```
 
-### How to use --strategy?
+### 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
@@ -74,7 +73,7 @@ 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).
 
-### 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!):
@@ -87,7 +86,10 @@ python3 ./freqtrade/main.py --strategy AwesomeStrategy --strategy-path /some/fol
 This is very simple. Copy paste your strategy file into the folder
 `user_data/strategies` or use `--strategy-path`. And voila, the bot is ready to use it.
 
-### How to use --dynamic-whitelist?
+### How to use **--dynamic-whitelist**?
+
+!!! danger "DEPRECATED"
+    Dynamic-whitelist is deprecated. Please move your configurations to the configuration as outlined [here](/configuration/#dynamic-pairlists)
 
 Per default `--dynamic-whitelist` will retrieve the 20 currencies based
 on BaseVolume. This value can be changed when you run the script.
@@ -111,7 +113,7 @@ python3 ./freqtrade/main.py --dynamic-whitelist 30
 negative value (e.g -2), `--dynamic-whitelist` will use the default
 value (20).
 
-### How to use --db-url?
+### 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
@@ -127,15 +129,17 @@ 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]
-                             [--timerange TIMERANGE] [-l] [-r]
-                             [--strategy-list STRATEGY_LIST [STRATEGY_LIST ...]]
-                             [--export EXPORT] [--export-filename PATH]
+usage: main.py backtesting [-h] [-i TICKER_INTERVAL] [--timerange TIMERANGE]
+                           [--eps] [--dmmp] [-l] [-r]
+                           [--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)
+  --timerange TIMERANGE
+                        specify what timerange of data to use.
   --eps, --enable-position-stacking
                         Allow buying the same pair multiple times (position
                         stacking)
@@ -143,8 +147,6 @@ optional arguments:
                         Disable applying `max_open_trades` during backtest
                         (same as setting `max_open_trades` to a very high
                         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
@@ -165,18 +167,18 @@ optional arguments:
                         filename=user_data/backtest_data/backtest_today.json
                         (default: user_data/backtest_data/backtest-
                         result.json)
-
 ```
 
-### How to use --refresh-pairs-cached parameter?
+### How to use **--refresh-pairs-cached** parameter?
 
 The first time your run Backtesting, it will take the pairs you have
 set in your config file and download data from Bittrex.
 
 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.**
+
+!!! Note
+    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`.
@@ -204,6 +206,8 @@ optional arguments:
                         number)
   --timerange TIMERANGE
                         specify what timerange of data to use.
+  --hyperopt PATH       specify hyperopt file (default:
+                        freqtrade/optimize/default_hyperopt.py)
   -e INT, --epochs INT  specify number of epochs (default: 100)
   -s {all,buy,roi,stoploss} [{all,buy,roi,stoploss} ...], --spaces {all,buy,roi,stoploss} [{all,buy,roi,stoploss} ...]
                         Specify which parameters to hyperopt. Space separate
@@ -211,6 +215,33 @@ optional arguments:
 
 ```
 
+## Edge commands
+
+To know your trade expectacny and winrate against historical data, you can use Edge.
+
+```
+usage: main.py edge [-h] [-i TICKER_INTERVAL] [--timerange TIMERANGE] [-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)
+  --timerange TIMERANGE
+                        specify what timerange of data to use.
+  -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 edge with up-to-date data.
+  --stoplosses STOPLOSS_RANGE
+                        defines a range of stoploss against which edge will
+                        assess the strategythe 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
@@ -219,4 +250,4 @@ in [misc.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/misc.
 ## 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).
+[optimize your bot](bot-optimization.md).

docs/configuration.md

@@ -2,12 +2,6 @@
 
 This page explains how to configure your `config.json` file.
 
-## Table of Contents
-
-- [Bot commands](#bot-commands)
-- [Backtesting commands](#backtesting-commands)
-- [Hyperopt commands](#hyperopt-commands)
-
 ## Setup config.json
 
 We recommend to copy and use the `config.json.example` as a template
@@ -15,62 +9,98 @@ for your bot configuration.
 
 The table below will list all configuration parameters.
 
-|  Command | Default | Mandatory | Description |
-|----------|---------|----------|-------------|
-| `max_open_trades` | 3 | Yes | Number of trades open your bot will have.
-| `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.
-| `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 | Have CCXT handle Exchange rate limits. Depending on the exchange, having this to false can lead to temporary bans from the exchange.
-| `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`
-| `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 useage 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.
-| `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.
+Mandatory Parameters are marked as **Required**.
 
-The definition of each config parameters is in [misc.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/misc.py#L205).
+|  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.
+| `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.
+| `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, 30m, 1h, 1d] | The ticker interval to use (1min, 5 min, 30 min, 1 hour or 1 day). Default is 5 minutes. [Strategy Override](#parameters-in-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.
+| `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-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-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-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-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-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-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-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-strategy).
+| `exchange.name` | bittrex | **Required.** Name of the exchange class to use. [List below](#user-content-what-values-for-exchangename).
+| `exchange.key` | key | API key to use for the exchange. Only required when you are in production mode.
+| `exchange.secret` | secret | API secret to use for the exchange. Only required when you are in production mode.
+| `exchange.pair_whitelist` | [] | List of currency to use by the bot. Can be overrided with `--dynamic-whitelist` param.
+| `exchange.pair_blacklist` | [] | List of currency the bot must avoid. Useful when using `--dynamic-whitelist` param.
+| `exchange.ccxt_rate_limit` | True | 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 | 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)
+| `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-strategy).
+| `experimental.sell_profit_only` | false | Waits until you have made a positive profit before taking a sell decision. [Strategy Override](#parameters-in-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-strategy).
+| `pairlist.method` | StaticPairList | Use Static whitelist. [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 folder).
+| `internals.process_throttle_secs` | 5 | **Required.** Set the process throttle. Value in second.
+
+### Parameters in strategy
+
+The following parameters can be set in either configuration or strategy.
+Values in the configuration are always overwriting values set in the strategy.
+
+* `minimal_roi`
+* `ticker_interval`
+* `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 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`.
-In this case a trade amount is calclulated as `currency_balanse / (max_open_trades - current_open_trades)`.
+To allow the bot to trade all the available `stake_currency` in your account set
+
+```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
 
@@ -78,7 +108,7 @@ In this case a trade amount is calclulated as `currency_balanse / (max_open_trad
 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
@@ -111,6 +141,15 @@ Go to the [trailing stoploss Documentation](stoploss.md) for details on trailing
 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.
+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).
+
+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
@@ -125,6 +164,52 @@ 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 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 or in the strategy. Configuration overwrites strategy configurations.
+
+If this is configured, all 4 values (`"buy"`, `"sell"`, `"stoploss"` and `"stoploss_on_exchange"`) need to be present, otherwise the bot warn about it and will fail to start.
+The below is the default which is used if this is not configured in either Strategy or configuration.
+
+```python
+"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 it's value if you are unsure of what you are doing. For more information about how stoploss works please read [the stoploss documentation](stoploss.md).
+
+### 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):**
+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/>
+**FOK (Full Or Kill):**
+It means if the order is not executed immediately AND fully then it is canceled by the exchange.<br/>
+**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/>
+`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/>
+possible values are: `gtc` (default), `fok` or `ioc`.<br/>
+``` python
+"order_time_in_force": {
+    "buy": "gtc",
+    "sell": "gtc"
+},
+```
+
+!!! 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.
+
 ### What values for exchange.name?
 
 Freqtrade is based on [CCXT library](https://github.com/ccxt/ccxt) that supports 115 cryptocurrency
@@ -142,9 +227,15 @@ Feel free to test other exchanges and submit your PR to improve the bot.
 ### What values for fiat_display_currency?
 
 `fiat_display_currency` set the base currency to use for the conversion from coin to fiat in Telegram.
-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".
+The valid values are:<br/>
+```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
 
@@ -153,14 +244,12 @@ behave and how is the performance of your strategy. In Dry-run mode the
 bot does not engage your money. It only runs a live simulation without
 creating trades.
 
-### To switch your bot in Dry-run mode:
-
 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)
@@ -177,23 +266,48 @@ creating trades.
 Once you will be happy with your bot performance, 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.
+
+By default, a Static Pairlist is used (configured as `"pair_whitelist"` under the `"exchange"` section of this configuration).
+
+**Available Pairlist methods:**
+
+* `"StaticPairList"`
+  * uses configuration from `exchange.pair_whitelist` and `exchange.pair_blacklist`
+* `"VolumePairList"`
+  * Formerly available as `--dynamic-whitelist [<number_assets>]`
+  * Selects `number_assets` top pairs based on `sort_key`, which can be one of `askVolume`, `bidVolume` and `quoteVolume`, defaults to `quoteVolume`.
+
+```json
+"pairlist": {
+        "method": "VolumePairList",
+        "config": {
+            "number_assets": 20,
+            "sort_key": "quoteVolume"
+        }
+    },
+```
+
 ## Switch to production mode
 
 In production mode, the bot will engage your money. Be careful 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:
+### 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": {
@@ -204,7 +318,28 @@ you run it in production mode.
 }
 
 ```
-If you have not your Bittrex API key yet, [see our tutorial](https://github.com/freqtrade/freqtrade/blob/develop/docs/pre-requisite.md).
+!!! Note
+    If you have an exchange API key yet, [see our tutorial](/pre-requisite).
+
+### Using proxy with FreqTrade
+
+To use a proxy with freqtrade, add the kwarg `"aiohttp_trust_env"=true` to the `"ccxt_async_kwargs"` dict in the exchange section of the configuration.
+
+An example for this can be found in `config_full.json.example`
+
+``` json
+"ccxt_async_config": {
+    "aiohttp_trust_env": true
+}
+```
+
+Then, export your proxy settings using the variables `"HTTP_PROXY"` and `"HTTPS_PROXY"` set to the appropriate values
+
+``` bash
+export HTTP_PROXY="http://addr:port"
+export HTTPS_PROXY="http://addr:port"
+freqtrade
+```
 
 
 ### Embedding Strategies
@@ -213,7 +348,7 @@ FreqTrade provides you with with an easy way to embed the strategy into your con
 This is done by utilizing BASE64 encoding and providing this string at the strategy configuration field,
 in your chosen config file.
 
-##### Encoding a string as BASE64
+#### Encoding a string as BASE64
 
 This is a quick example, how to generate the BASE64 string in python
 
@@ -235,4 +370,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/developer.md

@@ -0,0 +1,117 @@
+# Development Help
+
+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.
+
+## Documentation
+
+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, use 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 -r requirements-dev.txt`.
+
+This will install all required tools for development, including `pytest`, `flake8`, `mypy`, and `coveralls`.
+
+## Modules
+
+### Dynamic Pairlist
+
+You have a great idea for a new pair selection algorithm you would like to try out? Great.
+Hopefully you also want to contribute this back upstream.
+
+Whatever your motivations are - This should get you off the ground in trying to develop a new Pairlist provider.
+
+First of all, have a look at the [VolumePairList](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/pairlist/VolumePairList.py) provider, and best copy this file with a name of your new Pairlist Provider.
+
+This is a simple provider, which however serves as a good example on how to start developing.
+
+Next, modify the classname of the provider (ideally align this with the Filename).
+
+The base-class provides the an instance of the bot (`self._freqtrade`), as well as the configuration (`self._config`), and initiates both `_blacklist` and `_whitelist`.
+
+```python
+        self._freqtrade = freqtrade
+        self._config = config
+        self._whitelist = self._config['exchange']['pair_whitelist']
+        self._blacklist = self._config['exchange'].get('pair_blacklist', [])
+```
+
+
+Now, let's step through the methods which require actions:
+
+#### configuration
+
+Configuration for PairListProvider is done in the bot configuration file in the element `"pairlist"`.
+This Pairlist-object may contain a `"config"` dict with additional configurations for the configured pairlist.
+By convention, `"number_assets"` is used to specify the maximum number of pairs to keep in the whitelist. Please follow this to ensure a consistent user experience.
+
+Additional elements can be configured as needed. `VolumePairList` uses `"sort_key"` to specify the sorting value - however feel free to specify whatever is necessary for your great algorithm to be successfull and dynamic.
+
+#### short_desc
+
+Returns a description used for Telegram messages.
+This should contain the name of the Provider, as well as a short description containing the number of assets. Please follow the format `"PairlistName - top/bottom X pairs"`.
+
+#### refresh_pairlist
+
+Override this method and run all calculations needed in this method.
+This is called with each iteration of the bot - so consider implementing caching for compute/network heavy calculations.
+
+Assign the resulting whiteslist to `self._whitelist` and `self._blacklist` respectively. These will then be used to run the bot in this iteration. Pairs with open trades will be added to the whitelist to have the sell-methods run correctly.
+
+Please also run `self._validate_whitelist(pairs)` and to check and remove pairs with inactive markets. This function is available in the Parent class (`StaticPairList`) and should ideally not be overwritten.
+
+##### sample
+
+``` python
+    def refresh_pairlist(self) -> None:
+        # Generate dynamic whitelist
+        pairs = self._gen_pair_whitelist(self._config['stake_currency'], self._sort_key)
+        # Validate whitelist to only have active market pairs
+        self._whitelist = self._validate_whitelist(pairs)[:self._number_pairs]
+```
+
+#### _gen_pair_whitelist
+
+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.
+
+## 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 desired version (for example `0.18.0`)
+* Commit this part
+* push that branch to the remote and create a PR
+
+### create changelog from git commits
+
+``` bash
+# Needs to be done before merging / pulling that branch.
+git log --oneline --no-decorate --no-merges master..develop
+```
+
+### Create github release / tag
+
+* 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 to next valid version and postfix that with `-dev` (`0.18.0 -> 0.18.1-dev`)

docs/edge.md

@@ -0,0 +1,212 @@
+#  Edge positioning
+
+This page explains how to use Edge Positioning module in your bot in order to enter into a trade only if the trade has a reasonable win rate and risk reward ratio, and consequently adjust your position size and stoploss.
+
+!!! Warning
+    Edge positioning is not compatible with dynamic whitelist. it overrides dynamic whitelist.
+
+!!! Note
+    Edge won't consider anything else than buy/sell/stoploss signals. So trailing stoploss, ROI, and everything else will be ignored in its calculation.
+
+## 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/>
+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 ...
+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/>
+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).
+
+
+`W = (Number of winning trades) / (Total number of trades)`
+
+### 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:
+
+`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 loss = (Sum of losses) / (Number of losing trades)`
+
+`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:
+
+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`
+
+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.
+
+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.
+
+**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:
+
+| 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      |
+
+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.
+
+### Position size
+Edge 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**
+
+**Stoploss** is calculated as described above against historical data.
+
+Your position size then will be:
+
+**position size** = **allowed capital at risk** / **stoploss**
+
+Example:<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**. <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/>
+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/>
+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/>
+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**.
+
+## Configurations
+Edge has following configurations:
+
+#### enabled
+If true, then Edge will run periodically.<br/>
+(default to false)
+
+#### process_throttle_secs
+How often should Edge run in seconds? <br/>
+(default 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/>
+(default to 7)
+
+#### capital_available_percentage
+This is the percentage of the total capital on exchange in stake currency. <br/>
+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)
+
+#### allowed_risk
+Percentage of allowed risk per trade.<br/>
+(default to 0.01 [1%])
+
+#### stoploss_range_min
+Minimum stoploss.<br/>
+(default to -0.01)
+
+#### stoploss_range_max
+Maximum stoploss.<br/>
+(default 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/>
+if you set this parameter to -0.001, you then slow down the Edge calculation by a factor of 10. <br/>
+(default 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/>
+(default 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/>
+(default 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)
+
+#### 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/>
+(default to 1 day, 1440 = 60 * 24)
+
+#### 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)
+
+
+## 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
+```
+
+An example of its output:
+
+| pair      |   stoploss |   win rate |   risk reward ratio |   required risk reward |   expectancy |   total number of trades |   average duration (min) |
+|:----------|-----------:|-----------:|--------------------:|-----------------------:|-------------:|-------------------------:|-------------------------:|
+| AGI/BTC   |      -0.02 |       0.64 |                5.86 |                   0.56 |         3.41 |                       14 |                       54 |
+| NXS/BTC   |      -0.03 |       0.64 |                2.99 |                   0.57 |         1.54 |                       11 |                       26 |
+| LEND/BTC  |      -0.02 |       0.82 |                2.05 |                   0.22 |         1.50 |                       11 |                       36 |
+| VIA/BTC   |      -0.01 |       0.55 |                3.01 |                   0.83 |         1.19 |                       11 |                       48 |
+| MTH/BTC   |      -0.09 |       0.56 |                2.82 |                   0.80 |         1.12 |                       18 |                       52 |
+| ARDR/BTC  |      -0.04 |       0.42 |                3.14 |                   1.40 |         0.73 |                       12 |                       42 |
+| BCPT/BTC  |      -0.01 |       0.71 |                1.34 |                   0.40 |         0.67 |                       14 |                       30 |
+| WINGS/BTC |      -0.02 |       0.56 |                1.97 |                   0.80 |         0.65 |                       27 |                       42 |
+| VIBE/BTC  |      -0.02 |       0.83 |                0.91 |                   0.20 |         0.59 |                       12 |                       35 |
+| MCO/BTC   |      -0.02 |       0.79 |                0.97 |                   0.27 |         0.55 |                       14 |                       31 |
+| GNT/BTC   |      -0.02 |       0.50 |                2.06 |                   1.00 |         0.53 |                       18 |                       24 |
+| HOT/BTC   |      -0.01 |       0.17 |                7.72 |                   4.81 |         0.50 |                      209 |                        7 |
+| SNM/BTC   |      -0.03 |       0.71 |                1.06 |                   0.42 |         0.45 |                       17 |                       38 |
+| APPC/BTC  |      -0.02 |       0.44 |                2.28 |                   1.27 |         0.44 |                       25 |                       43 |
+| NEBL/BTC  |      -0.03 |       0.63 |                1.29 |                   0.58 |         0.44 |                       19 |                       59 |
+
+### Update cached pairs with the latest data
+```bash
+python3 ./freqtrade/main.py edge --refresh-pairs-cached
+```
+
+### Precising stoploss range
+```bash
+python3 ./freqtrade/main.py edge --stoplosses=-0.01,-0.1,-0.001 #min,max,step
+```
+
+### Advanced use of timerange
+```bash
+python3 ./freqtrade/main.py 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.
+
+The full timerange specification:
+
+* Use last 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 till 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 between POSIX timestamps 1527595200 1527618600: --timerange=1527595200-1527618600

docs/faq.md

@@ -27,7 +27,7 @@ like pauses. You can stop your bot, adjust settings and start it again.
 #### 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
 perform anymore BUYS?
@@ -68,4 +68,3 @@ 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.
 Did you run 100 000 evals? Congrats, you've done roughly 1 / 100 000 th
 of the search space.
-

docs/hyperopt.md

@@ -1,35 +1,55 @@
 # Hyperopt
+
 This page explains how to tune your strategy by finding the optimal
 parameters, a process called hyperparameter optimization. The bot uses several
 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)
-
-## 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 hyperopts result](#understand-the-backtesting-result)
+!!! Bug
+    Hyperopt will crash when used with only 1 CPU Core as found out in [Issue #1133](https://github.com/freqtrade/freqtrade/issues/1133)
 
 ## Prepare Hyperopting
-We recommend you start by taking a look at `hyperopt.py` file located in [freqtrade/optimize](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/optimize/hyperopt.py)
 
-### Configure your Guards and Triggers
-There are two places you need to change to add a new buy strategy for testing:
-- Inside [populate_buy_trend()](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/optimize/hyperopt.py#L278-L294).
-- Inside [hyperopt_space()](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/optimize/hyperopt.py#L218-L229) 
-and the associated methods `indicator_space`, `roi_space`, `stoploss_space`.
+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/freqtrade/freqtrade/blob/develop/user_data/hyperopts/test_hyperopt.py)
 
-There you have two different type of indicators: 1. `guards` and 2. `triggers`.
-1. Guards are conditions like "never buy if ADX < 10", or "never buy if 
-current price is over EMA10".
-2. Triggers are ones that actually trigger buy in specific moment, like 
-"buy when EMA5 crosses over EMA10" or "buy when close price touches lower 
-bollinger band".
+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
+* fill `roi_space` - for ROI optimization
+* fill `generate_roi_table` - for ROI optimization (if you need more than 3 entries)
+* fill `stoploss_space` - stoploss optimization
+* 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
+
+### 1. Install a Custom Hyperopt File
+
+Put your hyperopt file into the folder`user_data/hyperopts`.
+
+Let assume you want a hyperopt file `awesome_hyperopt.py`:  
+Copy the file `user_data/hyperopts/sample_hyperopt.py` into `user_data/hyperopts/awesome_hyperopt.py`
+
+### 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:
+
+- 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 current price is over EMA10.
+2. Triggers are ones that actually trigger buy in specific moment, like "buy when EMA5 crosses over EMA10" or "buy when close price touches lower bollinger band".
 
 Hyperoptimization will, for each eval round, pick one trigger and possibly
 multiple guards. The constructed strategy will be something like
@@ -40,6 +60,17 @@ 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-`.
+
 ## Solving a Mystery
 
 Let's say you are curious: should you use MACD crossings or lower Bollinger
@@ -50,7 +81,7 @@ mystery.
 
 We will start by defining a search space:
 
-```
+```python
     def indicator_space() -> List[Dimension]:
         """
         Define your Hyperopt space for searching strategy parameters
@@ -73,7 +104,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
@@ -83,12 +114,13 @@ So let's write the buy strategy using these values:
                 conditions.append(dataframe['rsi'] < params['rsi-value'])
 
             # TRIGGERS
-            if params['trigger'] == 'bb_lower':
-                conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
-            if params['trigger'] == 'macd_cross_signal':
-                conditions.append(qtpylib.crossed_above(
-                    dataframe['macd'], dataframe['macdsignal']
-                ))
+            if 'trigger' in params:
+                if params['trigger'] == 'bb_lower':
+                    conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
+                if params['trigger'] == 'macd_cross_signal':
+                    conditions.append(qtpylib.crossed_above(
+                        dataframe['macd'], dataframe['macdsignal']
+                    ))
 
             dataframe.loc[
                 reduce(lambda x, y: x & y, conditions),
@@ -113,33 +145,44 @@ When you want to test an indicator that isn't used by the bot currently, remembe
 add it to the `populate_indicators()` method in `hyperopt.py`.
 
 ## Execute Hyperopt
-Once you have updated your hyperopt configuration you can run it. 
-Because hyperopt tries a lot of combination to find the best parameters
-it will take time you will have the result (more than 30 mins).
 
-We strongly recommend to use `screen` to prevent any connection loss.
+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).
+
+We strongly recommend to use `screen` or `tmux` to prevent any connection loss.
+
 ```bash
-python3 ./freqtrade/main.py -c config.json hyperopt -e 5000
+python3 ./freqtrade/main.py --hyperopt <hyperoptname> -c config.json hyperopt -e 5000 --spaces all
 ```
 
+Use  `<hyperoptname>` as the name of 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.
+
+!!! Warning
+When switching parameters or changing configuration options, the file `user_data/hyperopt_results.pickle` should be removed. It's used to be able to continue interrupted calculations, but does not detect changes to settings or the hyperopt file.
+
 ### Execute Hyperopt with Different Ticker-Data Source
+
 If you would like to hyperopt parameters using an alternate ticker data that
 you have on-disk, use the `--datadir PATH` option. Default hyperopt will
 use data from directory `user_data/data`.
 
 ### Running Hyperopt with Smaller Testset
-Use the `--timeperiod` argument to change how much of the testset
+
+Use the `--timerange` argument to change how much of the testset
 you want to use. The last N ticks/timeframes will be used.
 Example:
 
 ```bash
-python3 ./freqtrade/main.py hyperopt --timeperiod -200
+python3 ./freqtrade/main.py hyperopt --timerange -200
 ```
 
 ### Running Hyperopt with Smaller Search Space
+
 Use the `--spaces` argument to limit the search space used by hyperopt.
 Letting Hyperopt optimize everything is a huuuuge search space. Often it
 might make more sense to start by just searching for initial buy algorithm.
@@ -150,11 +193,13 @@ Legal values are:
 
 - `all`: optimize everything
 - `buy`: just search for a new buy strategy
+- `sell`: just search for a new sell strategy
 - `roi`: just optimize the minimal profit table for your strategy
 - `stoploss`: search for the best stoploss value
 - space-separated list of any of the above values for example `--spaces roi stoploss`
 
-## Understand the Hyperopts Result 
+## Understand the Hyperopt Result
+
 Once Hyperopt is completed you can use the result to create a new strategy.
 Given the following result from hyperopt:
 
@@ -162,10 +207,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:
-{'adx-value': 44, 'rsi-value': 29, 'adx-enabled': False, 'rsi-enabled': True, 'trigger': 'bb_lower'}
+{    'adx-value': 44,
+     'rsi-value': 29,
+     'adx-enabled': False,
+     'rsi-enabled': True,
+     'trigger': 'bb_lower'}
 ```
 
 You should understand this result like:
+
 - The buy trigger that worked best was `bb_lower`.
 - You should not use ADX because `adx-enabled: False`)
 - You should **consider** using the RSI indicator (`rsi-enabled: True` and the best value is `29.0` (`rsi-value: 29.0`)
@@ -173,15 +223,16 @@ You should understand this result like:
 You have to look inside your strategy file into `buy_strategy_generator()`
 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:
+So for example you had `rsi-value: 29.0` so we would look at `rsi`-block, that translates to the following code block:
+
 ```
 (dataframe['rsi'] < 29.0)
 ```
 
 Translating your whole hyperopt result as the new buy-signal
 would then look like:
-```
+
+```python
 def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
     dataframe.loc[
         (
@@ -192,6 +243,55 @@ def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
     return dataframe
 ```
 
+### Understand Hyperopt ROI results
+
+If you are optimizing ROI, you're 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:
+{   '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
+}
+ROI table:
+{   0: 0.10674752302642071,
+    21: 0.09158372701087236,
+    78: 0.03634636907306948,
+    118: 0}
+```
+
+This would translate to the following ROI table:
+
+``` python
+ minimal_roi = {
+        "118": 0,
+        "78": 0.0363463,
+        "21": 0.0915,
+        "0": 0.106
+    }
+```
+
+### Validate backtest result
+
+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).
+
+!!! 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.
+
 ## 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,36 +1,67 @@
-# 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
-this documentation if you see it became outdated by sending us a 
-Pull-request. Do not hesitate to reach us on 
-[Slack](https://join.slack.com/t/highfrequencybot/shared_invite/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE)
- 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" data-icon="octicon-star" data-size="large" aria-label="Star freqtrade/freqtrade on GitHub">Star</a>
+<!-- Place this tag where you want the button to render. -->
+<a class="github-button" href="https://github.com/freqtrade/freqtrade/fork" data-icon="octicon-repo-forked" data-size="large" aria-label="Fork freqtrade/freqtrade on GitHub">Fork</a>
+<!-- Place this tag where you want the button to render. -->
+<a class="github-button" href="https://github.com/freqtrade/freqtrade/archive/master.zip" data-icon="octicon-cloud-download" data-size="large" aria-label="Download freqtrade/freqtrade on GitHub">Download</a>
+<!-- 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)
-	- [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)
-- [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)
-    - [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)
-    - [Install on Windows](https://github.com/freqtrade/freqtrade/blob/develop/docs/installation.md#windows)
-- [Bot Configuration](https://github.com/freqtrade/freqtrade/blob/develop/docs/configuration.md)
-- [Bot usage (Start your bot)](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md)
-    - [Bot commands](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md#bot-commands)
-    - [Backtesting commands](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md#backtesting-commands)
-    - [Hyperopt commands](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md#hyperopt-commands)
-- [Bot Optimization](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-optimization.md)
-	- [Change your strategy](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-optimization.md#change-your-strategy)
-    - [Add more Indicator](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-optimization.md#add-more-indicator)
-    - [Test your strategy with Backtesting](https://github.com/freqtrade/freqtrade/blob/develop/docs/backtesting.md)
-    - [Find optimal parameters with Hyperopt](https://github.com/freqtrade/freqtrade/blob/develop/docs/hyperopt.md)
-- [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)
-- [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)
-	- [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)
-    - [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))
+    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.
+
+    We strongly recommend you to have coding and Python knowledge. Do not hesitate to read the source code and understand the mechanism of this bot.
+
+
+## Features
+ - Based on Python 3.6+: For botting on any operating system - Windows, macOS and Linux
+ - Persistence: Persistence is achieved through sqlite
+ - Dry-run: Run the bot without playing money.
+ - Backtesting: Run a simulation of your buy/sell strategy.
+ - Strategy Optimization by machine learning: Use machine learning to optimize your buy/sell strategy parameters with real exchange data.
+ - 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
+ - Whitelist crypto-currencies: Select which crypto-currency you want to trade or use dynamic whitelists.
+ - Blacklist crypto-currencies: Select which crypto-currency you want to avoid.
+ - Manageable via Telegram: Manage the bot with Telegram
+ - Display profit/loss in fiat: Display your profit/loss in 33 fiat.
+ - Daily summary of profit/loss: Provide a daily summary of your profit/loss.
+ - Performance status report: Provide a performance status of your current trades.
+
+
+## Requirements
+### Uptodate clock
+The clock must be accurate, syncronized to a NTP server very frequently to avoid problems with communication to the exchanges.
+
+### Hardware requirements
+To run this bot we recommend you a cloud instance with a minimum of:
+
+- 2GB RAM
+- 1GB disk space
+- 2vCPU
+
+### Software requirements
+- Python 3.6.x
+- pip
+- 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/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE) to join Slack channel.
+
+## Ready to try?
+Begin by reading our installation guide [here](installation).

docs/installation.md

@@ -1,25 +1,69 @@
 # Installation
-
 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
+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 exchange account](#setup-your-exchange-account)
+- [Backtesting commands](#setup-your-telegram-bot)
 
-* [Table of Contents](#table-of-contents)
-* [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)
+### Setup your exchange account
+*To be completed, please feel free to complete this section.*
 
-<!-- /TOC -->
+### 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.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.
+```
+**1.4. Choose the name id of your bot (e.x "`My_own_freqtrade_bot`")**
+
+**1.5. Father bot will return you the token (API key)**<br/>
+Copy it and keep it you will use it for the config parameter `token`.
+*BotFather response:*
+```hl_lines="4"
+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`.**
+<hr/>
+## Quick start
+Freqtrade provides a Linux/MacOS script to install all dependencies and help you to configure the bot.
+
+```bash
+git clone git@github.com:freqtrade/freqtrade.git
+cd freqtrade
+git checkout develop
+./setup.sh --install
+```
+!!! Note
+    Windows installation is explained [here](#windows).
+<hr/>
 ## 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.
@@ -33,7 +77,7 @@ usage:
 	-c,--config     Easy config generator (Will override your existing file).
 ```
 
-### --install
+** --install **
 
 This script will install everything you need to run the bot:
 
@@ -43,15 +87,15 @@ This script will install everything you need to run the bot:
 
 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`.
 
@@ -69,33 +113,39 @@ Once you have Docker installed, simply create the config file (e.g. `config.json
 
 ### 1. Prepare the Bot
 
-#### 1.1. Clone the git repository
+**1.1. Clone the git repository**
 
+Linux/Mac/Windows with WSL
 ```bash
 git clone https://github.com/freqtrade/freqtrade.git
 ```
 
-#### 1.2. (Optional) Checkout the develop branch
+Windows with docker
+```bash
+git clone --config core.autocrlf=input https://github.com/freqtrade/freqtrade.git
+```
+
+**1.2. (Optional) Checkout the develop branch**
 
 ```bash
 git checkout develop
 ```
 
-#### 1.3. Go into the new directory
+**1.3. Go into the new directory**
 
 ```bash
 cd freqtrade
 ```
 
-#### 1.4. Copy `config.json.example` to `config.json`
+**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.
+> To edit the config please refer to the [Bot Configuration](configuration.md) page.
 
-#### 1.5. Create your database file *(optional - the bot will create it if it is missing)*
+**1.5. Create your database file *(optional - the bot will create it if it is missing)**
 
 Production
 
@@ -109,13 +159,37 @@ Dry-Run
 touch tradesv3.dryrun.sqlite
 ```
 
-### 2. Build the Docker image
+### 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
@@ -140,7 +214,7 @@ There is known issue in OSX Docker versions after 17.09.1, whereby /etc/localtim
 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)
+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.
 
@@ -148,7 +222,7 @@ In this example, the database will be created inside the docker instance and wil
 
 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
+**5.1. Move your config file and database**
 
 ```bash
 mkdir ~/.freqtrade
@@ -156,7 +230,7 @@ mv config.json ~/.freqtrade
 mv tradesv3.sqlite ~/.freqtrade
 ```
 
-#### 5.2. Run the docker image
+**5.2. Run the docker image**
 
 ```bash
 docker run -d \
@@ -167,8 +241,9 @@ docker run -d \
   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`
+!!! 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
 
@@ -184,14 +259,15 @@ 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.
+!!! 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
+```bash
 docker run -d \
   --name freqtrade \
   -v /etc/localtime:/etc/localtime:ro \
@@ -201,16 +277,17 @@ docker run -d \
   freqtrade --strategy AwsomelyProfitableStrategy backtesting
 ```
 
-Head over to the [Backtesting Documentation](https://github.com/freqtrade/freqtrade/blob/develop/docs/backtesting.md) for more details.
+Head over to the [Backtesting Documentation](backtesting.md) for more details.
 
-*Note*: Additional parameters can be appended after the image name (`freqtrade` in the above example).
+!!! 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
 
@@ -236,28 +313,33 @@ sudo apt-get install python3.6 python3.6-venv python3.6-dev build-essential auto
 
 Before installing FreqTrade on a Raspberry Pi running the official Raspbian Image, make sure you have at least Python 3.6 installed. The default image only provides Python 3.5. Probably the easiest way to get a recent version of python is [miniconda](https://repo.continuum.io/miniconda/).
 
-The following assumes that miniconda3 is installed and available in your environment, and is installed.
-It's recommended to use (mini)conda for this as installation/compilation of `scipy` and `pandas` takes a long time.
+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).
 
 ``` bash
 conda config --add channels rpi
 conda install python=3.6
 conda create -n freqtrade python=3.6
-conda install scipy pandas
+conda activate freqtrade
+conda install scipy pandas numpy
 
-pip install -r requirements.txt
-pip install -e .
+sudo apt install libffi-dev
+python3 -m pip install -r requirements.txt
+python3 -m pip install -e .
 ```
 
 ### MacOS
 
-#### Install Python 3.6, git, wget and ta-lib
+#### Install Python 3.6, git and wget
 
 ```bash
 brew install python3 git wget
 ```
 
-### common
+### Common
 
 #### 1. Install TA-Lib
 
@@ -268,18 +350,20 @@ wget http://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz
 tar xvzf 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 --prefix=/usr
+./configure --prefix=/usr/local
 make
-make install
+sudo make install
 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
@@ -308,7 +392,7 @@ 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
 
@@ -367,7 +451,7 @@ copy paste `config.json` to ``\path\freqtrade-develop\freqtrade`
 
 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
@@ -397,4 +481,4 @@ The easiest way is to download install Microsoft Visual Studio Community [here](
 ---
 
 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,10 +1,6 @@
 # Plotting
 This page explains how to plot prices, indicator, profits.
 
-## Table of Contents
-- [Plot price and indicators](#plot-price-and-indicators)
-- [Plot profit](#plot-profit)
-
 ## Installation
 
 Plotting scripts use Plotly library. Install/upgrade it with:
@@ -19,7 +15,7 @@ At least version 2.3.0 is required.
 Usage for the price plotter:
 
 ```
-script/plot_dataframe.py [-h] [-p pair] [--live]
+script/plot_dataframe.py [-h] [-p pairs] [--live]
 ```
 
 Example
@@ -27,11 +23,16 @@ Example
 python scripts/plot_dataframe.py -p BTC/ETH
 ```
 
-The `-p` pair argument, can be used to specify what
-pair you would like to plot.
+The `-p` pairs argument, can be used to specify
+pairs you would like to plot.
 
 **Advanced use**
 
+To plot multiple pairs, separate them with a comma:
+```
+python scripts/plot_dataframe.py -p BTC/ETH,XRP/ETH
+```
+
 To plot the current live price use the `--live` flag:
 ```
 python scripts/plot_dataframe.py -p BTC/ETH --live

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==3.1.0

docs/stoploss.md

@@ -2,9 +2,20 @@
 
 At this stage the bot contains the following stoploss support modes:
 
-1. static stop loss, defined in either the strategy or configuration
-2. trailing stop loss, defined in the configuration
-3. trailing stop loss, custom positive loss, defined in configuration
+1. static stop loss, defined in either the strategy or configuration.
+2. trailing stop loss, defined in the 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
 
@@ -48,4 +59,4 @@ Both values can be configured in the main configuration file and requires `"trai
 
 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 higher than your minimal ROI, otherwise minimal ROI will apply first and sell your trade.
+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.

docs/telegram-usage.md

@@ -2,9 +2,9 @@
 
 This page explains how to command your bot with Telegram.
 
-## Pre-requisite
+## Prerequisite
 To control your bot with Telegram, you need first to
-[set up a Telegram bot](https://github.com/freqtrade/freqtrade/blob/develop/docs/pre-requisite.md) 
+[set up a Telegram bot](installation.md)
 and add your Telegram API keys into your config file.
 
 ## Telegram commands
@@ -23,6 +23,7 @@ official commands. You can ask at any moment for help with `/help`.
 | `/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
@@ -30,16 +31,20 @@ official commands. You can ask at any moment for help with `/help`.
 | `/version` | | Show version
 
 ## Telegram commands in action
+
 Below, example of Telegram message you will receive for each command.
 
 ### /start
+
 > **Status:** `running`
 
 ### /stop
+
 > `Stopping trader ...`
 > **Status:** `stopped`
 
 ## /status
+
 For each open trade, the bot will send you the following message.
 
 > **Trade ID:** `123`
@@ -54,6 +59,7 @@ For each open trade, the bot will send you the following message.
 > **Open Order:** `None`
 
 ## /status table
+
 Return the status of all open trades in a table format.
 ```
    ID  Pair      Since    Profit
@@ -63,6 +69,7 @@ Return the status of all open trades in a table format.
 ```
 
 ## /count
+
 Return the number of trades used and available.
 ```
 current    max
@@ -71,6 +78,7 @@ current    max
 ```
 
 ## /profit
+
 Return a summary of your profit/loss and performance.
 
 > **ROI:** Close trades
@@ -90,7 +98,14 @@ Return a summary of your profit/loss and performance.
 
 > **BITTREX:** Selling BTC/LTC with limit `0.01650000 (profit: ~-4.07%, -0.00008168)`
 
+## /forcebuy <pair>
+
+> **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
+
 Return the performance of each crypto-currency the bot has sold.
 > Performance:
 > 1. `RCN/BTC 57.77%`
@@ -101,6 +116,7 @@ Return the performance of each crypto-currency the bot has sold.
 > ...
 
 ## /balance
+
 Return the balance of all crypto-currency your have on the exchange.
 
 > **Currency:** BTC
@@ -114,6 +130,7 @@ Return the balance of all crypto-currency your have on the exchange.
 > **Pending:** 0.0
 
 ## /daily <n>
+
 Per default `/daily` will return the 7 last days.
 The example below if for `/daily 3`:
 
@@ -127,11 +144,5 @@ Day         Profit BTC      Profit USD
 ```
 
 ## /version
-> **Version:** `0.14.3` 
 
-### using proxy with telegram
-```
-$ export HTTP_PROXY="http://addr:port"
-$ export HTTPS_PROXY="http://addr:port"
-$ freqtrade
-```
+> **Version:** `0.14.3`

docs/webhook-config.md

@@ -66,6 +66,7 @@ Possible parameters are:
 * profit_fiat
 * stake_currency
 * fiat_currency
+* sell_reason
 
 ### Webhookstatus
 

freqtrade/__init__.py

@@ -1,5 +1,5 @@
 """ FreqTrade bot """
-__version__ = '0.17.1'
+__version__ = '0.18.1'
 
 
 class DependencyException(BaseException):

freqtrade/arguments.py

@@ -104,10 +104,19 @@ class Arguments(object):
             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)',
+                 ' based on 24h BaseVolume (default: %(const)s)'
+                 ' DEPRECATED.',
             dest='dynamic_whitelist',
             const=constants.DYNAMIC_WHITELIST,
             type=int,
@@ -128,6 +137,22 @@ class Arguments(object):
         """
         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',
@@ -171,6 +196,27 @@ class Arguments(object):
             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:
         """
@@ -184,22 +230,6 @@ class Arguments(object):
             dest='ticker_interval',
             type=str,
         )
-        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(
             '--timerange',
@@ -214,6 +244,22 @@ class Arguments(object):
         """
         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)',
@@ -226,7 +272,7 @@ class Arguments(object):
             '-s', '--spaces',
             help='Specify which parameters to hyperopt. Space separate list. \
                   Default: %(default)s',
-            choices=['all', 'buy', 'roi', 'stoploss'],
+            choices=['all', 'buy', 'sell', 'roi', 'stoploss'],
             default='all',
             nargs='+',
             dest='spaces',
@@ -237,7 +283,7 @@ class Arguments(object):
         Builds and attaches all subcommands
         :return: None
         """
-        from freqtrade.optimize import backtesting, hyperopt
+        from freqtrade.optimize import backtesting, hyperopt, edge_cli
 
         subparsers = self.parser.add_subparsers(dest='subparser')
 
@@ -247,6 +293,12 @@ class Arguments(object):
         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)
@@ -300,9 +352,9 @@ class Arguments(object):
         Parses given arguments for scripts.
         """
         self.parser.add_argument(
-            '-p', '--pair',
+            '-p', '--pairs',
             help='Show profits for only this pairs. Pairs are comma-separated.',
-            dest='pair',
+            dest='pairs',
             default=None
         )
 
@@ -326,6 +378,15 @@ class Arguments(object):
             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',
@@ -337,7 +398,7 @@ class Arguments(object):
 
         self.parser.add_argument(
             '--exchange',
-            help='Exchange name (default: %(default)s)',
+            help='Exchange name (default: %(default)s). Only valid if no config is provided',
             dest='exchange',
             type=str,
             default='bittrex'

freqtrade/configuration.py

@@ -12,6 +12,7 @@ from jsonschema import Draft4Validator, validate
 from jsonschema.exceptions import ValidationError, best_match
 
 from freqtrade import OperationalException, constants
+from freqtrade.state import RunMode
 logger = logging.getLogger(__name__)
 
 
@@ -33,9 +34,11 @@ 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:
+
+    def __init__(self, args: Namespace, runmode: RunMode = None) -> None:
         self.args = args
         self.config: Optional[Dict[str, Any]] = None
+        self.runmode = runmode
 
     def load_config(self) -> Dict[str, Any]:
         """
@@ -52,15 +55,28 @@ class Configuration(object):
         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)
 
+        # Set runmode
+        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
+
+        config.update({'runmode': self.runmode})
+
         return config
 
     def _load_config_file(self, path: str) -> Dict[str, Any]:
@@ -103,19 +119,20 @@ class Configuration(object):
 
         # Add dynamic_whitelist if found
         if 'dynamic_whitelist' in self.args and self.args.dynamic_whitelist:
-            config.update({'dynamic_whitelist': self.args.dynamic_whitelist})
-            logger.info(
-                'Parameter --dynamic-whitelist detected. '
-                'Using dynamically generated 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')
@@ -127,6 +144,13 @@ class Configuration(object):
                 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
@@ -134,13 +158,16 @@ class Configuration(object):
 
         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 _create_datadir(self, config: Dict[str, Any], datadir: Optional[str] = None) -> str:
+        if not datadir:
+            # set datadir
+            exchange_name = config.get('exchange', {}).get('name').lower()
+            datadir = os.path.join('user_data', 'data', exchange_name)
+
+        if not os.path.isdir(datadir):
+            os.makedirs(datadir)
+            logger.info(f'Created data directory: {datadir}')
+        return datadir
 
     def _load_backtesting_config(self, config: Dict[str, Any]) -> Dict[str, Any]:
         """
@@ -180,9 +207,9 @@ class Configuration(object):
 
         # 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})
+            config.update({'datadir': self._create_datadir(config, self.args.datadir)})
         else:
-            config.update({'datadir': self._create_default_datadir(config)})
+            config.update({'datadir': self._create_datadir(config, None)})
         logger.info('Using data folder: %s ...', config.get('datadir'))
 
         # If -r/--refresh-pairs-cached is used we add it to the configuration
@@ -210,6 +237,32 @@ class Configuration(object):
 
         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
@@ -235,7 +288,7 @@ class Configuration(object):
         :return: Returns the config if valid, otherwise throw an exception
         """
         try:
-            validate(conf, constants.CONF_SCHEMA)
+            validate(conf, constants.CONF_SCHEMA, Draft4Validator)
             return conf
         except ValidationError as exception:
             logger.critical(
@@ -271,6 +324,11 @@ class Configuration(object):
             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/constants.py

@@ -9,10 +9,16 @@ TICKER_INTERVAL = 5  # min
 HYPEROPT_EPOCH = 100  # epochs
 RETRY_TIMEOUT = 30  # sec
 DEFAULT_STRATEGY = 'DefaultStrategy'
+DEFAULT_HYPEROPT = 'DefaultHyperOpts'
 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']
 
 TICKER_INTERVAL_MINUTES = {
     '1m': 1,
@@ -37,13 +43,13 @@ SUPPORTED_FIAT = [
     "KRW", "MXN", "MYR", "NOK", "NZD", "PHP", "PKR", "PLN",
     "RUB", "SEK", "SGD", "THB", "TRY", "TWD", "ZAR", "USD",
     "BTC", "XBT", "ETH", "XRP", "LTC", "BCH", "USDT"
-    ]
+]
 
 # Required json-schema for user specified config
 CONF_SCHEMA = {
     'type': 'object',
     'properties': {
-        'max_open_trades': {'type': 'integer', 'minimum': 0},
+        'max_open_trades': {'type': 'integer', 'minimum': -1},
         'ticker_interval': {'type': 'string', 'enum': list(TICKER_INTERVAL_MINUTES.keys())},
         'stake_currency': {'type': 'string', 'enum': ['BTC', 'XBT', 'ETH', 'USDT', 'EUR', 'USD']},
         'stake_amount': {
@@ -101,7 +107,27 @@ CONF_SCHEMA = {
                 'order_book_max': {'type': 'number', 'minimum': 1, 'maximum': 50}
             }
         },
+        'order_types': {
+            'type': 'object',
+            'properties': {
+                '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_interval': {'type': 'number'}
+            },
+            'required': ['buy', 'sell', 'stoploss', 'stoploss_on_exchange']
+        },
+        'order_time_in_force': {
+            'type': 'object',
+            'properties': {
+                'buy': {'type': 'string', 'enum': ORDERTIF_POSSIBILITIES},
+                'sell': {'type': 'string', 'enum': ORDERTIF_POSSIBILITIES}
+            },
+            'required': ['buy', 'sell']
+        },
         'exchange': {'$ref': '#/definitions/exchange'},
+        'edge': {'$ref': '#/definitions/edge'},
         'experimental': {
             'type': 'object',
             'properties': {
@@ -110,6 +136,14 @@ CONF_SCHEMA = {
                 'ignore_roi_if_buy_signal_true': {'type': 'boolean'}
             }
         },
+        'pairlist': {
+            'type': 'object',
+            'properties': {
+                'method': {'type': 'string', 'enum': AVAILABLE_PAIRLISTS},
+                'config': {'type': 'object'}
+            },
+            'required': ['method']
+        },
         'telegram': {
             'type': 'object',
             'properties': {
@@ -130,6 +164,7 @@ CONF_SCHEMA = {
         },
         'db_url': {'type': 'string'},
         'initial_state': {'type': 'string', 'enum': ['running', 'stopped']},
+        'forcebuy_enable': {'type': 'boolean'},
         'internals': {
             'type': 'object',
             'properties': {
@@ -164,9 +199,30 @@ CONF_SCHEMA = {
                     },
                     'uniqueItems': True
                 },
-                'outdated_offset': {'type': 'integer', 'minimum': 1}
+                'outdated_offset': {'type': 'integer', 'minimum': 1},
+                'ccxt_config': {'type': 'object'},
+                'ccxt_async_config': {'type': 'object'}
             },
             'required': ['name', 'key', 'secret', 'pair_whitelist']
+        },
+        'edge': {
+            'type': 'object',
+            'properties': {
+                "enabled": {'type': 'boolean'},
+                "process_throttle_secs": {'type': 'integer', 'minimum': 600},
+                "calculate_since_number_of_days": {'type': 'integer'},
+                "allowed_risk": {'type': 'number'},
+                "capital_available_percentage": {'type': 'number'},
+                "stoploss_range_min": {'type': 'number'},
+                "stoploss_range_max": {'type': 'number'},
+                "stoploss_range_step": {'type': 'number'},
+                "minimum_winrate": {'type': 'number'},
+                "minimum_expectancy": {'type': 'number'},
+                "min_trade_number": {'type': 'number'},
+                "max_trade_duration_minute": {'type': 'integer'},
+                "remove_pumps": {'type': 'boolean'}
+            },
+            'required': ['process_throttle_secs', 'allowed_risk', 'capital_available_percentage']
         }
     },
     'anyOf': [

freqtrade/data/__init__.py

@@ -0,0 +1,8 @@
+"""
+Module to handle data operations for freqtrade
+"""
+
+# limit what's imported when using `from freqtrad.data import *``
+__all__ = [
+    'converter'
+]

freqtrade/data/converter.py

@@ -0,0 +1,106 @@
+"""
+Functions to convert data from one format to another
+"""
+import logging
+import pandas as pd
+from pandas import DataFrame, to_datetime
+
+from freqtrade.constants import TICKER_INTERVAL_MINUTES
+
+logger = logging.getLogger(__name__)
+
+
+def parse_ticker_dataframe(ticker: list, ticker_interval: str,
+                           fill_missing: 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 fill_missing: fill up missing candles with 0 candles
+                         (see ohlcv_fill_up_missing_data for details)
+    :return: DataFrame
+    """
+    logger.debug("Parsing tickerlist to dataframe")
+    cols = ['date', 'open', 'high', 'low', 'close', 'volume']
+    frame = DataFrame(ticker, columns=cols)
+
+    frame['date'] = to_datetime(frame['date'],
+                                unit='ms',
+                                utc=True,
+                                infer_datetime_format=True)
+
+    # Some exchanges return int values for volume and even for ohlc.
+    # Convert them since TA-LIB indicators used in the strategy assume floats
+    # 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',
+        'high': 'max',
+        'low': 'min',
+        'close': 'last',
+        'volume': 'max',
+    })
+    frame.drop(frame.tail(1).index, inplace=True)     # eliminate partial candle
+    logger.debug('Dropping last candle')
+
+    if fill_missing:
+        return ohlcv_fill_up_missing_data(frame, ticker_interval)
+    else:
+        return frame
+
+
+def ohlcv_fill_up_missing_data(dataframe: DataFrame, ticker_interval: 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
+
+    """
+    ohlc_dict = {
+        'open': 'first',
+        'high': 'max',
+        'low': 'min',
+        'close': 'last',
+        'volume': 'sum'
+    }
+    tick_mins = TICKER_INTERVAL_MINUTES[ticker_interval]
+    # Resample to create "NAN" values
+    df = dataframe.resample(f'{tick_mins}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)
+    logger.debug(f"Missing data fillup: before: {len(dataframe)} - after: {len(df)}")
+    return df
+
+
+def order_book_to_dataframe(bids: list, asks: list) -> DataFrame:
+    """
+    Gets order book list, returns dataframe with below format per suggested by creslin
+    -------------------------------------------------------------------
+     b_sum       b_size       bids       asks       a_size       a_sum
+    -------------------------------------------------------------------
+    """
+    cols = ['bids', 'b_size']
+
+    bids_frame = DataFrame(bids, columns=cols)
+    # add cumulative sum column
+    bids_frame['b_sum'] = bids_frame['b_size'].cumsum()
+    cols2 = ['asks', 'a_size']
+    asks_frame = DataFrame(asks, columns=cols2)
+    # add cumulative sum column
+    asks_frame['a_sum'] = asks_frame['a_size'].cumsum()
+
+    frame = pd.concat([bids_frame['b_sum'], bids_frame['b_size'], bids_frame['bids'],
+                       asks_frame['asks'], asks_frame['a_size'], asks_frame['a_sum']], axis=1,
+                      keys=['b_sum', 'b_size', 'bids', 'asks', 'a_size', 'a_sum'])
+    # logger.info('order book %s', frame )
+    return frame

freqtrade/data/dataprovider.py

@@ -0,0 +1,97 @@
+"""
+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(object):
+
+    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, tick_interval for which data is currently cached.
+        Should be whitelist + open trades.
+        """
+        return list(self._exchange._klines.keys())
+
+    def ohlcv(self, pair: str, tick_interval: str = None, copy: bool = True) -> DataFrame:
+        """
+        get ohlcv data for the given pair as DataFrame
+        Please check `available_pairs` to verify which pairs are currently cached.
+        :param pair: pair to get the data for
+        :param tick_interval: ticker_interval to get pair for
+        :param copy: copy dataframe before returning.
+                     Use false only for RO operations (where the dataframe is not modified)
+        """
+        if self.runmode in (RunMode.DRY_RUN, RunMode.LIVE):
+            if tick_interval:
+                pairtick = (pair, tick_interval)
+            else:
+                pairtick = (pair, self._config['ticker_interval'])
+
+            return self._exchange.klines(pairtick, copy=copy)
+        else:
+            return DataFrame()
+
+    def historic_ohlcv(self, pair: str, ticker_interval: str) -> DataFrame:
+        """
+        get stored historic ohlcv data
+        :param pair: pair to get the data for
+        :param tick_interval: ticker_interval to get pair for
+        """
+        return load_pair_history(pair=pair,
+                                 ticker_interval=ticker_interval,
+                                 refresh_pairs=False,
+                                 datadir=Path(self._config['datadir']) if self._config.get(
+                                     'datadir') else None
+                                 )
+
+    def ticker(self, pair: str):
+        """
+        Return last ticker data
+        """
+        # TODO: Implement me
+        pass
+
+    def orderbook(self, pair: str, max: int):
+        """
+        return latest orderbook data
+        """
+        # TODO: Implement me
+        pass
+
+    @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

@@ -0,0 +1,235 @@
+"""
+Handle historic data (ohlcv).
+includes:
+* load data for a pair (or a list of pairs) from disk
+* download data from exchange and store to disk
+"""
+
+import logging
+from pathlib import Path
+from typing import Optional, List, Dict, Tuple, Any
+
+import arrow
+from pandas import DataFrame
+
+from freqtrade import misc, constants, OperationalException
+from freqtrade.data.converter import parse_ticker_dataframe
+from freqtrade.exchange import Exchange
+from freqtrade.arguments import TimeRange
+
+logger = logging.getLogger(__name__)
+
+
+def trim_tickerlist(tickerlist: List[Dict], timerange: TimeRange) -> List[Dict]:
+    """
+    Trim tickerlist based on given timerange
+    """
+    if not tickerlist:
+        return tickerlist
+
+    start_index = 0
+    stop_index = len(tickerlist)
+
+    if timerange.starttype == 'line':
+        stop_index = timerange.startts
+    if timerange.starttype == 'index':
+        start_index = timerange.startts
+    elif timerange.starttype == 'date':
+        while (start_index < len(tickerlist) and
+               tickerlist[start_index][0] < timerange.startts * 1000):
+            start_index += 1
+
+    if timerange.stoptype == 'line':
+        start_index = len(tickerlist) + timerange.stopts
+    if timerange.stoptype == 'index':
+        stop_index = timerange.stopts
+    elif timerange.stoptype == 'date':
+        while (stop_index > 0 and
+               tickerlist[stop_index-1][0] > timerange.stopts * 1000):
+            stop_index -= 1
+
+    if start_index > stop_index:
+        raise ValueError(f'The timerange [{timerange.startts},{timerange.stopts}] is incorrect')
+
+    return tickerlist[start_index:stop_index]
+
+
+def load_tickerdata_file(
+        datadir: Optional[Path], pair: str,
+        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
+    """
+    path = make_testdata_path(datadir)
+    pair_s = pair.replace('/', '_')
+    file = path.joinpath(f'{pair_s}-{ticker_interval}.json')
+
+    pairdata = misc.file_load_json(file)
+
+    if not pairdata:
+        return None
+
+    if timerange:
+        pairdata = trim_tickerlist(pairdata, timerange)
+    return pairdata
+
+
+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
+                      ) -> DataFrame:
+    """
+    Loads cached ticker history for the given pair.
+    :return: DataFrame with ohlcv data
+    """
+
+    # 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 pair and store them in %s', datadir)
+        download_pair_history(datadir=datadir,
+                              exchange=exchange,
+                              pair=pair,
+                              tick_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',
+                           pair, arrow.get(pairdata[0][0] // 1000).strftime('%Y-%m-%d %H:%M:%S'))
+        if timerange.stoptype == 'date' and pairdata[-1][0] < timerange.stopts * 1000:
+            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, ticker_interval, fill_up_missing)
+    else:
+        logger.warning('No data for pair: "%s", Interval: %s. '
+                       'Use --refresh-pairs-cached to download the data',
+                       pair, ticker_interval)
+        return None
+
+
+def load_data(datadir: Optional[Path],
+              ticker_interval: str,
+              pairs: List[str],
+              refresh_pairs: bool = False,
+              exchange: Optional[Exchange] = None,
+              timerange: TimeRange = TimeRange(None, None, 0, 0),
+              fill_up_missing: bool = True) -> Dict[str, DataFrame]:
+    """
+    Loads ticker history data for a list of pairs the given parameters
+    :return: dict(<pair>:<tickerlist>)
+    """
+    result = {}
+
+    for pair in pairs:
+        hist = load_pair_history(pair=pair, ticker_interval=ticker_interval,
+                                 datadir=datadir, timerange=timerange,
+                                 refresh_pairs=refresh_pairs,
+                                 exchange=exchange,
+                                 fill_up_missing=fill_up_missing)
+        if hist is not None:
+            result[pair] = hist
+    return result
+
+
+def make_testdata_path(datadir: Optional[Path]) -> Path:
+    """Return the path where testdata files are stored"""
+    return datadir or (Path(__file__).parent.parent / "tests" / "testdata").resolve()
+
+
+def load_cached_data_for_updating(filename: Path, tick_interval: str,
+                                  timerange: Optional[TimeRange]) -> Tuple[List[Any],
+                                                                           Optional[int]]:
+    """
+    Load cached data and choose what part of the data should be updated
+    """
+
+    since_ms = None
+
+    # user sets timerange, so find the start time
+    if timerange:
+        if timerange.starttype == 'date':
+            since_ms = timerange.startts * 1000
+        elif timerange.stoptype == 'line':
+            num_minutes = timerange.stopts * constants.TICKER_INTERVAL_MINUTES[tick_interval]
+            since_ms = arrow.utcnow().shift(minutes=num_minutes).timestamp * 1000
+
+    # read the cached file
+    if filename.is_file():
+        with open(filename, "rt") as file:
+            data = misc.json_load(file)
+        # remove the last item, could be incomplete candle
+        if data:
+            data.pop()
+    else:
+        data = []
+
+    if data:
+        if since_ms and since_ms < data[0][0]:
+            # Earlier data than existing data requested, redownload all
+            data = []
+        else:
+            # a part of the data was already downloaded, so download unexist data only
+            since_ms = data[-1][0] + 1
+
+    return (data, since_ms)
+
+
+def download_pair_history(datadir: Optional[Path],
+                          exchange: Exchange,
+                          pair: str,
+                          tick_interval: str = '5m',
+                          timerange: Optional[TimeRange] = None) -> bool:
+    """
+    Download the latest ticker intervals from the exchange for the pair passed in parameters
+    The data is downloaded starting from the last correct ticker interval data that
+    exists in a cache. If timerange starts earlier than the data in the cache,
+    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 timerange: range of time to download
+    :return: bool with success state
+
+    """
+    try:
+        path = make_testdata_path(datadir)
+        filepair = pair.replace("/", "_")
+        filename = path.joinpath(f'{filepair}-{tick_interval}.json')
+
+        logger.info('Download the pair: "%s", Interval: %s', pair, tick_interval)
+
+        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,
+                                        since_ms=since_ms if since_ms
+                                        else
+                                        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)
+        return True
+    except BaseException:
+        logger.info('Failed to download the pair: "%s", Interval: %s',
+                    pair, tick_interval)
+        return False

freqtrade/edge/__init__.py

@@ -0,0 +1,441 @@
+# pragma pylint: disable=W0603
+""" Edge positioning package """
+import logging
+from pathlib import Path
+from typing import Any, Dict, NamedTuple
+
+import arrow
+import numpy as np
+import utils_find_1st as utf1st
+from pandas import DataFrame
+
+from freqtrade import constants, OperationalException
+from freqtrade.arguments import Arguments
+from freqtrade.arguments import TimeRange
+from freqtrade.data import history
+from freqtrade.optimize import get_timeframe
+from freqtrade.strategy.interface import SellType
+
+
+logger = logging.getLogger(__name__)
+
+
+class PairInfo(NamedTuple):
+    stoploss: float
+    winrate: float
+    risk_reward_ratio: float
+    required_risk_reward: float
+    expectancy: float
+    nb_trades: int
+    avg_trade_duration: float
+
+
+class Edge():
+    """
+    Calculates Win Rate, Risk Reward Ratio, Expectancy
+    against historical data for a give set of markets and a strategy
+    it then adjusts stoploss and position size accordingly
+    and force it into the strategy
+    Author: https://github.com/mishaker
+    """
+
+    config: Dict = {}
+    _cached_pairs: Dict[str, Any] = {}  # Keeps a list of pairs
+
+    def __init__(self, config: Dict[str, Any], exchange, strategy) -> None:
+
+        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
+        self._final_pairs: list = []
+
+        # 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'] != float('inf'):
+            logger.critical('max_open_trades should be -1 in config !')
+
+        if self.config['stake_amount'] != constants.UNLIMITED_STAKE_AMOUNT:
+            raise OperationalException('Edge works only with unlimited stake amount')
+
+        self._capital_percentage: float = self.edge_config.get('capital_available_percentage')
+        self._allowed_risk: float = self.edge_config.get('allowed_risk')
+        self._since_number_of_days: int = self.edge_config.get('calculate_since_number_of_days', 14)
+        self._last_updated: int = 0  # Timestamp of pairs last updated time
+        self._refresh_pairs = True
+
+        self._stoploss_range_min = float(self.edge_config.get('stoploss_range_min', -0.01))
+        self._stoploss_range_max = float(self.edge_config.get('stoploss_range_max', -0.05))
+        self._stoploss_range_step = float(self.edge_config.get('stoploss_range_step', -0.001))
+
+        # calculating stoploss range
+        self._stoploss_range = np.arange(
+            self._stoploss_range_min,
+            self._stoploss_range_max,
+            self._stoploss_range_step
+        )
+
+        self._timerange: TimeRange = Arguments.parse_timerange("%s-" % arrow.now().shift(
+            days=-1 * self._since_number_of_days).format('YYYYMMDD'))
+
+        self.fee = self.exchange.get_fee()
+
+    def calculate(self) -> bool:
+        pairs = self.config['exchange']['pair_whitelist']
+        heartbeat = self.edge_config.get('process_throttle_secs')
+
+        if (self._last_updated > 0) and (
+                self._last_updated + heartbeat > arrow.utcnow().timestamp):
+            return False
+
+        data: Dict[str, Any] = {}
+        logger.info('Using stake_currency: %s ...', self.config['stake_currency'])
+        logger.info('Using local backtesting data (using whitelist in given config) ...')
+
+        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._refresh_pairs,
+            exchange=self.exchange,
+            timerange=self._timerange
+        )
+
+        if not data:
+            # Reinitializing cached pairs
+            self._cached_pairs = {}
+            logger.critical("No data found. Edge is stopped ...")
+            return False
+
+        preprocessed = self.tickerdata_to_dataframe(data)
+
+        # Print timeframe
+        min_date, max_date = self.get_timeframe(preprocessed)
+        logger.info(
+            'Measuring data from %s up to %s (%s days) ...',
+            min_date.isoformat(),
+            max_date.isoformat(),
+            (max_date - min_date).days
+        )
+        headers = ['date', 'buy', 'open', 'close', 'sell', 'high', 'low']
+
+        trades: list = []
+        for pair, pair_data in preprocessed.items():
+            # Sorting dataframe by date and reset index
+            pair_data = pair_data.sort_values(by=['date'])
+            pair_data = pair_data.reset_index(drop=True)
+
+            ticker_data = self.advise_sell(
+                self.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:
+            return False
+
+        # Fill missing, calculable columns, profit, duration , abs etc.
+        trades_df = self._fill_calculable_fields(DataFrame(trades))
+        self._cached_pairs = self._process_expectancy(trades_df)
+        self._last_updated = arrow.utcnow().timestamp
+
+        return True
+
+    def stake_amount(self, pair: str, free_capital: float,
+                     total_capital: float, capital_in_trade: float) -> float:
+        stoploss = self.stoploss(pair)
+        available_capital = (total_capital + capital_in_trade) * self._capital_percentage
+        allowed_capital_at_risk = available_capital * self._allowed_risk
+        max_position_size = abs(allowed_capital_at_risk / stoploss)
+        position_size = min(max_position_size, free_capital)
+        if pair in self._cached_pairs:
+            logger.info(
+                'winrate: %s, expectancy: %s, position size: %s, pair: %s,'
+                ' capital in trade: %s, free capital: %s, total capital: %s,'
+                ' stoploss: %s, available capital: %s.',
+                self._cached_pairs[pair].winrate,
+                self._cached_pairs[pair].expectancy,
+                position_size, pair,
+                capital_in_trade, free_capital, total_capital,
+                stoploss, available_capital
+            )
+        return round(position_size, 15)
+
+    def stoploss(self, pair: str) -> float:
+        if pair in self._cached_pairs:
+            return self._cached_pairs[pair].stoploss
+        else:
+            logger.warning('tried to access stoploss of a non-existing pair, '
+                           'strategy stoploss is returned instead.')
+            return self.strategy.stoploss
+
+    def adjust(self, pairs) -> list:
+        """
+        Filters out and sorts "pairs" according to Edge calculated pairs
+        """
+        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)) and \
+                    pair in pairs:
+                final.append(pair)
+
+        if self._final_pairs != final:
+            self._final_pairs = final
+            if 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 '
+                    'and minimum winrate was found !'
+                    )
+
+        return self._final_pairs
+
+    def _fill_calculable_fields(self, result: DataFrame) -> DataFrame:
+        """
+        The result frame contains a number of columns that are calculable
+        from other columns. These are left blank till all rows are added,
+        to be populated in single vector calls.
+
+        Columns to be populated are:
+        - Profit
+        - trade duration
+        - profit abs
+        :param result Dataframe
+        :return: result Dataframe
+        """
+
+        # stake and fees
+        # stake = 0.015
+        # 0.05% is 0.0005
+        # fee = 0.001
+
+        # we set stake amount to an arbitrary amount.
+        # as it doesn't change the calculation.
+        # all returned values are relative. they are percentages.
+        stake = 0.015
+        fee = self.fee
+        open_fee = fee / 2
+        close_fee = fee / 2
+
+        result['trade_duration'] = result['close_time'] - result['open_time']
+
+        result['trade_duration'] = result['trade_duration'].map(
+            lambda x: int(x.total_seconds() / 60))
+
+        # Spends, Takes, Profit, Absolute Profit
+
+        # Buy Price
+        result['buy_vol'] = stake / result['open_rate']  # How many target are we buying
+        result['buy_fee'] = stake * open_fee
+        result['buy_spend'] = stake + result['buy_fee']  # How much we're spending
+
+        # Sell price
+        result['sell_sum'] = result['buy_vol'] * result['close_rate']
+        result['sell_fee'] = result['sell_sum'] * close_fee
+        result['sell_take'] = result['sell_sum'] - result['sell_fee']
+
+        # profit_percent
+        result['profit_percent'] = (result['sell_take'] - result['buy_spend']) / result['buy_spend']
+
+        # Absolute profit
+        result['profit_abs'] = result['sell_take'] - result['buy_spend']
+
+        return result
+
+    def _process_expectancy(self, results: DataFrame) -> Dict[str, Any]:
+        """
+        This calculates WinRate, Required Risk Reward, Risk Reward and Expectancy of all pairs
+        The calulation will be done per pair and per strategy.
+        """
+        # Removing pairs having less than min_trades_number
+        min_trades_number = self.edge_config.get('min_trade_number', 10)
+        results = results.groupby(['pair', 'stoploss']).filter(lambda x: len(x) > min_trades_number)
+        ###################################
+
+        # Removing outliers (Only Pumps) from the dataset
+        # The method to detect outliers is to calculate standard deviation
+        # Then every value more than (standard deviation + 2*average) is out (pump)
+        #
+        # Removing Pumps
+        if self.edge_config.get('remove_pumps', False):
+            results = results.groupby(['pair', 'stoploss']).apply(
+                lambda x: x[x['profit_abs'] < 2 * x['profit_abs'].std() + x['profit_abs'].mean()])
+        ##########################################################################
+
+        # Removing trades having a duration more than X minutes (set in config)
+        max_trade_duration = self.edge_config.get('max_trade_duration_minute', 1440)
+        results = results[results.trade_duration < max_trade_duration]
+        #######################################################################
+
+        if results.empty:
+            return {}
+
+        groupby_aggregator = {
+            'profit_abs': [
+                ('nb_trades', 'count'),  # number of all trades
+                ('profit_sum', lambda x: x[x > 0].sum()),  # cumulative profit of all winning trades
+                ('loss_sum', lambda x: abs(x[x < 0].sum())),  # cumulative loss of all losing trades
+                ('nb_win_trades', lambda x: x[x > 0].count())  # number of winning trades
+            ],
+            'trade_duration': [('avg_trade_duration', 'mean')]
+        }
+
+        # Group by (pair and stoploss) by applying above aggregator
+        df = results.groupby(['pair', 'stoploss'])['profit_abs', 'trade_duration'].agg(
+            groupby_aggregator).reset_index(col_level=1)
+
+        # Dropping level 0 as we don't need it
+        df.columns = df.columns.droplevel(0)
+
+        # Calculating number of losing trades, average win and average loss
+        df['nb_loss_trades'] = df['nb_trades'] - df['nb_win_trades']
+        df['average_win'] = df['profit_sum'] / df['nb_win_trades']
+        df['average_loss'] = df['loss_sum'] / df['nb_loss_trades']
+
+        # Win rate = number of profitable trades / number of trades
+        df['winrate'] = df['nb_win_trades'] / df['nb_trades']
+
+        # risk_reward_ratio = average win / average loss
+        df['risk_reward_ratio'] = df['average_win'] / df['average_loss']
+
+        # required_risk_reward = (1 / winrate) - 1
+        df['required_risk_reward'] = (1 / df['winrate']) - 1
+
+        # expectancy = (risk_reward_ratio * winrate) - (lossrate)
+        df['expectancy'] = (df['risk_reward_ratio'] * df['winrate']) - (1 - df['winrate'])
+
+        # sort by expectancy and stoploss
+        df = df.sort_values(by=['expectancy', 'stoploss'], ascending=False).groupby(
+            'pair').first().sort_values(by=['expectancy'], ascending=False).reset_index()
+
+        final = {}
+        for x in df.itertuples():
+            final[x.pair] = PairInfo(
+                x.stoploss,
+                x.winrate,
+                x.risk_reward_ratio,
+                x.required_risk_reward,
+                x.expectancy,
+                x.nb_trades,
+                x.avg_trade_duration
+            )
+
+        # Returning a list of pairs in order of "expectancy"
+        return final
+
+    def _find_trades_for_stoploss_range(self, ticker_data, pair, stoploss_range):
+        buy_column = ticker_data['buy'].values
+        sell_column = ticker_data['sell'].values
+        date_column = ticker_data['date'].values
+        ohlc_columns = ticker_data[['open', 'high', 'low', 'close']].values
+
+        result: list = []
+        for stoploss in stoploss_range:
+            result += self._detect_next_stop_or_sell_point(
+                buy_column, sell_column, date_column, ohlc_columns, round(stoploss, 6), pair
+            )
+
+        return result
+
+    def _detect_next_stop_or_sell_point(self, buy_column, sell_column, date_column,
+                                        ohlc_columns, stoploss, pair, start_point=0):
+        """
+        Iterate through ohlc_columns recursively 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
+        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)
+
+        # return empty if we don't find trade entry (i.e. buy==1) or
+        # we find a buy but at the of array
+        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
+        open_price = ohlc_columns[open_trade_index, 0]
+        stop_price = (open_price * stop_price_percentage)
+
+        # Searching for the index where stoploss is hit
+        stop_index = utf1st.find_1st(
+            ohlc_columns[open_trade_index:, 2], stop_price, utf1st.cmp_smaller)
+
+        # If we don't find it then we assume stop_index will be far in future (infinite number)
+        if stop_index == -1:
+            stop_index = float('inf')
+
+        # Searching for the index where sell is hit
+        sell_index = utf1st.find_1st(sell_column[open_trade_index:], 1, utf1st.cmp_equal)
+
+        # If we don't find it then we assume sell_index will be far in future (infinite number)
+        if sell_index == -1:
+            sell_index = float('inf')
+
+        # Check if we don't find any stop or sell point (in that case trade remains open)
+        # It is not interesting for Edge to consider it so we simply ignore the trade
+        # And stop iterating there is no more entry
+        if stop_index == sell_index == float('inf'):
+            return []
+
+        if stop_index <= sell_index:
+            exit_index = open_trade_index + stop_index
+            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
+
+            # check if we have the next candle
+            if len(ohlc_columns) - 1 < exit_index:
+                return []
+
+            exit_type = SellType.SELL_SIGNAL
+            exit_price = ohlc_columns[exit_index, 0]
+
+        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
+                 }
+
+        result.append(trade)
+
+        # Calling again the same function recursively but giving
+        # it a view of exit_index till the end of array
+        return result + self._detect_next_stop_or_sell_point(
+            buy_column[exit_index:],
+            sell_column[exit_index:],
+            date_column[exit_index:],
+            ohlc_columns[exit_index:],
+            stoploss,
+            pair,
+            (start_point + exit_index)
+        )

freqtrade/exchange/__init__.py

@@ -7,12 +7,14 @@ from typing import List, Dict, Tuple, Any, Optional
 from datetime import datetime
 from math import floor, ceil
 
+import arrow
 import asyncio
 import ccxt
 import ccxt.async_support as ccxt_async
-import arrow
+from pandas import DataFrame
 
 from freqtrade import constants, OperationalException, DependencyException, TemporaryError
+from freqtrade.data.converter import parse_ticker_dataframe
 
 logger = logging.getLogger(__name__)
 
@@ -64,14 +66,8 @@ def retrier(f):
 
 class Exchange(object):
 
-    # Current selected exchange
-    _api: ccxt.Exchange = None
-    _api_async: ccxt_async.Exchange = None
     _conf: Dict = {}
 
-    # Holds all open sell orders for dry_run
-    _dry_run_open_orders: Dict[str, Any] = {}
-
     def __init__(self, config: dict) -> None:
         """
         Initializes this module with the given config,
@@ -84,24 +80,30 @@ class Exchange(object):
         self._cached_ticker: Dict[str, Any] = {}
 
         # Holds last candle refreshed time of each pair
-        self._pairs_last_refresh_time: Dict[str, int] = {}
+        self._pairs_last_refresh_time: Dict[Tuple[str, str], int] = {}
 
         # Holds candles
-        self.klines: Dict[str, Any] = {}
+        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']
-        self._api = self._init_ccxt(exchange_config)
-        self._api_async = self._init_ccxt(exchange_config, ccxt_async)
+        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'])
@@ -114,7 +116,8 @@ class Exchange(object):
         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.Exchange:
+    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.
@@ -124,14 +127,20 @@ class Exchange(object):
 
         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())({
-                '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)
-            })
+
+            api = getattr(ccxt_module, name.lower())(ex_config)
         except (KeyError, AttributeError):
             raise OperationalException(f'Exchange {name} is not supported')
 
@@ -149,6 +158,13 @@ class Exchange(object):
         """exchange ccxt id"""
         return self._api.id
 
+    def klines(self, pair_interval: Tuple[str, str], copy=True) -> DataFrame:
+        # create key tuple
+        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'):
@@ -199,7 +215,8 @@ class Exchange(object):
                     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'Pair {pair} is not available at {self.name}'
+                    f'Please remove {pair} from your whitelist.')
 
     def validate_timeframes(self, timeframe: List[str]) -> None:
         """
@@ -210,6 +227,30 @@ class Exchange(object):
             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 != '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 != '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.
@@ -241,14 +282,15 @@ class Exchange(object):
             price = ceil(big_price) / pow(10, symbol_prec)
         return price
 
-    def buy(self, pair: str, rate: float, amount: float) -> Dict:
+    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': 'limit',
+                'type': ordertype,
                 'side': 'buy',
                 'remaining': 0.0,
                 'datetime': arrow.utcnow().isoformat(),
@@ -260,9 +302,14 @@ class Exchange(object):
         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)
+            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})
 
-            return self._api.create_limit_buy_order(pair, amount, rate)
         except ccxt.InsufficientFunds as e:
             raise DependencyException(
                 f'Insufficient funds to create limit buy order on market {pair}.'
@@ -279,14 +326,15 @@ class Exchange(object):
         except ccxt.BaseError as e:
             raise OperationalException(e)
 
-    def sell(self, pair: str, rate: float, amount: float) -> Dict:
+    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': 'limit',
+                'type': ordertype,
                 'side': 'sell',
                 'remaining': 0.0,
                 'datetime': arrow.utcnow().isoformat(),
@@ -297,9 +345,14 @@ class Exchange(object):
         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)
+            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})
 
-            return self._api.create_limit_sell_order(pair, amount, rate)
         except ccxt.InsufficientFunds as e:
             raise DependencyException(
                 f'Insufficient funds to create limit sell order on market {pair}.'
@@ -316,6 +369,64 @@ class Exchange(object):
         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:
+            order = self._api.create_order(pair, 'stop_loss_limit', 'sell',
+                                           amount, rate, {'stopPrice': stop_price})
+            logger.info('stoploss limit order added for %s. '
+                        'stop price: %s. limit: %s' % (pair, stop_price, rate))
+            return order
+
+        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']:
@@ -367,6 +478,8 @@ class Exchange(object):
     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] = {
@@ -406,116 +519,85 @@ class Exchange(object):
         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 tick in tickers:
-            if tick[0] == pair:
-                data.extend(tick[1])
-        # Sort data again after extending the result - above calls return in "async order" order
+        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_tickers(self, pair_list: List[str], ticker_interval: str) -> None:
+    def refresh_latest_ohlcv(self, pair_list: List[Tuple[str, str]]) -> List[Tuple[str, List]]:
         """
-        Refresh tickers asyncronously and return the result.
+        Refresh in-memory ohlcv asyncronously and set `_klines` 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))
+        logger.debug("Refreshing ohlcv data for %d pairs", len(pair_list))
 
-    async def async_get_candles_history(self, pairs: List[str],
-                                        tick_interval: str) -> List[Tuple[str, List]]:
-        """Download ohlcv history for pair-list asyncronously """
-        input_coroutines = [self._async_get_candle_history(
-            symbol, tick_interval) for symbol in pairs]
-        tickers = await asyncio.gather(*input_coroutines, return_exceptions=True)
+        input_coroutines = []
+
+        # Gather corotines to run
+        for pair, ticker_interval in set(pair_list):
+            # Calculating ticker interval in second
+            interval_in_sec = constants.TICKER_INTERVAL_MINUTES[ticker_interval] * 60
+
+            if not ((self._pairs_last_refresh_time.get((pair, ticker_interval), 0)
+                    + interval_in_sec) >= arrow.utcnow().timestamp
+                    and (pair, ticker_interval) in self._klines):
+                input_coroutines.append(self._async_get_candle_history(pair, ticker_interval))
+            else:
+                logger.debug("Using cached ohlcv data for %s, %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]
+            tick_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, tick_interval)] = ticks[-1][0] // 1000
+            # keeping parsed dataframe in cache
+            self._klines[(pair, tick_interval)] = parse_ticker_dataframe(
+                ticks, tick_interval, fill_missing=True)
         return tickers
 
     @retrier_async
     async def _async_get_candle_history(self, pair: str, tick_interval: str,
-                                        since_ms: Optional[int] = None) -> Tuple[str, List]:
+                                        since_ms: Optional[int] = None) -> Tuple[str, str, List]:
+        """
+        Asyncronously gets candle histories using fetch_ohlcv
+        returns tuple: (pair, tick_interval, ohlcv_list)
+        """
         try:
             # fetch ohlcv asynchronously
-            logger.debug("fetching %s since %s ...", pair, since_ms)
+            logger.debug("fetching %s, %s since %s ...", pair, tick_interval, since_ms)
 
-            # Calculating ticker interval in second
-            interval_in_sec = constants.TICKER_INTERVAL_MINUTES[tick_interval] * 60
-
-            # If (last update time) + (interval in second) is greater or equal than now
-            # that means we don't have to hit the API as there is no new candle
-            # so we fetch it from local cache
-            if (not since_ms and
-                    self._pairs_last_refresh_time.get(pair, 0) + interval_in_sec >=
-                    arrow.utcnow().timestamp):
-                data = self.klines[pair]
-                logger.debug("Using cached klines data for %s ...", pair)
-            else:
-                data = await self._api_async.fetch_ohlcv(pair, timeframe=tick_interval,
-                                                         since=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)
-            data = sorted(data, key=lambda x: x[0])
+            # 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, tick_interval, []
+            logger.debug("done fetching %s, %s ...", pair, tick_interval)
+            return pair, tick_interval, data
 
-            # keeping last candle time as last refreshed time of the pair
-            if data:
-                self._pairs_last_refresh_time[pair] = data[-1][0] // 1000
-
-            # keeping candles in cache
-            self.klines[pair] = data
-
-            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 get_candle_history(self, pair: str, tick_interval: str,
-                           since_ms: Optional[int] = None) -> List[Dict]:
-        try:
-            # last item should be in the time interval [now - tick_interval, now]
-            till_time_ms = arrow.utcnow().shift(
-                            minutes=-constants.TICKER_INTERVAL_MINUTES[tick_interval]
-                        ).timestamp * 1000
-            # it looks as if some exchanges return cached data
-            # and they update it one in several minute, so 10 mins interval
-            # is necessary to skeep downloading of an empty array when all
-            # chached data was already downloaded
-            till_time_ms = min(till_time_ms, arrow.utcnow().shift(minutes=-10).timestamp * 1000)
-
-            data: List[Dict[Any, Any]] = []
-            while not since_ms or since_ms < till_time_ms:
-                data_part = self._api.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)
-                data_part = sorted(data_part, key=lambda x: x[0])
-
-                if not data_part:
-                    break
-
-                logger.debug('Downloaded data for %s time range [%s, %s]',
-                             pair,
-                             arrow.get(data_part[0][0] / 1000).format(),
-                             arrow.get(data_part[-1][0] / 1000).format())
-
-                data.extend(data_part)
-                since_ms = data[-1][0] + 1
-
-            return data
         except ccxt.NotSupported as e:
             raise OperationalException(
                 f'Exchange {self._api.name} does not support fetching historical candlestick data.'

freqtrade/exchange/exchange_helpers.py

@@ -1,58 +0,0 @@
-"""
-Functions to analyze ticker data with indicators and produce buy and sell signals
-"""
-import logging
-import pandas as pd
-from pandas import DataFrame, to_datetime
-
-logger = logging.getLogger(__name__)
-
-
-def parse_ticker_dataframe(ticker: list) -> DataFrame:
-    """
-    Analyses the trend for the given ticker history
-    :param ticker: See exchange.get_candle_history
-    :return: DataFrame
-    """
-    cols = ['date', 'open', 'high', 'low', 'close', 'volume']
-    frame = DataFrame(ticker, columns=cols)
-
-    frame['date'] = to_datetime(frame['date'],
-                                unit='ms',
-                                utc=True,
-                                infer_datetime_format=True)
-
-    # group by index and aggregate results to eliminate duplicate ticks
-    frame = frame.groupby(by='date', as_index=False, sort=True).agg({
-        'open': 'first',
-        'high': 'max',
-        'low': 'min',
-        'close': 'last',
-        'volume': 'max',
-    })
-    frame.drop(frame.tail(1).index, inplace=True)     # eliminate partial candle
-    return frame
-
-
-def order_book_to_dataframe(bids: list, asks: list) -> DataFrame:
-    """
-    Gets order book list, returns dataframe with below format per suggested by creslin
-    -------------------------------------------------------------------
-     b_sum       b_size       bids       asks       a_size       a_sum
-    -------------------------------------------------------------------
-    """
-    cols = ['bids', 'b_size']
-
-    bids_frame = DataFrame(bids, columns=cols)
-    # add cumulative sum column
-    bids_frame['b_sum'] = bids_frame['b_size'].cumsum()
-    cols2 = ['asks', 'a_size']
-    asks_frame = DataFrame(asks, columns=cols2)
-    # add cumulative sum column
-    asks_frame['a_sum'] = asks_frame['a_size'].cumsum()
-
-    frame = pd.concat([bids_frame['b_sum'], bids_frame['b_size'], bids_frame['bids'],
-                       asks_frame['asks'], asks_frame['a_size'], asks_frame['a_sum']], axis=1,
-                      keys=['b_sum', 'b_size', 'bids', 'asks', 'a_size', 'a_sum'])
-    # logger.info('order book %s', frame )
-    return frame

freqtrade/freqtradebot.py

@@ -12,17 +12,19 @@ from typing import Any, Callable, Dict, List, Optional
 import arrow
 from requests.exceptions import RequestException
 
-from cachetools import TTLCache, cached
-
 from freqtrade import (DependencyException, OperationalException,
                        TemporaryError, __version__, constants, persistence)
+from freqtrade.data.converter import order_book_to_dataframe
+from freqtrade.data.dataprovider import DataProvider
+from freqtrade.edge import Edge
 from freqtrade.exchange import Exchange
 from freqtrade.persistence import Trade
 from freqtrade.rpc import RPCManager, RPCMessageType
+from freqtrade.resolvers import StrategyResolver, PairListResolver
 from freqtrade.state import State
-from freqtrade.strategy.interface import SellType
-from freqtrade.strategy.resolver import IStrategy, StrategyResolver
-from freqtrade.exchange.exchange_helpers import order_book_to_dataframe
+from freqtrade.strategy.interface import SellType, IStrategy
+from freqtrade.wallets import Wallets
+
 
 logger = logging.getLogger(__name__)
 
@@ -33,11 +35,11 @@ class FreqtradeBot(object):
     This is from here the bot start its logic.
     """
 
-    def __init__(self, config: Dict[str, Any])-> None:
+    def __init__(self, config: Dict[str, Any]) -> None:
         """
-        Init all variables and object the bot need to work
-        :param config: configuration dict, you can use the Configuration.get_config()
-        method to get the config dict.
+        Init all variables and objects the bot needs to work
+        :param config: configuration dict, you can use Configuration.get_config()
+        to get the config dict.
         """
 
         logger.info(
@@ -51,9 +53,25 @@ class FreqtradeBot(object):
         # Init objects
         self.config = config
         self.strategy: IStrategy = StrategyResolver(self.config).strategy
+
         self.rpc: RPCManager = RPCManager(self)
-        self.persistence = None
         self.exchange = Exchange(self.config)
+        self.wallets = Wallets(self.exchange)
+        self.dataprovider = DataProvider(self.config, self.exchange)
+
+        # Attach Dataprovider to Strategy baseclass
+        IStrategy.dp = self.dataprovider
+        # Attach Wallets to Strategy baseclass
+        IStrategy.wallets = self.wallets
+
+        pairlistname = self.config.get('pairlist', {}).get('method', 'StaticPairList')
+        self.pairlists = PairListResolver(pairlistname, self, self.config).pairlist
+
+        # Initializing Edge only if enabled
+        self.edge = Edge(self.config, self.exchange, self.strategy) if \
+            self.config.get('edge', {}).get('enabled', False) else None
+
+        self.active_pair_whitelist: List[str] = self.config['exchange']['pair_whitelist']
         self._init_modules()
 
     def _init_modules(self) -> None:
@@ -97,7 +115,7 @@ class FreqtradeBot(object):
             })
             logger.info('Changing state to: %s', state.name)
             if state == State.RUNNING:
-                self._startup_messages()
+                self.rpc.startup_messages(self.config, self.pairlists)
 
         if state == State.STOPPED:
             time.sleep(1)
@@ -107,45 +125,10 @@ class FreqtradeBot(object):
                 constants.PROCESS_THROTTLE_SECS
             )
 
-            nb_assets = self.config.get('dynamic_whitelist', None)
-
             self._throttle(func=self._process,
-                           min_secs=min_secs,
-                           nb_assets=nb_assets)
+                           min_secs=min_secs)
         return state
 
-    def _startup_messages(self) -> None:
-        if self.config.get('dry_run', False):
-            self.rpc.send_msg({
-                'type': RPCMessageType.WARNING_NOTIFICATION,
-                'status': 'Dry run is enabled. All trades are simulated.'
-            })
-        stake_currency = self.config['stake_currency']
-        stake_amount = self.config['stake_amount']
-        minimal_roi = self.config['minimal_roi']
-        ticker_interval = self.config['ticker_interval']
-        exchange_name = self.config['exchange']['name']
-        strategy_name = self.config.get('strategy', '')
-        self.rpc.send_msg({
-            'type': RPCMessageType.CUSTOM_NOTIFICATION,
-            'status': f'*Exchange:* `{exchange_name}`\n'
-                      f'*Stake per trade:* `{stake_amount} {stake_currency}`\n'
-                      f'*Minimum ROI:* `{minimal_roi}`\n'
-                      f'*Ticker Interval:* `{ticker_interval}`\n'
-                      f'*Strategy:* `{strategy_name}`'
-        })
-        if self.config.get('dynamic_whitelist', False):
-            top_pairs = 'top ' + str(self.config.get('dynamic_whitelist', 20))
-            specific_pairs = ''
-        else:
-            top_pairs = 'whitelisted'
-            specific_pairs = '\n' + ', '.join(self.config['exchange'].get('pair_whitelist', ''))
-        self.rpc.send_msg({
-            'type': RPCMessageType.STATUS_NOTIFICATION,
-            'status': f'Searching for {top_pairs} {stake_currency} pairs to buy and sell...'
-                      f'{specific_pairs}'
-        })
-
     def _throttle(self, func: Callable[..., Any], min_secs: float, *args, **kwargs) -> Any:
         """
         Throttles the given callable that it
@@ -162,32 +145,38 @@ class FreqtradeBot(object):
         time.sleep(duration)
         return result
 
-    def _process(self, nb_assets: Optional[int] = 0) -> bool:
+    def _process(self) -> bool:
         """
         Queries the persistence layer for open trades and handles them,
         otherwise a new trade is created.
-        :param: nb_assets: the maximum number of pairs to be traded at the same time
         :return: True if one or more trades has been created or closed, False otherwise
         """
         state_changed = False
         try:
-            # Refresh whitelist based on wallet maintenance
-            sanitized_list = self._refresh_whitelist(
-                self._gen_pair_whitelist(
-                    self.config['stake_currency']
-                ) if nb_assets else self.config['exchange']['pair_whitelist']
-            )
+            # Refresh whitelist
+            self.pairlists.refresh_pairlist()
+            self.active_pair_whitelist = self.pairlists.whitelist
 
-            # Keep only the subsets of pairs wanted (up to nb_assets)
-            final_list = sanitized_list[:nb_assets] if nb_assets else sanitized_list
-            self.config['exchange']['pair_whitelist'] = final_list
-
-            # Refreshing candles
-            self.exchange.refresh_tickers(final_list, self.strategy.ticker_interval)
+            # Calculating Edge positiong
+            if self.edge:
+                self.edge.calculate()
+                self.active_pair_whitelist = self.edge.adjust(self.active_pair_whitelist)
 
             # Query trades from persistence layer
             trades = Trade.query.filter(Trade.is_open.is_(True)).all()
 
+            # Extend active-pair whitelist with pairs from open trades
+            # ensures that tickers are downloaded for open trades
+            self.active_pair_whitelist.extend([trade.pair for trade in trades
+                                               if trade.pair not in self.active_pair_whitelist])
+
+            # Create pair-whitelist tuple with (pair, ticker_interval)
+            pair_whitelist_tuple = [(pair, self.config['ticker_interval'])
+                                    for pair in self.active_pair_whitelist]
+            # Refreshing candles
+            self.dataprovider.refresh(pair_whitelist_tuple,
+                                      self.strategy.informative_pairs())
+
             # First process current opened trades
             for trade in trades:
                 state_changed |= self.process_maybe_execute_sell(trade)
@@ -202,7 +191,7 @@ class FreqtradeBot(object):
                 Trade.session.flush()
 
         except TemporaryError as error:
-            logger.warning('%s, retrying in 30 seconds...', error)
+            logger.warning(f"Error: {error}, retrying in {constants.RETRY_TIMEOUT} seconds...")
             time.sleep(constants.RETRY_TIMEOUT)
         except OperationalException:
             tb = traceback.format_exc()
@@ -215,76 +204,11 @@ class FreqtradeBot(object):
             self.state = State.STOPPED
         return state_changed
 
-    @cached(TTLCache(maxsize=1, ttl=1800))
-    def _gen_pair_whitelist(self, base_currency: str, key: str = 'quoteVolume') -> List[str]:
-        """
-        Updates the whitelist with with a dynamically generated list
-        :param base_currency: base currency as str
-        :param key: sort key (defaults to 'quoteVolume')
-        :return: List of pairs
-        """
-
-        if not self.exchange.exchange_has('fetchTickers'):
-            raise OperationalException(
-                'Exchange does not support dynamic whitelist.'
-                'Please edit your config and restart the bot'
-            )
-
-        tickers = self.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]
-
-        sorted_tickers = sorted(tickers, reverse=True, key=lambda t: t[key])
-        pairs = [s['symbol'] for s in sorted_tickers]
-        return pairs
-
-    def _refresh_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
-        trade
-        :return: the list of pairs the user wants to trade without the one unavailable or
-        black_listed
-        """
-        sanitized_whitelist = whitelist
-        markets = self.exchange.get_markets()
-
-        markets = [m for m in markets if m['quote'] == self.config['stake_currency']]
-        known_pairs = set()
-        for market in markets:
-            pair = market['symbol']
-            # pair is not int the generated dynamic market, or in the blacklist ... ignore it
-            if pair not in whitelist or pair in self.config['exchange'].get('pair_blacklist', []):
-                continue
-            # else the pair is valid
-            known_pairs.add(pair)
-            # Market is not active
-            if not market['active']:
-                sanitized_whitelist.remove(pair)
-                logger.info(
-                    'Ignoring %s from whitelist. Market is not active.',
-                    pair
-                )
-
-        # We need to remove pairs that are unknown
-        final_list = [x for x in sanitized_whitelist if x in known_pairs]
-
-        return final_list
-
-    def get_target_bid(self, pair: str, ticker: Dict[str, float]) -> float:
+    def get_target_bid(self, pair: str) -> float:
         """
         Calculates bid target between current ask price and last price
-        :param ticker: Ticker to use for getting Ask and Last Price
         :return: float: Price
         """
-        if ticker['ask'] < ticker['last']:
-            ticker_rate = ticker['ask']
-        else:
-            balance = self.config['bid_strategy']['ask_last_balance']
-            ticker_rate = ticker['ask'] + balance * (ticker['last'] - ticker['ask'])
-
-        used_rate = ticker_rate
         config_bid_strategy = self.config.get('bid_strategy', {})
         if 'use_order_book' in config_bid_strategy and\
                 config_bid_strategy.get('use_order_book', False):
@@ -294,27 +218,37 @@ class FreqtradeBot(object):
             logger.debug('order_book %s', order_book)
             # top 1 = index 0
             order_book_rate = order_book['bids'][order_book_top - 1][0]
-            # if ticker has lower rate, then use ticker ( usefull if down trending )
             logger.info('...top %s order book buy rate %0.8f', order_book_top, order_book_rate)
-            if ticker_rate < order_book_rate:
-                logger.info('...using ticker rate instead %0.8f', ticker_rate)
-                used_rate = ticker_rate
-            else:
-                used_rate = order_book_rate
+            used_rate = order_book_rate
         else:
             logger.info('Using Last Ask / Last Price')
+            ticker = self.exchange.get_ticker(pair)
+            if ticker['ask'] < ticker['last']:
+                ticker_rate = ticker['ask']
+            else:
+                balance = self.config['bid_strategy']['ask_last_balance']
+                ticker_rate = ticker['ask'] + balance * (ticker['last'] - ticker['ask'])
             used_rate = ticker_rate
 
         return used_rate
 
-    def _get_trade_stake_amount(self) -> Optional[float]:
+    def _get_trade_stake_amount(self, pair) -> Optional[float]:
         """
         Check if stake amount can be fulfilled with the available balance
         for the stake currency
         :return: float: Stake Amount
         """
-        stake_amount = self.config['stake_amount']
-        avaliable_amount = self.exchange.get_balance(self.config['stake_currency'])
+        if self.edge:
+            return self.edge.stake_amount(
+                pair,
+                self.wallets.get_free(self.config['stake_currency']),
+                self.wallets.get_total(self.config['stake_currency']),
+                Trade.total_open_trades_stakes()
+            )
+        else:
+            stake_amount = self.config['stake_amount']
+
+        avaliable_amount = self.wallets.get_free(self.config['stake_currency'])
 
         if stake_amount == constants.UNLIMITED_STAKE_AMOUNT:
             open_trades = len(Trade.query.filter(Trade.is_open.is_(True)).all())
@@ -326,9 +260,8 @@ class FreqtradeBot(object):
         # Check if stake_amount is fulfilled
         if avaliable_amount < stake_amount:
             raise DependencyException(
-                'Available balance(%f %s) is lower than stake amount(%f %s)' % (
-                    avaliable_amount, self.config['stake_currency'],
-                    stake_amount, self.config['stake_currency'])
+                f"Available balance({avaliable_amount} {self.config['stake_currency']}) is "
+                f"lower than stake amount({stake_amount} {self.config['stake_currency']})"
             )
 
         return stake_amount
@@ -357,7 +290,9 @@ class FreqtradeBot(object):
         if not min_stake_amounts:
             return None
 
-        amount_reserve_percent = 1 - 0.05  # reserve 5% + stoploss
+        # reserve some percent defined in config (5% default) + stoploss
+        amount_reserve_percent = 1.0 - self.config.get('amount_reserve_percent',
+                                                       constants.DEFAULT_AMOUNT_RESERVE_PERCENT)
         if self.strategy.stoploss is not None:
             amount_reserve_percent += self.strategy.stoploss
         # it should not be more than 50%
@@ -371,16 +306,7 @@ class FreqtradeBot(object):
         :return: True if a trade object has been created and persisted, False otherwise
         """
         interval = self.strategy.ticker_interval
-        stake_amount = self._get_trade_stake_amount()
-
-        if not stake_amount:
-            return False
-
-        logger.info(
-            'Checking buy signals to create a new trade with stake_amount: %f ...',
-            stake_amount
-        )
-        whitelist = copy.deepcopy(self.config['exchange']['pair_whitelist'])
+        whitelist = copy.deepcopy(self.active_pair_whitelist)
 
         # Remove currently opened and latest pairs from whitelist
         for trade in Trade.query.filter(Trade.is_open.is_(True)).all():
@@ -392,10 +318,18 @@ class FreqtradeBot(object):
             raise DependencyException('No currency pairs in whitelist')
 
         # running get_signal on historical data fetched
-        # to find buy signals
         for _pair in whitelist:
-            (buy, sell) = self.strategy.get_signal(_pair, interval, self.exchange.klines.get(_pair))
+            (buy, sell) = self.strategy.get_signal(
+                _pair, interval, self.dataprovider.ohlcv(_pair, self.strategy.ticker_interval))
+
             if buy and not sell:
+                stake_amount = self._get_trade_stake_amount(_pair)
+                if not stake_amount:
+                    return False
+
+                logger.info(f"Buy signal found: about create a new trade with stake_amount: "
+                            f"{stake_amount} ...")
+
                 bidstrat_check_depth_of_market = self.config.get('bid_strategy', {}).\
                     get('check_depth_of_market', {})
                 if (bidstrat_check_depth_of_market.get('enabled', False)) and\
@@ -425,7 +359,7 @@ class FreqtradeBot(object):
             return True
         return False
 
-    def execute_buy(self, pair: str, stake_amount: float) -> bool:
+    def execute_buy(self, pair: str, stake_amount: float, price: Optional[float] = None) -> bool:
         """
         Executes a limit buy for the given pair
         :param pair: pair for which we want to create a LIMIT_BUY
@@ -435,32 +369,75 @@ class FreqtradeBot(object):
         pair_url = self.exchange.get_pair_detail_url(pair)
         stake_currency = self.config['stake_currency']
         fiat_currency = self.config.get('fiat_display_currency', None)
+        time_in_force = self.strategy.order_time_in_force['buy']
 
-        # Calculate amount
-        buy_limit = self.get_target_bid(pair, self.exchange.get_ticker(pair))
+        if price:
+            buy_limit_requested = price
+        else:
+            # Calculate amount
+            buy_limit_requested = self.get_target_bid(pair)
 
-        min_stake_amount = self._get_min_pair_stake_amount(pair_s, buy_limit)
+        min_stake_amount = self._get_min_pair_stake_amount(pair_s, buy_limit_requested)
         if min_stake_amount is not None and min_stake_amount > stake_amount:
             logger.warning(
-                f'Can\'t open a new trade for {pair_s}: stake amount'
-                f' is too small ({stake_amount} < {min_stake_amount})'
+                f'Can\'t open a new trade for {pair_s}: stake amount '
+                f'is too small ({stake_amount} < {min_stake_amount})'
             )
             return False
 
-        amount = stake_amount / buy_limit
+        amount = stake_amount / buy_limit_requested
 
-        order_id = self.exchange.buy(pair, buy_limit, amount)['id']
+        order = self.exchange.buy(pair=pair, ordertype=self.strategy.order_types['buy'],
+                                  amount=amount, rate=buy_limit_requested,
+                                  time_in_force=time_in_force)
+        order_id = order['id']
+        order_status = order.get('status', None)
+
+        # we assume the order is executed at the price requested
+        buy_limit_filled_price = buy_limit_requested
+
+        if order_status == 'expired' or order_status == 'rejected':
+            order_type = self.strategy.order_types['buy']
+            order_tif = self.strategy.order_time_in_force['buy']
+
+            # return false if the order is not filled
+            if float(order['filled']) == 0:
+                logger.warning('Buy %s order with time in force %s for %s is %s by %s.'
+                               ' zero amount is fulfilled.',
+                               order_tif, order_type, pair_s, order_status, self.exchange.name)
+                return False
+            else:
+                # the order is partially fulfilled
+                # in case of IOC orders we can check immediately
+                # if the order is fulfilled fully or partially
+                logger.warning('Buy %s order with time in force %s for %s is %s by %s.'
+                               ' %s amount fulfilled out of %s (%s remaining which is canceled).',
+                               order_tif, order_type, pair_s, order_status, self.exchange.name,
+                               order['filled'], order['amount'], order['remaining']
+                               )
+                stake_amount = order['cost']
+                amount = order['amount']
+                buy_limit_filled_price = order['price']
+                order_id = None
+
+        # in case of FOK the order may be filled immediately and fully
+        elif order_status == 'closed':
+            stake_amount = order['cost']
+            amount = order['amount']
+            buy_limit_filled_price = order['price']
+            order_id = None
 
         self.rpc.send_msg({
             'type': RPCMessageType.BUY_NOTIFICATION,
             'exchange': self.exchange.name.capitalize(),
             'pair': pair_s,
             'market_url': pair_url,
-            'limit': buy_limit,
+            'limit': buy_limit_filled_price,
             'stake_amount': stake_amount,
             'stake_currency': stake_currency,
             'fiat_currency': fiat_currency
         })
+
         # Fee is applied twice because we make a LIMIT_BUY and LIMIT_SELL
         fee = self.exchange.get_fee(symbol=pair, taker_or_maker='maker')
         trade = Trade(
@@ -469,16 +446,21 @@ class FreqtradeBot(object):
             amount=amount,
             fee_open=fee,
             fee_close=fee,
-            open_rate=buy_limit,
-            open_rate_requested=buy_limit,
+            open_rate=buy_limit_filled_price,
+            open_rate_requested=buy_limit_requested,
             open_date=datetime.utcnow(),
             exchange=self.exchange.id,
             open_order_id=order_id,
             strategy=self.strategy.get_strategy_name(),
             ticker_interval=constants.TICKER_INTERVAL_MINUTES[self.config['ticker_interval']]
         )
+
         Trade.session.add(trade)
         Trade.session.flush()
+
+        # Updating wallets
+        self.wallets.update()
+
         return True
 
     def process_maybe_execute_buy(self) -> bool:
@@ -517,13 +499,26 @@ class FreqtradeBot(object):
                         trade.fee_open = 0
 
                 except OperationalException as exception:
-                    logger.warning("could not update trade amount: %s", exception)
+                    logger.warning("Could not update trade amount: %s", exception)
 
                 trade.update(order)
 
+            if self.strategy.order_types.get('stoploss_on_exchange') and trade.is_open:
+                result = self.handle_stoploss_on_exchange(trade)
+                if result:
+                    self.wallets.update()
+                    return result
+
             if trade.is_open and trade.open_order_id is None:
                 # Check if we can sell our current pair
-                return self.handle_trade(trade)
+                result = self.handle_trade(trade)
+
+                # Updating wallets if any trade occured
+                if result:
+                    self.wallets.update()
+
+                return result
+
         except DependencyException as exception:
             logger.warning('Unable to sell trade: %s', exception)
         return False
@@ -563,12 +558,12 @@ class FreqtradeBot(object):
                     fee_abs += exectrade['fee']['cost']
 
         if amount != order_amount:
-            logger.warning(f"amount {amount} does not match amount {trade.amount}")
+            logger.warning(f"Amount {amount} does not match amount {trade.amount}")
             raise OperationalException("Half bought? Amounts don't match")
         real_amount = amount - fee_abs
         if fee_abs != 0:
-            logger.info(f"""Applying fee on amount for {trade} \
-(from {order_amount} to {real_amount}) from Trades""")
+            logger.info(f"Applying fee on amount for {trade} "
+                        f"(from {order_amount} to {real_amount}) from Trades")
         return real_amount
 
     def handle_trade(self, trade: Trade) -> bool:
@@ -577,17 +572,16 @@ class FreqtradeBot(object):
         :return: True if trade has been sold, False otherwise
         """
         if not trade.is_open:
-            raise ValueError(f'attempt to handle closed trade: {trade}')
+            raise ValueError(f'Attempt to handle closed trade: {trade}')
 
         logger.debug('Handling %s ...', trade)
-        sell_rate = self.exchange.get_ticker(trade.pair)['bid']
 
         (buy, sell) = (False, False)
         experimental = self.config.get('experimental', {})
         if experimental.get('use_sell_signal') or experimental.get('ignore_roi_if_buy_signal'):
-            ticker = self.exchange.klines.get(trade.pair)
-            (buy, sell) = self.strategy.get_signal(trade.pair, self.strategy.ticker_interval,
-                                                   ticker)
+            (buy, sell) = self.strategy.get_signal(
+                trade.pair, self.strategy.ticker_interval,
+                self.dataprovider.ohlcv(trade.pair, self.strategy.ticker_interval))
 
         config_ask_strategy = self.config.get('ask_strategy', {})
         if config_ask_strategy.get('use_order_book', False):
@@ -600,29 +594,102 @@ class FreqtradeBot(object):
 
             for i in range(order_book_min, order_book_max + 1):
                 order_book_rate = order_book['asks'][i - 1][0]
-
-                # if orderbook has higher rate (high profit),
-                # use orderbook, otherwise just use bids rate
                 logger.info('  order book asks top %s: %0.8f', i, order_book_rate)
-                if sell_rate < order_book_rate:
-                    sell_rate = order_book_rate
+                sell_rate = order_book_rate
 
                 if self.check_sell(trade, sell_rate, buy, sell):
                     return True
-                    break
+
         else:
-            logger.info('checking sell')
+            logger.debug('checking sell')
+            sell_rate = self.exchange.get_ticker(trade.pair)['bid']
             if self.check_sell(trade, sell_rate, buy, sell):
                 return True
 
-        logger.info('Found no sell signals for whitelisted currencies. Trying again..')
+        logger.debug('Found no sell signal for %s.', trade)
         return False
 
+    def handle_stoploss_on_exchange(self, trade: Trade) -> bool:
+        """
+        Check if trade is fulfilled in which case the stoploss
+        on exchange should be added immediately if stoploss on exchange
+        is enabled.
+        """
+
+        result = False
+
+        # If trade is open and the buy order is fulfilled but there is no stoploss,
+        # then we add a stoploss on exchange
+        if not trade.open_order_id and not trade.stoploss_order_id:
+            if self.edge:
+                stoploss = self.edge.stoploss(pair=trade.pair)
+            else:
+                stoploss = self.strategy.stoploss
+
+            stop_price = trade.open_rate * (1 + stoploss)
+
+            # limit price should be less than stop price.
+            # 0.99 is arbitrary here.
+            limit_price = stop_price * 0.99
+
+            stoploss_order_id = self.exchange.stoploss_limit(
+                pair=trade.pair, amount=trade.amount, stop_price=stop_price, rate=limit_price
+            )['id']
+            trade.stoploss_order_id = str(stoploss_order_id)
+            trade.stoploss_last_update = datetime.now()
+
+        # Or the trade open and there is already a stoploss on exchange.
+        # so we check if it is hit ...
+        elif trade.stoploss_order_id:
+            logger.debug('Handling stoploss on exchange %s ...', trade)
+            order = self.exchange.get_order(trade.stoploss_order_id, trade.pair)
+            if order['status'] == 'closed':
+                trade.sell_reason = SellType.STOPLOSS_ON_EXCHANGE.value
+                trade.update(order)
+                result = True
+            elif self.config.get('trailing_stop', False):
+                # if trailing stoploss is enabled we check if stoploss value has changed
+                # in which case we cancel stoploss order and put another one with new
+                # value immediately
+                self.handle_trailing_stoploss_on_exchange(trade, order)
+
+        return result
+
+    def handle_trailing_stoploss_on_exchange(self, trade: Trade, order):
+        """
+        Check to see if stoploss on exchange should be updated
+        in case of trailing stoploss on exchange
+        :param Trade: Corresponding Trade
+        :param order: Current on exchange stoploss order
+        :return: None
+        """
+
+        if trade.stop_loss > float(order['info']['stopPrice']):
+            # we check if the update is neccesary
+            update_beat = self.strategy.order_types.get('stoploss_on_exchange_interval', 60)
+            if (datetime.utcnow() - trade.stoploss_last_update).total_seconds() > update_beat:
+                # cancelling the current stoploss on exchange first
+                logger.info('Trailing stoploss: cancelling current stoploss on exchange '
+                            'in order to add another one ...')
+                if self.exchange.cancel_order(order['id'], trade.pair):
+                    # creating the new one
+                    stoploss_order_id = self.exchange.stoploss_limit(
+                        pair=trade.pair, amount=trade.amount,
+                        stop_price=trade.stop_loss, rate=trade.stop_loss * 0.99
+                    )['id']
+                    trade.stoploss_order_id = str(stoploss_order_id)
+
     def check_sell(self, trade: Trade, sell_rate: float, buy: bool, sell: bool) -> bool:
-        should_sell = self.strategy.should_sell(trade, sell_rate, datetime.utcnow(), buy, sell)
+        if self.edge:
+            stoploss = self.edge.stoploss(trade.pair)
+            should_sell = self.strategy.should_sell(
+                trade, sell_rate, datetime.utcnow(), buy, sell, force_stoploss=stoploss)
+        else:
+            should_sell = self.strategy.should_sell(trade, sell_rate, datetime.utcnow(), buy, sell)
+
         if should_sell.sell_flag:
             self.execute_sell(trade, sell_rate, should_sell.sell_type)
-            logger.info('excuted sell')
+            logger.info('executed sell, reason: %s', should_sell.sell_type)
             return True
         return False
 
@@ -655,34 +722,44 @@ class FreqtradeBot(object):
             ordertime = arrow.get(order['datetime']).datetime
 
             # Check if trade is still actually open
-            if int(order['remaining']) == 0:
+            if float(order['remaining']) == 0.0:
+                self.wallets.update()
                 continue
 
-            # Check if trade is still actually open
-            if order['status'] == 'open':
+            # Handle cancelled on exchange
+            if order['status'] == 'canceled':
+                if order['side'] == 'buy':
+                    self.handle_buy_order_full_cancel(trade, "canceled on Exchange")
+                elif order['side'] == 'sell':
+                    self.handle_timedout_limit_sell(trade, order)
+                    self.wallets.update()
+            # Check if order is still actually open
+            elif order['status'] == 'open':
                 if order['side'] == 'buy' and ordertime < buy_timeoutthreashold:
                     self.handle_timedout_limit_buy(trade, order)
+                    self.wallets.update()
                 elif order['side'] == 'sell' and ordertime < sell_timeoutthreashold:
                     self.handle_timedout_limit_sell(trade, order)
+                    self.wallets.update()
+
+    def handle_buy_order_full_cancel(self, trade: Trade, reason: str) -> None:
+        """Close trade in database and send message"""
+        Trade.session.delete(trade)
+        Trade.session.flush()
+        logger.info('Buy order %s for %s.', reason, trade)
+        self.rpc.send_msg({
+            'type': RPCMessageType.STATUS_NOTIFICATION,
+            'status': f'Unfilled buy order for {trade.pair} {reason}'
+        })
 
-    # FIX: 20180110, why is cancel.order unconditionally here, whereas
-    #                it is conditionally called in the
-    #                handle_timedout_limit_sell()?
     def handle_timedout_limit_buy(self, trade: Trade, order: Dict) -> bool:
         """Buy timeout - cancel order
         :return: True if order was fully cancelled
         """
-        pair_s = trade.pair.replace('_', '/')
         self.exchange.cancel_order(trade.open_order_id, trade.pair)
         if order['remaining'] == order['amount']:
             # if trade is not partially completed, just delete the trade
-            Trade.session.delete(trade)
-            Trade.session.flush()
-            logger.info('Buy order timeout for %s.', trade)
-            self.rpc.send_msg({
-                'type': RPCMessageType.STATUS_NOTIFICATION,
-                'status': f'Unfilled buy order for {pair_s} cancelled due to timeout'
-            })
+            self.handle_buy_order_full_cancel(trade, "cancelled due to timeout")
             return True
 
         # if trade is partially complete, edit the stake details for the trade
@@ -693,20 +770,24 @@ class FreqtradeBot(object):
         logger.info('Partial buy order timeout for %s.', trade)
         self.rpc.send_msg({
             'type': RPCMessageType.STATUS_NOTIFICATION,
-            'status': f'Remaining buy order for {pair_s} cancelled due to timeout'
+            'status': f'Remaining buy order for {trade.pair} cancelled due to timeout'
         })
         return False
 
-    # FIX: 20180110, should cancel_order() be cond. or unconditionally called?
     def handle_timedout_limit_sell(self, trade: Trade, order: Dict) -> bool:
         """
         Sell timeout - cancel order and update trade
         :return: True if order was fully cancelled
         """
-        pair_s = trade.pair.replace('_', '/')
         if order['remaining'] == order['amount']:
             # if trade is not partially completed, just cancel the trade
-            self.exchange.cancel_order(trade.open_order_id, trade.pair)
+            if order["status"] != "canceled":
+                reason = "due to timeout"
+                self.exchange.cancel_order(trade.open_order_id, trade.pair)
+                logger.info('Sell order timeout for %s.', trade)
+            else:
+                reason = "on exchange"
+                logger.info('Sell order canceled on exchange for %s.', trade)
             trade.close_rate = None
             trade.close_profit = None
             trade.close_date = None
@@ -714,9 +795,9 @@ class FreqtradeBot(object):
             trade.open_order_id = None
             self.rpc.send_msg({
                 'type': RPCMessageType.STATUS_NOTIFICATION,
-                'status': f'Unfilled sell order for {pair_s} cancelled due to timeout'
+                'status': f'Unfilled sell order for {trade.pair} cancelled {reason}'
             })
-            logger.info('Sell order timeout for %s.', trade)
+
             return True
 
         # TODO: figure out how to handle partially complete sell orders
@@ -730,8 +811,27 @@ class FreqtradeBot(object):
         :param sellreason: Reason the sell was triggered
         :return: None
         """
+        sell_type = 'sell'
+        if sell_reason in (SellType.STOP_LOSS, SellType.TRAILING_STOP_LOSS):
+            sell_type = 'stoploss'
+
+        # if stoploss is on exchange and we are on dry_run mode,
+        # we consider the sell price stop price
+        if self.config.get('dry_run', False) and sell_type == 'stoploss' \
+           and self.strategy.order_types['stoploss_on_exchange']:
+            limit = trade.stop_loss
+
+        # First cancelling stoploss on exchange ...
+        if self.strategy.order_types.get('stoploss_on_exchange') and trade.stoploss_order_id:
+            self.exchange.cancel_order(trade.stoploss_order_id, trade.pair)
+
         # Execute sell and update trade record
-        order_id = self.exchange.sell(str(trade.pair), limit, trade.amount)['id']
+        order_id = self.exchange.sell(pair=str(trade.pair),
+                                      ordertype=self.strategy.order_types[sell_type],
+                                      amount=trade.amount, rate=limit,
+                                      time_in_force=self.strategy.order_time_in_force['sell']
+                                      )['id']
+
         trade.open_order_id = order_id
         trade.close_rate_requested = limit
         trade.sell_reason = sell_reason.value
@@ -754,6 +854,7 @@ class FreqtradeBot(object):
             'current_rate': current_rate,
             'profit_amount': profit_trade,
             'profit_percent': profit_percent,
+            'sell_reason': sell_reason.value
         }
 
         # For regular case, when the configuration exists

freqtrade/main.py

@@ -25,7 +25,7 @@ def main(sysargv: List[str]) -> None:
     """
     arguments = Arguments(
         sysargv,
-        'Simple High Frequency Trading Bot for crypto currencies'
+        'Free, open source crypto trading bot'
     )
     args = arguments.get_parsed_arg()
 
@@ -39,13 +39,13 @@ def main(sysargv: List[str]) -> None:
     return_code = 1
     try:
         # Load and validate configuration
-        config = Configuration(args).get_config()
+        config = Configuration(args, None).get_config()
 
         # Init the bot
         freqtrade = FreqtradeBot(config)
 
         state = None
-        while 1:
+        while True:
             state = freqtrade.worker(old_state=state)
             if state == State.RELOAD_CONF:
                 freqtrade = reconfigure(freqtrade, args)
@@ -76,7 +76,7 @@ def reconfigure(freqtrade: FreqtradeBot, args: Namespace) -> FreqtradeBot:
     freqtrade.cleanup()
 
     # Create new instance
-    freqtrade = FreqtradeBot(Configuration(args).get_config())
+    freqtrade = FreqtradeBot(Configuration(args, None).get_config())
     freqtrade.rpc.send_msg({
         'type': RPCMessageType.STATUS_NOTIFICATION,
         'status': 'config reloaded'

freqtrade/misc.py

@@ -3,7 +3,6 @@ Various tool function for Freqtrade and scripts
 """
 
 import gzip
-import json
 import logging
 import re
 from datetime import datetime
@@ -11,6 +10,7 @@ from typing import Dict
 
 import numpy as np
 from pandas import DataFrame
+import rapidjson
 
 logger = logging.getLogger(__name__)
 
@@ -38,12 +38,7 @@ def datesarray_to_datetimearray(dates: np.ndarray) -> np.ndarray:
     An numpy-array of datetimes
     :return: numpy-array of datetime
     """
-    times = []
-    dates = dates.astype(datetime)
-    for index in range(0, dates.size):
-        date = dates[index].to_pydatetime()
-        times.append(date)
-    return np.array(times)
+    return dates.dt.to_pydatetime()
 
 
 def common_datearray(dfs: Dict[str, DataFrame]) -> np.ndarray:
@@ -71,16 +66,45 @@ def file_dump_json(filename, data, is_zip=False) -> None:
     :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'):
             filename = filename + '.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):
+    """
+    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:

freqtrade/optimize/__init__.py

@@ -1,245 +1,49 @@
 # pragma pylint: disable=missing-docstring
 
-import gzip
-try:
-    import ujson as json
-    _UJSON = True
-except ImportError:
-    # see mypy/issues/1153
-    import json  # type: ignore
-    _UJSON = False
 import logging
-import os
-from typing import Optional, List, Dict, Tuple, Any
-import arrow
+from datetime import datetime
+from typing import Dict, Tuple
+import operator
 
-from freqtrade import misc, constants, OperationalException
-from freqtrade.exchange import Exchange
-from freqtrade.arguments import TimeRange
+import arrow
+from pandas import DataFrame
+
+from freqtrade.optimize.default_hyperopt import DefaultHyperOpts  # noqa: F401
 
 logger = logging.getLogger(__name__)
 
 
-def json_load(data):
-    """Try to load data with ujson"""
-    if _UJSON:
-        return json.load(data, precise_float=True)
-    else:
-        return json.load(data)
-
-
-def trim_tickerlist(tickerlist: List[Dict], timerange: TimeRange) -> List[Dict]:
-    if not tickerlist:
-        return tickerlist
-
-    start_index = 0
-    stop_index = len(tickerlist)
-
-    if timerange.starttype == 'line':
-        stop_index = timerange.startts
-    if timerange.starttype == 'index':
-        start_index = timerange.startts
-    elif timerange.starttype == 'date':
-        while (start_index < len(tickerlist) and
-               tickerlist[start_index][0] < timerange.startts * 1000):
-            start_index += 1
-
-    if timerange.stoptype == 'line':
-        start_index = len(tickerlist) + timerange.stopts
-    if timerange.stoptype == 'index':
-        stop_index = timerange.stopts
-    elif timerange.stoptype == 'date':
-        while (stop_index > 0 and
-               tickerlist[stop_index-1][0] > timerange.stopts * 1000):
-            stop_index -= 1
-
-    if start_index > stop_index:
-        raise ValueError(f'The timerange [{timerange.startts},{timerange.stopts}] is incorrect')
-
-    return tickerlist[start_index:stop_index]
-
-
-def load_tickerdata_file(
-        datadir: str, pair: str,
-        ticker_interval: str,
-        timerange: Optional[TimeRange] = None) -> Optional[List[Dict]]:
+def get_timeframe(data: Dict[str, DataFrame]) -> Tuple[arrow.Arrow, arrow.Arrow]:
     """
-    Load a pair from file,
-    :return dict OR empty if unsuccesful
+    Get the maximum timeframe for the given backtest data
+    :param data: dictionary with preprocessed backtesting data
+    :return: tuple containing min_date, max_date
     """
-    path = make_testdata_path(datadir)
-    pair_s = pair.replace('/', '_')
-    file = os.path.join(path, f'{pair_s}-{ticker_interval}.json')
-    gzipfile = file + '.gz'
-
-    # If the file does not exist we download it when None is returned.
-    # If file exists, read the file, load the json
-    if os.path.isfile(gzipfile):
-        logger.debug('Loading ticker data from file %s', gzipfile)
-        with gzip.open(gzipfile) as tickerdata:
-            pairdata = json.load(tickerdata)
-    elif os.path.isfile(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
+    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 load_data(datadir: str,
-              ticker_interval: str,
-              pairs: List[str],
-              refresh_pairs: Optional[bool] = False,
-              exchange: Optional[Exchange] = None,
-              timerange: TimeRange = TimeRange(None, None, 0, 0)) -> Dict[str, List]:
+def validate_backtest_data(data: Dict[str, DataFrame], min_date: datetime,
+                           max_date: datetime, ticker_interval_mins: int) -> bool:
     """
-    Loads ticker history data for the given parameters
-    :return: dict
+    Validates preprocessed backtesting data for missing values and shows warnings about it that.
+
+    :param data: dictionary with preprocessed backtesting data
+    :param min_date: start-date of the data
+    :param max_date: end-date of the data
+    :param ticker_interval_mins: ticker interval in minutes
     """
-    result = {}
-
-    # If the user force the refresh of pairs
-    if refresh_pairs:
-        logger.info('Download data for all pairs and store them in %s', datadir)
-        if not exchange:
-            raise OperationalException("Exchange needs to be initialized when "
-                                       "calling load_data with refresh_pairs=True")
-        download_pairs(datadir, exchange, pairs, ticker_interval, timerange=timerange)
-
-    for pair in pairs:
-        pairdata = load_tickerdata_file(datadir, pair, ticker_interval, timerange=timerange)
-        if pairdata:
-            result[pair] = pairdata
-        else:
-            logger.warning(
-                'No data for pair: "%s", Interval: %s. '
-                'Use --refresh-pairs-cached to download the data',
-                pair,
-                ticker_interval
-            )
-
-    return result
-
-
-def make_testdata_path(datadir: str) -> str:
-    """Return the path where testdata files are stored"""
-    return datadir or os.path.abspath(
-        os.path.join(
-            os.path.dirname(__file__), '..', 'tests', 'testdata'
-        )
-    )
-
-
-def download_pairs(datadir, exchange: Exchange, pairs: List[str],
-                   ticker_interval: str,
-                   timerange: TimeRange = TimeRange(None, None, 0, 0)) -> bool:
-    """For each pairs passed in parameters, download the ticker intervals"""
-    for pair in pairs:
-        try:
-            download_backtesting_testdata(datadir,
-                                          exchange=exchange,
-                                          pair=pair,
-                                          tick_interval=ticker_interval,
-                                          timerange=timerange)
-        except BaseException:
-            logger.info(
-                'Failed to download the pair: "%s", Interval: %s',
-                pair,
-                ticker_interval
-            )
-            return False
-    return True
-
-
-def load_cached_data_for_updating(filename: str,
-                                  tick_interval: str,
-                                  timerange: Optional[TimeRange]) -> Tuple[
-                                                                                  List[Any],
-                                                                                  Optional[int]]:
-    """
-    Load cached data and choose what part of the data should be updated
-    """
-
-    since_ms = None
-
-    # user sets timerange, so find the start time
-    if timerange:
-        if timerange.starttype == 'date':
-            since_ms = timerange.startts * 1000
-        elif timerange.stoptype == 'line':
-            num_minutes = timerange.stopts * constants.TICKER_INTERVAL_MINUTES[tick_interval]
-            since_ms = arrow.utcnow().shift(minutes=num_minutes).timestamp * 1000
-
-    # read the cached file
-    if os.path.isfile(filename):
-        with open(filename, "rt") as file:
-            data = json_load(file)
-            # remove the last item, because we are not sure if it is correct
-            # it could be fetched when the candle was incompleted
-            if data:
-                data.pop()
-    else:
-        data = []
-
-    if data:
-        if since_ms and since_ms < data[0][0]:
-            # the data is requested for earlier period than the cache has
-            # so fully redownload all the data
-            data = []
-        else:
-            # a part of the data was already downloaded, so
-            # download unexist data only
-            since_ms = data[-1][0] + 1
-
-    return (data, since_ms)
-
-
-def download_backtesting_testdata(datadir: str,
-                                  exchange: Exchange,
-                                  pair: str,
-                                  tick_interval: str = '5m',
-                                  timerange: Optional[TimeRange] = None) -> None:
-
-    """
-    Download the latest ticker intervals from the exchange for the pair passed in parameters
-    The data is downloaded starting from the last correct ticker interval data that
-    exists in a cache. If timerange starts earlier than the data in the cache,
-    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 timerange: range of time to download
-    :return: None
-
-    """
-    path = make_testdata_path(datadir)
-    filepair = pair.replace("/", "_")
-    filename = os.path.join(path, f'{filepair}-{tick_interval}.json')
-
-    logger.info(
-        'Download the pair: "%s", Interval: %s',
-        pair,
-        tick_interval
-    )
-
-    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,
-                                    since_ms=since_ms if since_ms
-                                    else
-                                    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)
+    # total difference in minutes / interval-minutes
+    expected_frames = int((max_date - min_date).total_seconds() // 60 // ticker_interval_mins)
+    found_missing = False
+    for pair, df in data.items():
+        dflen = len(df)
+        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/optimize/backtesting.py

@@ -4,26 +4,26 @@
 This module contains the backtesting logic
 """
 import logging
-import operator
 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, Tuple
+from typing import Any, Dict, List, NamedTuple, Optional
 
-import arrow
 from pandas import DataFrame
 from tabulate import tabulate
 
-import freqtrade.optimize as optimize
+from freqtrade import optimize
 from freqtrade import DependencyException, constants
 from freqtrade.arguments import Arguments
 from freqtrade.configuration import Configuration
 from freqtrade.exchange import Exchange
+from freqtrade.data import history
 from freqtrade.misc import file_dump_json
 from freqtrade.persistence import Trade
-from freqtrade.strategy.interface import SellType
-from freqtrade.strategy.resolver import IStrategy, StrategyResolver
+from freqtrade.resolvers import StrategyResolver
+from freqtrade.state import RunMode
+from freqtrade.strategy.interface import SellType, IStrategy
 
 logger = logging.getLogger(__name__)
 
@@ -68,6 +68,7 @@ class Backtesting(object):
         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
@@ -88,24 +89,11 @@ class Backtesting(object):
         """
         self.strategy = strategy
         self.ticker_interval = self.config.get('ticker_interval')
+        self.ticker_interval_mins = constants.TICKER_INTERVAL_MINUTES[self.ticker_interval]
         self.tickerdata_to_dataframe = strategy.tickerdata_to_dataframe
         self.advise_buy = strategy.advise_buy
         self.advise_sell = strategy.advise_sell
 
-    @staticmethod
-    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 _generate_text_table(self, data: Dict[str, Dict], results: DataFrame,
                              skip_nan: bool = False) -> str:
         """
@@ -113,11 +101,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():
@@ -129,6 +119,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]),
@@ -142,12 +133,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:
         """
@@ -164,11 +158,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,
@@ -176,12 +172,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 _store_backtest_result(self, recordfilename: str, results: DataFrame,
                                strategyname: Optional[str] = None) -> None:
@@ -223,21 +222,38 @@ class Backtesting(object):
 
             buy_signal = sell_row.buy
             sell = self.strategy.should_sell(trade, sell_row.open, sell_row.date, buy_signal,
-                                             sell_row.sell)
+                                             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 next entry in min_roi > to trade duration
+                    # Interface.py skips on trade_duration <= duration
+                    roi_entry = max(list(filter(lambda x: trade_dur >= x,
+                                                self.strategy.minimal_roi.keys())))
+                    roi = self.strategy.minimal_roi[roi_entry]
+
+                    # - (Expected abs profit + open_rate + open_fee) / (fee_close -1)
+                    closerate = - (trade.open_rate * roi + trade.open_rate *
+                                   (1 + trade.fee_open)) / (trade.fee_close - 1)
+                else:
+                    closerate = sell_row.open
+
                 return BacktestResult(pair=pair,
-                                      profit_percent=trade.calc_profit_percent(rate=sell_row.open),
-                                      profit_abs=trade.calc_profit(rate=sell_row.open),
+                                      profit_percent=trade.calc_profit_percent(rate=closerate),
+                                      profit_abs=trade.calc_profit(rate=closerate),
                                       open_time=buy_row.date,
                                       close_time=sell_row.date,
-                                      trade_duration=int((
-                                          sell_row.date - buy_row.date).total_seconds() // 60),
+                                      trade_duration=trade_dur,
                                       open_index=buy_row.Index,
                                       close_index=sell_row.Index,
                                       open_at_end=False,
                                       open_rate=buy_row.open,
-                                      close_rate=sell_row.open,
+                                      close_rate=closerate,
                                       sell_reason=sell.sell_type
                                       )
         if partial_ticker:
@@ -277,12 +293,17 @@ class Backtesting(object):
             position_stacking: do we allow position stacking? (default: False)
         :return: DataFrame
         """
-        headers = ['date', 'buy', 'open', 'close', 'sell']
+        headers = ['date', 'buy', 'open', 'close', 'sell', 'low', 'high']
         processed = args['processed']
         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
 
@@ -297,15 +318,28 @@ class Backtesting(object):
 
             # Convert from Pandas to list for performance reasons
             # (Looping Pandas is slow.)
-            ticker = [x for x in ticker_data.itertuples()]
+            ticker[pair] = [x for x in ticker_data.itertuples()]
+            pairs.append(pair)
+
+        lock_pair_until: Dict = {}
+        tmp = start_date + timedelta(minutes=self.ticker_interval_mins)
+        index = 0
+        # Loop timerange and test per pair
+        while tmp < end_date:
+            # print(f"time: {tmp}")
+            for i, pair in enumerate(ticker):
+                try:
+                    row = ticker[pair][index]
+                except IndexError:
+                    # missing Data for one pair ...
+                    # Warnings for this are shown by `validate_backtest_data`
+                    continue
 
-            lock_pair_until = None
-            for index, row in enumerate(ticker):
                 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 lock_pair_until is not None and row.date <= lock_pair_until:
+                    if pair in lock_pair_until and row.date <= lock_pair_until[pair]:
                         continue
                 if max_open_trades > 0:
                     # Check if max_open_trades has already been reached for the given date
@@ -314,17 +348,19 @@ class Backtesting(object):
 
                     trade_count_lock[row.date] = trade_count_lock.get(row.date, 0) + 1
 
-                trade_entry = self._get_sell_trade_entry(pair, row, ticker[index + 1:],
+                trade_entry = self._get_sell_trade_entry(pair, row, ticker[pair][index + 1:],
                                                          trade_count_lock, args)
 
                 if trade_entry:
-                    lock_pair_until = trade_entry.close_time
+                    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 = ticker_data.iloc[-1].date
+                    lock_pair_until[pair] = end_date
 
+            tmp += timedelta(minutes=self.ticker_interval_mins)
+            index += 1
         return DataFrame.from_records(trades, columns=BacktestResult._fields)
 
     def start(self) -> None:
@@ -339,15 +375,16 @@ class Backtesting(object):
 
         if self.config.get('live'):
             logger.info('Downloading data for all pairs in whitelist ...')
-            self.exchange.refresh_tickers(pairs, self.ticker_interval)
-            data = self.exchange.klines
+            self.exchange.refresh_latest_ohlcv([(pair, self.ticker_interval) for pair in pairs])
+            data = {key[0]: value for key, value in self.exchange._klines.items()}
+
         else:
             logger.info('Using local backtesting data (using whitelist in given config) ...')
 
             timerange = Arguments.parse_timerange(None if self.config.get(
                 'timerange') is None else str(self.config.get('timerange')))
-            data = optimize.load_data(
-                self.config['datadir'],
+            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),
@@ -370,17 +407,18 @@ class Backtesting(object):
             logger.info("Running backtesting for Strategy %s", strat.get_strategy_name())
             self._set_strategy(strat)
 
-            # need to reprocess data every time to populate signals
-            preprocessed = self.tickerdata_to_dataframe(data)
-
-            # Print timeframe
-            min_date, max_date = self.get_timeframe(preprocessed)
+            min_date, max_date = optimize.get_timeframe(data)
+            # Validate dataframe for missing values (mainly at start and end, as fillup is called)
+            optimize.validate_backtest_data(data, 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
             )
+            # need to reprocess data every time to populate signals
+            preprocessed = self.strategy.tickerdata_to_dataframe(data)
 
             # Execute backtest and print results
             all_results[self.strategy.get_strategy_name()] = self.backtest(
@@ -389,6 +427,8 @@ class Backtesting(object):
                     'processed': preprocessed,
                     'max_open_trades': max_open_trades,
                     'position_stacking': self.config.get('position_stacking', False),
+                    'start_date': min_date,
+                    'end_date': max_date,
                 }
             )
 
@@ -399,18 +439,18 @@ class Backtesting(object):
                                             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')
 
@@ -421,7 +461,7 @@ def setup_configuration(args: Namespace) -> Dict[str, Any]:
     :param args: Cli args from Arguments()
     :return: Configuration
     """
-    configuration = Configuration(args)
+    configuration = Configuration(args, RunMode.BACKTEST)
     config = configuration.get_config()
 
     # Ensure we do not use Exchange credentials

freqtrade/optimize/default_hyperopt.py

@@ -0,0 +1,226 @@
+# pragma pylint: disable=missing-docstring, invalid-name, pointless-string-statement
+
+import talib.abstract as ta
+from pandas import DataFrame
+from typing import Dict, Any, Callable, List
+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.
+    You can override it with your own hyperopt
+    """
+
+    @staticmethod
+    def populate_indicators(dataframe: DataFrame, metadata: dict) -> DataFrame:
+        dataframe['adx'] = ta.ADX(dataframe)
+        macd = ta.MACD(dataframe)
+        dataframe['macd'] = macd['macd']
+        dataframe['macdsignal'] = macd['macdsignal']
+        dataframe['mfi'] = ta.MFI(dataframe)
+        dataframe['rsi'] = ta.RSI(dataframe)
+        stoch_fast = ta.STOCHF(dataframe)
+        dataframe['fastd'] = stoch_fast['fastd']
+        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']
+        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
+        """
+        def populate_buy_trend(dataframe: DataFrame, metadata: dict) -> DataFrame:
+            """
+            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'])
+            if 'fastd-enabled' in params and params['fastd-enabled']:
+                conditions.append(dataframe['fastd'] < params['fastd-value'])
+            if 'adx-enabled' in params and params['adx-enabled']:
+                conditions.append(dataframe['adx'] > params['adx-value'])
+            if 'rsi-enabled' in params and params['rsi-enabled']:
+                conditions.append(dataframe['rsi'] < params['rsi-value'])
+
+            # TRIGGERS
+            if 'trigger' in params:
+                if params['trigger'] == 'bb_lower':
+                    conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
+                if params['trigger'] == 'macd_cross_signal':
+                    conditions.append(qtpylib.crossed_above(
+                        dataframe['macd'], dataframe['macdsignal']
+                    ))
+                if params['trigger'] == 'sar_reversal':
+                    conditions.append(qtpylib.crossed_above(
+                        dataframe['close'], dataframe['sar']
+                    ))
+
+            dataframe.loc[
+                reduce(lambda x, y: x & y, conditions),
+                'buy'] = 1
+
+            return dataframe
+
+        return populate_buy_trend
+
+    @staticmethod
+    def indicator_space() -> List[Dimension]:
+        """
+        Define your Hyperopt space for searching strategy parameters
+        """
+        return [
+            Integer(10, 25, name='mfi-value'),
+            Integer(15, 45, name='fastd-value'),
+            Integer(20, 50, name='adx-value'),
+            Integer(20, 40, name='rsi-value'),
+            Categorical([True, False], name='mfi-enabled'),
+            Categorical([True, False], name='fastd-enabled'),
+            Categorical([True, False], name='adx-enabled'),
+            Categorical([True, False], name='rsi-enabled'),
+            Categorical(['bb_lower', 'macd_cross_signal', 'sar_reversal'], name='trigger')
+        ]
+
+    @staticmethod
+    def sell_strategy_generator(params: Dict[str, Any]) -> Callable:
+        """
+        Define the sell strategy parameters to be used by hyperopt
+        """
+        def populate_sell_trend(dataframe: DataFrame, metadata: dict) -> DataFrame:
+            """
+            Sell strategy Hyperopt will build and use
+            """
+            # print(params)
+            conditions = []
+            # 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']
+                    ))
+
+            dataframe.loc[
+                reduce(lambda x, y: x & y, conditions),
+                'sell'] = 1
+
+            return dataframe
+
+        return populate_sell_trend
+
+    @staticmethod
+    def sell_indicator_space() -> List[Dimension]:
+        """
+        Define your Hyperopt space for searching sell strategy parameters
+        """
+        return [
+            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 generate_roi_table(params: Dict) -> Dict[int, float]:
+        """
+        Generate the ROI table that will be used by Hyperopt
+        """
+        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
+    def stoploss_space() -> List[Dimension]:
+        """
+        Stoploss Value to search
+        """
+        return [
+            Real(-0.5, -0.02, name='stoploss'),
+        ]
+
+    @staticmethod
+    def roi_space() -> List[Dimension]:
+        """
+        Values to search for each ROI steps
+        """
+        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'),
+        ]
+
+    def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        """
+        Based on TA indicators. Should be a copy of from strategy
+        must align to populate_indicators in this file
+        Only used when --spaces does not include buy
+        """
+        dataframe.loc[
+            (
+                (dataframe['close'] < dataframe['bb_lowerband']) &
+                (dataframe['mfi'] < 16) &
+                (dataframe['adx'] > 25) &
+                (dataframe['rsi'] < 21)
+            ),
+            'buy'] = 1
+
+        return dataframe
+
+    def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        """
+        Based on TA indicators. Should be a copy of from strategy
+        must align to populate_indicators in this file
+        Only used when --spaces does not include sell
+        """
+        dataframe.loc[
+            (
+                (qtpylib.crossed_above(
+                    dataframe['macdsignal'], dataframe['macd']
+                )) &
+                (dataframe['fastd'] > 54)
+            ),
+            'sell'] = 1
+        return dataframe

freqtrade/optimize/edge_cli.py

@@ -0,0 +1,109 @@
+# pragma pylint: disable=missing-docstring, W0212, too-many-arguments
+
+"""
+This module contains the edge backtesting interface
+"""
+import logging
+from argparse import Namespace
+from typing import Dict, Any
+from tabulate import tabulate
+from freqtrade.edge import Edge
+
+from freqtrade.arguments import Arguments
+from freqtrade.configuration import Configuration
+from freqtrade.exchange import Exchange
+from freqtrade.resolvers import StrategyResolver
+from freqtrade.state import RunMode
+
+logger = logging.getLogger(__name__)
+
+
+class EdgeCli(object):
+    """
+    EdgeCli class, this class contains all the logic to run edge backtesting
+
+    To run a edge backtest:
+    edge = EdgeCli(config)
+    edge.start()
+    """
+
+    def __init__(self, config: Dict[str, Any]) -> None:
+        self.config = config
+
+        # Reset keys for edge
+        self.config['exchange']['key'] = ''
+        self.config['exchange']['secret'] = ''
+        self.config['exchange']['password'] = ''
+        self.config['exchange']['uid'] = ''
+        self.config['dry_run'] = True
+        self.exchange = Exchange(self.config)
+        self.strategy = StrategyResolver(self.config).strategy
+
+        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(
+            'timerange') is None else str(self.config.get('timerange')))
+
+        self.edge._timerange = self.timerange
+
+    def _generate_edge_table(self, results: dict) -> str:
+
+        floatfmt = ('s', '.10g', '.2f', '.2f', '.2f', '.2f', 'd', '.d')
+        tabular_data = []
+        headers = ['pair', 'stoploss', 'win rate', 'risk reward ratio',
+                   'required risk reward', 'expectancy', 'total number of trades',
+                   'average duration (min)']
+
+        for result in results.items():
+            if result[1].nb_trades > 0:
+                tabular_data.append([
+                    result[0],
+                    result[1].stoploss,
+                    result[1].winrate,
+                    result[1].risk_reward_ratio,
+                    result[1].required_risk_reward,
+                    result[1].expectancy,
+                    result[1].nb_trades,
+                    round(result[1].avg_trade_duration)
+                ])
+
+        # 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()
+        print('')  # blank like 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, RunMode.EDGECLI)
+    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

@@ -9,22 +9,24 @@ import multiprocessing
 import os
 import sys
 from argparse import Namespace
-from functools import reduce
 from math import exp
 from operator import itemgetter
-from typing import Any, Callable, Dict, List
+from pathlib import Path
+from pprint import pprint
+from typing import Any, Dict, List
 
-import talib.abstract as ta
+from joblib import Parallel, delayed, dump, load, wrap_non_picklable_objects
 from pandas import DataFrame
-from sklearn.externals.joblib import Parallel, delayed, dump, load
 from skopt import Optimizer
-from skopt.space import Categorical, Dimension, Integer, Real
+from skopt.space import Dimension
 
-import freqtrade.vendor.qtpylib.indicators as qtpylib
 from freqtrade.arguments import Arguments
 from freqtrade.configuration import Configuration
-from freqtrade.optimize import load_data
+from freqtrade.data.history import load_data
+from freqtrade.optimize import get_timeframe
 from freqtrade.optimize.backtesting import Backtesting
+from freqtrade.state import RunMode
+from freqtrade.resolvers import HyperOptResolver
 
 logger = logging.getLogger(__name__)
 
@@ -42,6 +44,9 @@ class Hyperopt(Backtesting):
     """
     def __init__(self, config: Dict[str, Any]) -> None:
         super().__init__(config)
+        self.config = config
+        self.custom_hyperopt = HyperOptResolver(self.config).hyperopt
+
         # set TARGET_TRADES to suit your number concurrent trades so its realistic
         # to the number of days
         self.target_trades = 600
@@ -74,24 +79,6 @@ class Hyperopt(Backtesting):
         arg_dict = {dim.name: value for dim, value in zip(dimensions, params)}
         return arg_dict
 
-    @staticmethod
-    def populate_indicators(dataframe: DataFrame, metadata: dict) -> DataFrame:
-        dataframe['adx'] = ta.ADX(dataframe)
-        macd = ta.MACD(dataframe)
-        dataframe['macd'] = macd['macd']
-        dataframe['macdsignal'] = macd['macdsignal']
-        dataframe['mfi'] = ta.MFI(dataframe)
-        dataframe['rsi'] = ta.RSI(dataframe)
-        stoch_fast = ta.STOCHF(dataframe)
-        dataframe['fastd'] = stoch_fast['fastd']
-        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['sar'] = ta.SAR(dataframe)
-
-        return dataframe
-
     def save_trials(self) -> None:
         """
         Save hyperopt trials to file
@@ -116,12 +103,13 @@ class Hyperopt(Backtesting):
         results = sorted(self.trials, key=itemgetter('loss'))
         best_result = results[0]
         logger.info(
-            'Best result:\n%s\nwith values:\n%s',
-            best_result['result'],
-            best_result['params']
+            'Best result:\n%s\nwith values:\n',
+            best_result['result']
         )
+        pprint(best_result['params'], indent=4)
         if 'roi_t1' in best_result['params']:
-            logger.info('ROI table:\n%s', self.generate_roi_table(best_result['params']))
+            logger.info('ROI table:')
+            pprint(self.custom_hyperopt.generate_roi_table(best_result['params']), indent=4)
 
     def log_results(self, results) -> None:
         """
@@ -149,59 +137,6 @@ class Hyperopt(Backtesting):
         result = trade_loss + profit_loss + duration_loss
         return result
 
-    @staticmethod
-    def generate_roi_table(params: Dict) -> Dict[int, float]:
-        """
-        Generate the ROI table that will be used by Hyperopt
-        """
-        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
-    def roi_space() -> List[Dimension]:
-        """
-        Values to search for each ROI steps
-        """
-        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'),
-        ]
-
-    @staticmethod
-    def stoploss_space() -> List[Dimension]:
-        """
-        Stoploss search space
-        """
-        return [
-            Real(-0.5, -0.02, name='stoploss'),
-        ]
-
-    @staticmethod
-    def indicator_space() -> List[Dimension]:
-        """
-        Define your Hyperopt space for searching strategy parameters
-        """
-        return [
-            Integer(10, 25, name='mfi-value'),
-            Integer(15, 45, name='fastd-value'),
-            Integer(20, 50, name='adx-value'),
-            Integer(20, 40, name='rsi-value'),
-            Categorical([True, False], name='mfi-enabled'),
-            Categorical([True, False], name='fastd-enabled'),
-            Categorical([True, False], name='adx-enabled'),
-            Categorical([True, False], name='rsi-enabled'),
-            Categorical(['bb_lower', 'macd_cross_signal', 'sar_reversal'], name='trigger')
-        ]
-
     def has_space(self, space: str) -> bool:
         """
         Tell if a space value is contained in the configuration
@@ -216,71 +151,46 @@ class Hyperopt(Backtesting):
         """
         spaces: List[Dimension] = []
         if self.has_space('buy'):
-            spaces += Hyperopt.indicator_space()
+            spaces += self.custom_hyperopt.indicator_space()
+        if self.has_space('sell'):
+            spaces += self.custom_hyperopt.sell_indicator_space()
+            # Make sure experimental is enabled
+            if 'experimental' not in self.config:
+                self.config['experimental'] = {}
+            self.config['experimental']['use_sell_signal'] = True
         if self.has_space('roi'):
-            spaces += Hyperopt.roi_space()
+            spaces += self.custom_hyperopt.roi_space()
         if self.has_space('stoploss'):
-            spaces += Hyperopt.stoploss_space()
+            spaces += self.custom_hyperopt.stoploss_space()
         return spaces
 
-    @staticmethod
-    def buy_strategy_generator(params: Dict[str, Any]) -> Callable:
-        """
-        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
-            """
-            conditions = []
-            # GUARDS AND TRENDS
-            if 'mfi-enabled' in params and params['mfi-enabled']:
-                conditions.append(dataframe['mfi'] < params['mfi-value'])
-            if 'fastd-enabled' in params and params['fastd-enabled']:
-                conditions.append(dataframe['fastd'] < params['fastd-value'])
-            if 'adx-enabled' in params and params['adx-enabled']:
-                conditions.append(dataframe['adx'] > params['adx-value'])
-            if 'rsi-enabled' in params and params['rsi-enabled']:
-                conditions.append(dataframe['rsi'] < params['rsi-value'])
-
-            # TRIGGERS
-            if params['trigger'] == 'bb_lower':
-                conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
-            if params['trigger'] == 'macd_cross_signal':
-                conditions.append(qtpylib.crossed_above(
-                    dataframe['macd'], dataframe['macdsignal']
-                ))
-            if params['trigger'] == 'sar_reversal':
-                conditions.append(qtpylib.crossed_above(
-                    dataframe['close'], dataframe['sar']
-                ))
-
-            dataframe.loc[
-                reduce(lambda x, y: x & y, conditions),
-                'buy'] = 1
-
-            return dataframe
-
-        return populate_buy_trend
-
-    def generate_optimizer(self, _params) -> Dict:
+    def generate_optimizer(self, _params: Dict) -> Dict:
         params = self.get_args(_params)
-
         if self.has_space('roi'):
-            self.strategy.minimal_roi = self.generate_roi_table(params)
+            self.strategy.minimal_roi = self.custom_hyperopt.generate_roi_table(params)
 
         if self.has_space('buy'):
-            self.advise_buy = self.buy_strategy_generator(params)
+            self.advise_buy = self.custom_hyperopt.buy_strategy_generator(params)
+        elif hasattr(self.custom_hyperopt, 'populate_buy_trend'):
+            self.advise_buy = self.custom_hyperopt.populate_buy_trend  # type: ignore
+
+        if self.has_space('sell'):
+            self.advise_sell = self.custom_hyperopt.sell_strategy_generator(params)
+        elif hasattr(self.custom_hyperopt, 'populate_sell_trend'):
+            self.advise_sell = self.custom_hyperopt.populate_sell_trend  # type: ignore
 
         if self.has_space('stoploss'):
             self.strategy.stoploss = params['stoploss']
 
         processed = load(TICKERDATA_PICKLE)
+        min_date, max_date = get_timeframe(processed)
         results = self.backtest(
             {
                 'stake_amount': self.config['stake_amount'],
                 'processed': processed,
                 'position_stacking': self.config.get('position_stacking', True),
+                'start_date': min_date,
+                'end_date': max_date,
             }
         )
         result_explanation = self.format_results(results)
@@ -329,7 +239,8 @@ class Hyperopt(Backtesting):
         )
 
     def run_optimizer_parallel(self, parallel, asked) -> List:
-        return parallel(delayed(self.generate_optimizer)(v) for v in asked)
+        return parallel(delayed(
+                        wrap_non_picklable_objects(self.generate_optimizer))(v) for v in asked)
 
     def load_previous_results(self):
         """ read trials file if we have one """
@@ -344,15 +255,16 @@ class Hyperopt(Backtesting):
         timerange = Arguments.parse_timerange(None if self.config.get(
             'timerange') is None else str(self.config.get('timerange')))
         data = load_data(
-            datadir=str(self.config.get('datadir')),
+            datadir=Path(self.config['datadir']) if self.config.get('datadir') else None,
             pairs=self.config['exchange']['pair_whitelist'],
             ticker_interval=self.ticker_interval,
             timerange=timerange
         )
 
-        if self.has_space('buy'):
-            self.strategy.advise_indicators = Hyperopt.populate_indicators  # type: ignore
-        dump(self.tickerdata_to_dataframe(data), TICKERDATA_PICKLE)
+        if self.has_space('buy') or self.has_space('sell'):
+            self.strategy.advise_indicators = \
+                self.custom_hyperopt.populate_indicators  # type: ignore
+        dump(self.strategy.tickerdata_to_dataframe(data), TICKERDATA_PICKLE)
         self.exchange = None  # type: ignore
         self.load_previous_results()
 
@@ -395,7 +307,7 @@ def start(args: Namespace) -> None:
 
     # Initialize configuration
     # Monkey patch the configuration with hyperopt_conf.py
-    configuration = Configuration(args)
+    configuration = Configuration(args, RunMode.HYPEROPT)
     logger.info('Starting freqtrade in Hyperopt mode')
     config = configuration.load_config()
 

freqtrade/optimize/hyperopt_interface.py

@@ -0,0 +1,80 @@
+"""
+IHyperOpt interface
+This module defines the interface to apply for hyperopts
+"""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Callable, List
+
+from pandas import DataFrame
+from skopt.space import Dimension
+
+
+class IHyperOpt(ABC):
+    """
+    Interface for freqtrade hyperopts
+    Defines the mandatory structure must follow any custom strategies
+
+    Attributes you can use:
+        minimal_roi -> Dict: Minimal ROI designed for the strategy
+        stoploss -> float: optimal stoploss designed for the strategy
+        ticker_interval -> int: value of the ticker interval to use for the strategy
+    """
+
+    @staticmethod
+    @abstractmethod
+    def populate_indicators(dataframe: DataFrame, metadata: dict) -> DataFrame:
+        """
+        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()
+        :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
+        """
+
+    @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
+        """
+
+    @staticmethod
+    @abstractmethod
+    def sell_indicator_space() -> List[Dimension]:
+        """
+        Create a sell indicator space
+        """
+
+    @staticmethod
+    @abstractmethod
+    def generate_roi_table(params: Dict) -> Dict[int, float]:
+        """
+        Create an roi table
+        """
+
+    @staticmethod
+    @abstractmethod
+    def stoploss_space() -> List[Dimension]:
+        """
+        Create a stoploss space
+        """
+
+    @staticmethod
+    @abstractmethod
+    def roi_space() -> List[Dimension]:
+        """
+        Create a roi space
+        """

freqtrade/pairlist/IPairList.py

@@ -0,0 +1,91 @@
+"""
+Static List provider
+
+Provides lists as configured in config.json
+
+ """
+import logging
+from abc import ABC, abstractmethod
+from typing import List
+
+logger = logging.getLogger(__name__)
+
+
+class IPairList(ABC):
+
+    def __init__(self, freqtrade, config: dict) -> None:
+        self._freqtrade = freqtrade
+        self._config = config
+        self._whitelist = self._config['exchange']['pair_whitelist']
+        self._blacklist = self._config['exchange'].get('pair_blacklist', [])
+
+    @property
+    def name(self) -> str:
+        """
+        Gets name of the class
+        -> no need to overwrite in subclasses
+        """
+        return self.__class__.__name__
+
+    @property
+    def whitelist(self) -> List[str]:
+        """
+        Has the current whitelist
+        -> no need to overwrite in subclasses
+        """
+        return self._whitelist
+
+    @property
+    def blacklist(self) -> List[str]:
+        """
+        Has the current blacklist
+        -> no need to overwrite in subclasses
+        """
+        return self._blacklist
+
+    @abstractmethod
+    def short_desc(self) -> str:
+        """
+        Short whitelist method description - used for startup-messages
+        -> Please overwrite in subclasses
+        """
+
+    @abstractmethod
+    def refresh_pairlist(self) -> None:
+        """
+        Refreshes pairlists and assigns them to self._whitelist and self._blacklist respectively
+        -> Please overwrite in subclasses
+        """
+
+    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
+        trade
+        :return: the list of pairs the user wants to trade without the one unavailable or
+        black_listed
+        """
+        sanitized_whitelist = whitelist
+        markets = self._freqtrade.exchange.get_markets()
+
+        # Filter to markets in stake currency
+        markets = [m for m in markets if m['quote'] == self._config['stake_currency']]
+        known_pairs = set()
+
+        for market in markets:
+            pair = market['symbol']
+            # pair is not int the generated dynamic market, or in the blacklist ... ignore it
+            if pair not in whitelist or pair in self.blacklist:
+                continue
+            # else the pair is valid
+            known_pairs.add(pair)
+            # Market is not active
+            if not market['active']:
+                sanitized_whitelist.remove(pair)
+                logger.info(
+                    'Ignoring %s from whitelist. Market is not active.',
+                    pair
+                )
+
+        # We need to remove pairs that are unknown
+        return [x for x in sanitized_whitelist if x in known_pairs]

freqtrade/pairlist/StaticPairList.py

@@ -0,0 +1,30 @@
+"""
+Static List provider
+
+Provides lists as configured in config.json
+
+ """
+import logging
+
+from freqtrade.pairlist.IPairList import IPairList
+
+logger = logging.getLogger(__name__)
+
+
+class StaticPairList(IPairList):
+
+    def __init__(self, freqtrade, config: dict) -> None:
+        super().__init__(freqtrade, config)
+
+    def short_desc(self) -> str:
+        """
+        Short whitelist method description - used for startup-messages
+        -> Please overwrite in subclasses
+        """
+        return f"{self.name}: {self.whitelist}"
+
+    def refresh_pairlist(self) -> None:
+        """
+        Refreshes pairlists and assigns them to self._whitelist and self._blacklist respectively
+        """
+        self._whitelist = self._validate_whitelist(self._config['exchange']['pair_whitelist'])

freqtrade/pairlist/VolumePairList.py

@@ -0,0 +1,75 @@
+"""
+Static List provider
+
+Provides lists as configured in config.json
+
+ """
+import logging
+from typing import List
+from cachetools import TTLCache, cached
+
+from freqtrade.pairlist.IPairList import IPairList
+from freqtrade import OperationalException
+logger = logging.getLogger(__name__)
+
+SORT_VALUES = ['askVolume', 'bidVolume', 'quoteVolume']
+
+
+class VolumePairList(IPairList):
+
+    def __init__(self, freqtrade, config: dict) -> None:
+        super().__init__(freqtrade, config)
+        self._whitelistconf = self._config.get('pairlist', {}).get('config')
+        if 'number_assets' not in self._whitelistconf:
+            raise OperationalException(
+                f'`number_assets` not specified. Please check your configuration '
+                'for "pairlist.config.number_assets"')
+        self._number_pairs = self._whitelistconf['number_assets']
+        self._sort_key = self._whitelistconf.get('sort_key', 'quoteVolume')
+
+        if not self._freqtrade.exchange.exchange_has('fetchTickers'):
+            raise OperationalException(
+                'Exchange does not support dynamic whitelist.'
+                'Please edit your config and restart the bot'
+            )
+        if not self._validate_keys(self._sort_key):
+            raise OperationalException(
+                f'key {self._sort_key} not in {SORT_VALUES}')
+
+    def _validate_keys(self, key):
+        return key in SORT_VALUES
+
+    def short_desc(self) -> str:
+        """
+        Short whitelist method description - used for startup-messages
+        -> Please overwrite in subclasses
+        """
+        return f"{self.name} - top {self._whitelistconf['number_assets']} volume pairs."
+
+    def refresh_pairlist(self) -> None:
+        """
+        Refreshes pairlists and assigns them to self._whitelist and self._blacklist respectively
+        -> Please overwrite in subclasses
+        """
+        # Generate dynamic whitelist
+        pairs = self._gen_pair_whitelist(self._config['stake_currency'], self._sort_key)
+        # Validate whitelist to only have active market 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]:
+        """
+        Updates the whitelist with with a dynamically generated list
+        :param base_currency: base currency as str
+        :param key: sort key (defaults to 'quoteVolume')
+        :return: List of pairs
+        """
+
+        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]
+
+        sorted_tickers = sorted(tickers, reverse=True, key=lambda t: t[key])
+        pairs = [s['symbol'] for s in sorted_tickers]
+        return pairs

freqtrade/persistence.py

@@ -4,7 +4,7 @@ This module contains the class to persist trades into SQLite
 
 import logging
 from datetime import datetime
-from decimal import Decimal, getcontext
+from decimal import Decimal
 from typing import Any, Dict, Optional
 
 import arrow
@@ -14,6 +14,7 @@ from sqlalchemy.exc import NoSuchModuleError
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm.scoping import scoped_session
 from sqlalchemy.orm.session import sessionmaker
+from sqlalchemy import func
 from sqlalchemy.pool import StaticPool
 
 from freqtrade import OperationalException
@@ -82,7 +83,7 @@ def check_migrate(engine) -> None:
         logger.debug(f'trying {table_back_name}')
 
     # Check for latest column
-    if not has_column(cols, 'ticker_interval'):
+    if not has_column(cols, 'stoploss_last_update'):
         logger.info(f'Running database migration - backup available as {table_back_name}')
 
         fee_open = get_column_def(cols, 'fee_open', 'fee')
@@ -91,6 +92,8 @@ def check_migrate(engine) -> None:
         close_rate_requested = get_column_def(cols, 'close_rate_requested', 'null')
         stop_loss = get_column_def(cols, 'stop_loss', '0.0')
         initial_stop_loss = get_column_def(cols, 'initial_stop_loss', '0.0')
+        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')
         sell_reason = get_column_def(cols, 'sell_reason', 'null')
         strategy = get_column_def(cols, 'strategy', 'null')
@@ -98,6 +101,9 @@ def check_migrate(engine) -> None:
 
         # Schema migration necessary
         engine.execute(f"alter table trades rename to {table_back_name}")
+        # drop indexes on backup table
+        for index in inspector.get_indexes(table_back_name):
+            engine.execute(f"drop index {index['name']}")
         # let SQLAlchemy create the schema as required
         _DECL_BASE.metadata.create_all(engine)
 
@@ -106,7 +112,8 @@ 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, max_rate, sell_reason, strategy,
+                stop_loss, initial_stop_loss, stoploss_order_id, stoploss_last_update,
+                max_rate, sell_reason, strategy,
                 ticker_interval
                 )
             select id, lower(exchange),
@@ -122,8 +129,9 @@ def check_migrate(engine) -> None:
                 {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,
-                {max_rate} max_rate, {sell_reason} sell_reason, {strategy} strategy,
-                {ticker_interval} ticker_interval
+                {stoploss_order_id} stoploss_order_id, {stoploss_last_update} stoploss_last_update,
+                {max_rate} max_rate, {sell_reason} sell_reason,
+                {strategy} strategy, {ticker_interval} ticker_interval
                 from {table_back_name}
              """)
 
@@ -177,6 +185,10 @@ class Trade(_DECL_BASE):
     stop_loss = Column(Float, nullable=True, default=0.0)
     # absolute value of the initial stop loss
     initial_stop_loss = Column(Float, nullable=True, default=0.0)
+    # 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)
     sell_reason = Column(String, nullable=True)
@@ -210,11 +222,13 @@ class Trade(_DECL_BASE):
             logger.debug("assigning new stop loss")
             self.stop_loss = new_loss
             self.initial_stop_loss = new_loss
+            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.stoploss_last_update = datetime.utcnow()
                 logger.debug("adjusted stop loss")
             else:
                 logger.debug("keeping current stop loss")
@@ -239,17 +253,21 @@ class Trade(_DECL_BASE):
         if order['status'] == 'open' or order['price'] is None:
             return
 
-        logger.info('Updating trade (id=%d) ...', self.id)
+        logger.info('Updating trade (id=%s) ...', self.id)
 
-        getcontext().prec = 8  # Bittrex do not go above 8 decimal
-        if order_type == 'limit' and order['side'] == 'buy':
+        if order_type in ('market', 'limit') and order['side'] == 'buy':
             # Update open rate and actual amount
             self.open_rate = Decimal(order['price'])
             self.amount = Decimal(order['amount'])
-            logger.info('LIMIT_BUY has been fulfilled for %s.', self)
+            logger.info('%s_BUY has been fulfilled for %s.', order_type.upper(), self)
             self.open_order_id = None
-        elif order_type == 'limit' and order['side'] == 'sell':
+        elif order_type in ('market', 'limit') and order['side'] == 'sell':
             self.close(order['price'])
+            logger.info('%s_SELL has been fulfilled for %s.', order_type.upper(), self)
+        elif order_type == 'stop_loss_limit':
+            self.stoploss_order_id = None
+            logger.info('STOP_LOSS_LIMIT is hit for %s.', self)
+            self.close(order['average'])
         else:
             raise ValueError(f'Unknown order type: {order_type}')
         cleanup()
@@ -273,12 +291,11 @@ class Trade(_DECL_BASE):
             self,
             fee: Optional[float] = None) -> float:
         """
-        Calculate the open_rate in BTC
+        Calculate the open_rate including fee.
         :param fee: fee to use on the open rate (optional).
         If rate is not set self.fee will be used
-        :return: Price in BTC of the open trade
+        :return: Price in of the open trade incl. Fees
         """
-        getcontext().prec = 8
 
         buy_trade = (Decimal(self.amount) * Decimal(self.open_rate))
         fees = buy_trade * Decimal(fee or self.fee_open)
@@ -289,14 +306,13 @@ class Trade(_DECL_BASE):
             rate: Optional[float] = None,
             fee: Optional[float] = None) -> float:
         """
-        Calculate the close_rate in BTC
+        Calculate the close_rate including fee
         :param fee: fee to use on the close rate (optional).
         If rate is not set self.fee will be used
         :param rate: rate to compare with (optional).
         If rate is not set self.close_rate will be used
         :return: Price in BTC of the open trade
         """
-        getcontext().prec = 8
 
         if rate is None and not self.close_rate:
             return 0.0
@@ -310,12 +326,12 @@ class Trade(_DECL_BASE):
             rate: Optional[float] = None,
             fee: Optional[float] = None) -> float:
         """
-        Calculate the profit in BTC between Close and Open trade
+        Calculate the absolute profit in stake currency between Close and Open trade
         :param fee: fee to use on the close rate (optional).
         If rate is not set self.fee will be used
         :param rate: close rate to compare with (optional).
         If rate is not set self.close_rate will be used
-        :return:  profit in BTC as float
+        :return:  profit in stake currency as float
         """
         open_trade_price = self.calc_open_trade_price()
         close_trade_price = self.calc_close_trade_price(
@@ -336,7 +352,6 @@ class Trade(_DECL_BASE):
         :param fee: fee to use on the close rate (optional).
         :return: profit in percentage as float
         """
-        getcontext().prec = 8
 
         open_trade_price = self.calc_open_trade_price()
         close_trade_price = self.calc_close_trade_price(
@@ -345,3 +360,14 @@ class Trade(_DECL_BASE):
         )
         profit_percent = (close_trade_price / open_trade_price) - 1
         return float(f"{profit_percent:.8f}")
+
+    @staticmethod
+    def total_open_trades_stakes() -> float:
+        """
+        Calculates total invested amount in open trades
+        in stake currency
+        """
+        total_open_stake_amount = Trade.session.query(func.sum(Trade.stake_amount))\
+            .filter(Trade.is_open.is_(True))\
+            .scalar()
+        return total_open_stake_amount or 0

freqtrade/resolvers/__init__.py

@@ -0,0 +1,4 @@
+from freqtrade.resolvers.iresolver import IResolver  # noqa: F401
+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/hyperopt_resolver.py

@@ -0,0 +1,74 @@
+# pragma pylint: disable=attribute-defined-outside-init
+
+"""
+This module load custom hyperopts
+"""
+import logging
+from pathlib import Path
+from typing import Optional, Dict
+
+from freqtrade.constants import DEFAULT_HYPEROPT
+from freqtrade.optimize.hyperopt_interface import IHyperOpt
+from freqtrade.resolvers import IResolver
+
+logger = logging.getLogger(__name__)
+
+
+class HyperOptResolver(IResolver):
+    """
+    This class contains all the logic to load custom hyperopt class
+    """
+
+    __slots__ = ['hyperopt']
+
+    def __init__(self, config: Optional[Dict] = None) -> None:
+        """
+        Load the custom class from config parameter
+        :param config: configuration dictionary or None
+        """
+        config = config or {}
+
+        # 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, extra_dir=config.get('hyperopt_path'))
+
+        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, extra_dir: Optional[str] = None) -> IHyperOpt:
+        """
+        Search and loads the specified hyperopt.
+        :param hyperopt_name: name of the module to import
+        :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 = [
+            current_path.parent.parent.joinpath('user_data/hyperopts'),
+            current_path,
+        ]
+
+        if extra_dir:
+            # Add extra hyperopt directory on top of search paths
+            abs_paths.insert(0, Path(extra_dir))
+
+        for _path in abs_paths:
+            try:
+                hyperopt = self._search_object(directory=_path, object_type=IHyperOpt,
+                                               object_name=hyperopt_name)
+                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(
+            "Impossible to load Hyperopt '{}'. This class does not exist"
+            " or contains Python code errors".format(hyperopt_name)
+        )

freqtrade/resolvers/iresolver.py

@@ -0,0 +1,61 @@
+# pragma pylint: disable=attribute-defined-outside-init
+
+"""
+This module load custom objects
+"""
+import importlib.util
+import inspect
+import logging
+from pathlib import Path
+from typing import Optional, Type, Any
+
+logger = logging.getLogger(__name__)
+
+
+class IResolver(object):
+    """
+    This class contains all the logic to load custom classes
+    """
+
+    @staticmethod
+    def _get_valid_object(object_type, module_path: Path,
+                          object_name: str) -> Optional[Type[Any]]:
+        """
+        Returns the first object with matching object_type and object_name in the path given.
+        :param object_type: object_type (class)
+        :param module_path: absolute path to the module
+        :param object_name: Class name of the object
+        :return: class or None
+        """
+
+        # Generate spec based on absolute path
+        spec = importlib.util.spec_from_file_location('unknown', str(module_path))
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)  # type: ignore # importlib does not use typehints
+
+        valid_objects_gen = (
+            obj for name, obj in inspect.getmembers(module, inspect.isclass)
+            if object_name == name and object_type in obj.__bases__
+        )
+        return next(valid_objects_gen, None)
+
+    @staticmethod
+    def _search_object(directory: Path, object_type, object_name: str,
+                       kwargs: dict = {}) -> Optional[Any]:
+        """
+        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)
+        for entry in directory.iterdir():
+            # Only consider python files
+            if not str(entry).endswith('.py'):
+                logger.debug('Ignoring %s', entry)
+                continue
+            obj = IResolver._get_valid_object(
+                object_type, Path.resolve(directory.joinpath(entry)), object_name
+            )
+            if obj:
+                return obj(**kwargs)
+        return None

freqtrade/resolvers/pairlist_resolver.py

@@ -0,0 +1,59 @@
+# pragma pylint: disable=attribute-defined-outside-init
+
+"""
+This module load custom hyperopts
+"""
+import logging
+from pathlib import Path
+
+from freqtrade.pairlist.IPairList import IPairList
+from freqtrade.resolvers import IResolver
+
+logger = logging.getLogger(__name__)
+
+
+class PairListResolver(IResolver):
+    """
+    This class contains all the logic to load custom hyperopt class
+    """
+
+    __slots__ = ['pairlist']
+
+    def __init__(self, pairlist_name: str, freqtrade, config: dict) -> None:
+        """
+        Load the custom class from config parameter
+        :param config: configuration dictionary or None
+        """
+        self.pairlist = self._load_pairlist(pairlist_name, kwargs={'freqtrade': freqtrade,
+                                                                   'config': config})
+
+    def _load_pairlist(
+            self, pairlist_name: str, kwargs: dict) -> IPairList:
+        """
+        Search and loads the specified pairlist.
+        :param pairlist_name: name of the module to import
+        :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'),
+            current_path,
+        ]
+
+        for _path in abs_paths:
+            try:
+                pairlist = self._search_object(directory=_path, object_type=IPairList,
+                                               object_name=pairlist_name,
+                                               kwargs=kwargs)
+                if pairlist:
+                    logger.info('Using resolved pairlist %s from \'%s\'', pairlist_name, _path)
+                    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

@@ -0,0 +1,165 @@
+# pragma pylint: disable=attribute-defined-outside-init
+
+"""
+This module load custom strategies
+"""
+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.resolvers import IResolver
+from freqtrade.strategy import import_strategy
+from freqtrade.strategy.interface import IStrategy
+
+logger = logging.getLogger(__name__)
+
+
+class StrategyResolver(IResolver):
+    """
+    This class contains all the logic to load custom strategy class
+    """
+
+    __slots__ = ['strategy']
+
+    def __init__(self, config: Optional[Dict] = None) -> None:
+        """
+        Load the custom class from config parameter
+        :param config: configuration dictionary or None
+        """
+        config = config or {}
+
+        # Verify the strategy is in the configuration, otherwise fallback to the default strategy
+        strategy_name = config.get('strategy') or constants.DEFAULT_STRATEGY
+        self.strategy: IStrategy = self._load_strategy(strategy_name,
+                                                       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
+        # (Attribute name,                              default, experimental)
+        attributes = [("minimal_roi",                   None,    False),
+                      ("ticker_interval",               None,    False),
+                      ("stoploss",                      None,    False),
+                      ("trailing_stop",                 None,    False),
+                      ("trailing_stop_positive",        None,    False),
+                      ("trailing_stop_positive_offset", 0.0,     False),
+                      ("process_only_new_candles",      None,    False),
+                      ("order_types",                   None,    False),
+                      ("order_time_in_force",           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)
+
+        # Loop this list again to have output combined
+        for attribute, _, exp in attributes:
+            if exp and attribute in config['experimental']:
+                logger.info("Strategy using %s: %s", attribute, config['experimental'][attribute])
+            elif attribute in config:
+                logger.info("Strategy using %s: %s", attribute, config[attribute])
+
+        # 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)
+
+        self._strategy_sanity_validations()
+
+    def _override_attribute_helper(self, config, attribute: str, default):
+        """
+        Override attributes in the strategy.
+        Prevalence:
+        - Configuration
+        - Strategy
+        - default (if not None)
+        """
+        if attribute in config:
+            setattr(self.strategy, attribute, config[attribute])
+            logger.info("Override strategy '%s' with value in config file: %s.",
+                        attribute, config[attribute])
+        elif hasattr(self.strategy, attribute):
+            config[attribute] = getattr(self.strategy, attribute)
+        # Explicitly check for None here as other "falsy" values are possible
+        elif default is not None:
+            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.")
+
+        if not all(k in self.strategy.order_time_in_force for k in constants.REQUIRED_ORDERTIF):
+            raise ImportError(f"Impossible to load Strategy '{self.strategy.__class__.__name__}'. "
+                              f"Order-time-in-force mapping is incomplete.")
+
+    def _load_strategy(
+            self, strategy_name: str, config: dict, extra_dir: Optional[str] = None) -> IStrategy:
+        """
+        Search and loads the specified strategy.
+        :param strategy_name: name of the module to import
+        :param config: configuration for the strategy
+        :param extra_dir: additional directory to search for the given strategy
+        :return: Strategy instance or None
+        """
+        current_path = Path(__file__).parent.parent.joinpath('strategy').resolve()
+
+        abs_paths = [
+            Path.cwd().joinpath('user_data/strategies'),
+            current_path,
+        ]
+
+        if extra_dir:
+            # Add extra strategy directory on top of search paths
+            abs_paths.insert(0, Path(extra_dir).resolve())
+
+        if ":" in strategy_name:
+            logger.info("loading base64 endocded strategy")
+            strat = strategy_name.split(":")
+
+            if len(strat) == 2:
+                temp = Path(tempfile.mkdtemp("freq", "strategy"))
+                name = strat[0] + ".py"
+
+                temp.joinpath(name).write_text(urlsafe_b64decode(strat[1]).decode('utf-8'))
+                temp.joinpath("__init__.py").touch()
+
+                strategy_name = strat[0]
+
+                # register temp path with the bot
+                abs_paths.insert(0, temp.resolve())
+
+        for _path in abs_paths:
+            try:
+                strategy = self._search_object(directory=_path, object_type=IStrategy,
+                                               object_name=strategy_name, kwargs={'config': config})
+                if strategy:
+                    logger.info('Using resolved strategy %s from \'%s\'', strategy_name, _path)
+                    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)
+
+                    return import_strategy(strategy, config=config)
+            except FileNotFoundError:
+                logger.warning('Path "%s" does not exist', _path.relative_to(Path.cwd()))
+
+        raise ImportError(
+            "Impossible to load Strategy '{}'. This class does not exist"
+            " or contains Python code errors".format(strategy_name)
+        )

freqtrade/rpc/rpc.py

@@ -10,13 +10,13 @@ from typing import Dict, Any, List, Optional
 
 import arrow
 import sqlalchemy as sql
-from numpy import mean, nan_to_num
+from numpy import mean, nan_to_num, NAN
 from pandas import DataFrame
 
-from freqtrade import TemporaryError
-from freqtrade.fiat_convert import CryptoToFiatConverter
+from freqtrade import TemporaryError, DependencyException
 from freqtrade.misc import shorten_date
 from freqtrade.persistence import Trade
+from freqtrade.rpc.fiat_convert import CryptoToFiatConverter
 from freqtrade.state import State
 from freqtrade.strategy.interface import SellType
 
@@ -84,9 +84,7 @@ class RPC(object):
         """
         # Fetch open trade
         trades = Trade.query.filter(Trade.is_open.is_(True)).all()
-        if self._freqtrade.state != State.RUNNING:
-            raise RPCException('trader is not running')
-        elif not trades:
+        if not trades:
             raise RPCException('no active trade')
         else:
             results = []
@@ -95,7 +93,10 @@ class RPC(object):
                 if trade.open_order_id:
                     order = self._freqtrade.exchange.get_order(trade.open_order_id, trade.pair)
                 # calculate profit and send message to user
-                current_rate = self._freqtrade.exchange.get_ticker(trade.pair, False)['bid']
+                try:
+                    current_rate = self._freqtrade.exchange.get_ticker(trade.pair, False)['bid']
+                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)
@@ -118,15 +119,16 @@ class RPC(object):
 
     def _rpc_status_table(self) -> DataFrame:
         trades = Trade.query.filter(Trade.is_open.is_(True)).all()
-        if self._freqtrade.state != State.RUNNING:
-            raise RPCException('trader is not running')
-        elif not trades:
+        if not trades:
             raise RPCException('no active order')
         else:
             trades_list = []
             for trade in trades:
                 # calculate profit and send message to user
-                current_rate = self._freqtrade.exchange.get_ticker(trade.pair, False)['bid']
+                try:
+                    current_rate = self._freqtrade.exchange.get_ticker(trade.pair, False)['bid']
+                except DependencyException:
+                    current_rate = NAN
                 trade_perc = (100 * trade.calc_profit_percent(current_rate))
                 trades_list.append([
                     trade.id,
@@ -211,7 +213,10 @@ class RPC(object):
                 profit_closed_percent.append(profit_percent)
             else:
                 # Get current rate
-                current_rate = self._freqtrade.exchange.get_ticker(trade.pair, False)['bid']
+                try:
+                    current_rate = self._freqtrade.exchange.get_ticker(trade.pair, False)['bid']
+                except DependencyException:
+                    current_rate = NAN
                 profit_percent = trade.calc_profit_percent(rate=current_rate)
 
             profit_all_coin.append(
@@ -279,7 +284,7 @@ class RPC(object):
                         rate = 1.0 / self._freqtrade.exchange.get_ticker('BTC/USDT', False)['bid']
                     else:
                         rate = self._freqtrade.exchange.get_ticker(coin + '/BTC', False)['bid']
-                except TemporaryError:
+                except (TemporaryError, DependencyException):
                     continue
             est_btc: float = rate * balance['total']
             total = total + est_btc
@@ -363,6 +368,7 @@ class RPC(object):
             # Execute sell for all open orders
             for trade in Trade.query.filter(Trade.is_open.is_(True)).all():
                 _exec_forcesell(trade)
+            Trade.session.flush()
             return
 
         # Query for trade
@@ -379,13 +385,45 @@ class RPC(object):
         _exec_forcesell(trade)
         Trade.session.flush()
 
+    def _rpc_forcebuy(self, pair: str, price: Optional[float]) -> Optional[Trade]:
+        """
+        Handler for forcebuy <asset> <price>
+        Buys a pair trade at the given or current price
+        """
+
+        if not self._freqtrade.config.get('forcebuy_enable', False):
+            raise RPCException('Forcebuy not enabled.')
+
+        if self._freqtrade.state != State.RUNNING:
+            raise RPCException('trader is not running')
+
+        # Check pair is in stake currency
+        stake_currency = self._freqtrade.config.get('stake_currency')
+        if not pair.endswith(stake_currency):
+            raise RPCException(
+                f'Wrong pair selected. Please pairs with stake {stake_currency} pairs only')
+        # check if valid pair
+
+        # check if pair already has an open pair
+        trade = Trade.query.filter(Trade.is_open.is_(True)).filter(Trade.pair.is_(pair)).first()
+        if trade:
+            raise RPCException(f'position for {pair} already open - id: {trade.id}')
+
+        # gen stake amount
+        stakeamount = self._freqtrade._get_trade_stake_amount(pair)
+
+        # execute buy
+        if self._freqtrade.execute_buy(pair, stakeamount, price):
+            trade = Trade.query.filter(Trade.is_open.is_(True)).filter(Trade.pair.is_(pair)).first()
+            return trade
+        else:
+            return None
+
     def _rpc_performance(self) -> List[Dict]:
         """
         Handler for performance.
         Shows a performance statistic from finished trades
         """
-        if self._freqtrade.state != State.RUNNING:
-            raise RPCException('trader is not running')
 
         pair_rates = Trade.session.query(Trade.pair,
                                          sql.func.sum(Trade.close_profit).label('profit_sum'),
@@ -405,3 +443,11 @@ class RPC(object):
             raise RPCException('trader is not running')
 
         return Trade.query.filter(Trade.is_open.is_(True)).all()
+
+    def _rpc_whitelist(self) -> Dict:
+        """ Returns the currently active whitelist"""
+        res = {'method': self._freqtrade.pairlists.name,
+               'length': len(self._freqtrade.pairlists.whitelist),
+               'whitelist': self._freqtrade.active_pair_whitelist
+               }
+        return res

freqtrade/rpc/rpc_manager.py

@@ -4,7 +4,7 @@ This module contains class to manage RPC communications (Telegram, Slack, ...)
 import logging
 from typing import List, Dict, Any
 
-from freqtrade.rpc import RPC
+from freqtrade.rpc import RPC, RPCMessageType
 
 logger = logging.getLogger(__name__)
 
@@ -51,3 +51,29 @@ class RPCManager(object):
         for mod in self.registered_modules:
             logger.debug('Forwarding message to rpc.%s', mod.name)
             mod.send_msg(msg)
+
+    def startup_messages(self, config, pairlist) -> None:
+        if config.get('dry_run', False):
+            self.send_msg({
+                'type': RPCMessageType.WARNING_NOTIFICATION,
+                'status': 'Dry run is enabled. All trades are simulated.'
+            })
+        stake_currency = config['stake_currency']
+        stake_amount = config['stake_amount']
+        minimal_roi = config['minimal_roi']
+        ticker_interval = config['ticker_interval']
+        exchange_name = config['exchange']['name']
+        strategy_name = config.get('strategy', '')
+        self.send_msg({
+            'type': RPCMessageType.CUSTOM_NOTIFICATION,
+            'status': f'*Exchange:* `{exchange_name}`\n'
+                      f'*Stake per trade:* `{stake_amount} {stake_currency}`\n'
+                      f'*Minimum ROI:* `{minimal_roi}`\n'
+                      f'*Ticker Interval:* `{ticker_interval}`\n'
+                      f'*Strategy:* `{strategy_name}`'
+        })
+        self.send_msg({
+            'type': RPCMessageType.STATUS_NOTIFICATION,
+            'status': f'Searching for {stake_currency} pairs to buy and sell '
+                      f'based on {pairlist.short_desc()}'
+        })

freqtrade/rpc/telegram.py

@@ -12,8 +12,8 @@ from telegram.error import NetworkError, TelegramError
 from telegram.ext import CommandHandler, Updater
 
 from freqtrade.__init__ import __version__
-from freqtrade.fiat_convert import CryptoToFiatConverter
 from freqtrade.rpc import RPC, RPCException, RPCMessageType
+from freqtrade.rpc.fiat_convert import CryptoToFiatConverter
 
 logger = logging.getLogger(__name__)
 
@@ -86,10 +86,12 @@ class Telegram(RPC):
             CommandHandler('start', self._start),
             CommandHandler('stop', self._stop),
             CommandHandler('forcesell', self._forcesell),
+            CommandHandler('forcebuy', self._forcebuy),
             CommandHandler('performance', self._performance),
             CommandHandler('daily', self._daily),
             CommandHandler('count', self._count),
             CommandHandler('reload_conf', self._reload_conf),
+            CommandHandler('whitelist', self._whitelist),
             CommandHandler('help', self._help),
             CommandHandler('version', self._version),
         ]
@@ -123,9 +125,9 @@ class Telegram(RPC):
             else:
                 msg['stake_amount_fiat'] = 0
 
-            message = "*{exchange}:* Buying [{pair}]({market_url})\n" \
-                      "with limit `{limit:.8f}\n" \
-                      "({stake_amount:.6f} {stake_currency}".format(**msg)
+            message = ("*{exchange}:* Buying [{pair}]({market_url})\n"
+                       "with limit `{limit:.8f}\n"
+                       "({stake_amount:.6f} {stake_currency}").format(**msg)
 
             if msg.get('fiat_currency', None):
                 message += ",{stake_amount_fiat:.3f} {fiat_currency}".format(**msg)
@@ -135,12 +137,13 @@ 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" \
-                      "*Limit:* `{limit:.8f}`\n" \
-                      "*Amount:* `{amount:.8f}`\n" \
-                      "*Open Rate:* `{open_rate:.8f}`\n" \
-                      "*Current Rate:* `{current_rate:.8f}`\n" \
-                      "*Profit:* `{profit_percent:.2f}%`".format(**msg)
+            message = ("*{exchange}:* Selling [{pair}]({market_url})\n"
+                       "*Limit:* `{limit:.8f}`\n"
+                       "*Amount:* `{amount:.8f}`\n"
+                       "*Open Rate:* `{open_rate:.8f}`\n"
+                       "*Current Rate:* `{current_rate:.8f}`\n"
+                       "*Sell Reason:* `{sell_reason}`\n"
+                       "*Profit:* `{profit_percent:.2f}%`").format(**msg)
 
             # Check if all sell properties are available.
             # This might not be the case if the message origin is triggered by /forcesell
@@ -148,8 +151,8 @@ class Telegram(RPC):
                and self._fiat_converter):
                 msg['profit_fiat'] = self._fiat_converter.convert_amount(
                     msg['profit_amount'], msg['stake_currency'], msg['fiat_currency'])
-                message += '` ({gain}: {profit_amount:.8f} {stake_currency}`' \
-                           '` / {profit_fiat:.3f} {fiat_currency})`'.format(**msg)
+                message += ('` ({gain}: {profit_amount:.8f} {stake_currency}`'
+                            '` / {profit_fiat:.3f} {fiat_currency})`').format(**msg)
 
         elif msg['type'] == RPCMessageType.STATUS_NOTIFICATION:
             message = '*Status:* `{status}`'.format(**msg)
@@ -243,14 +246,14 @@ class Telegram(RPC):
                 stake_cur,
                 fiat_disp_cur
             )
-            stats = tabulate(stats,
-                             headers=[
-                                 'Day',
-                                 f'Profit {stake_cur}',
-                                 f'Profit {fiat_disp_cur}'
-                             ],
-                             tablefmt='simple')
-            message = f'<b>Daily Profit over the last {timescale} days</b>:\n<pre>{stats}</pre>'
+            stats_tab = tabulate(stats,
+                                 headers=[
+                                     'Day',
+                                     f'Profit {stake_cur}',
+                                     f'Profit {fiat_disp_cur}'
+                                 ],
+                                 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)
@@ -307,11 +310,14 @@ class Telegram(RPC):
             result = self._rpc_balance(self._config.get('fiat_display_currency', ''))
             output = ''
             for currency in result['currencies']:
-                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)
+                if currency['est_btc'] > 0.0001:
+                    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)
 
             output += "\n*Estimated Value*:\n" \
                       "\t`BTC: {total: .8f}`\n" \
@@ -372,6 +378,24 @@ class Telegram(RPC):
         except RPCException as e:
             self._send_msg(str(e), bot=bot)
 
+    @authorized_only
+    def _forcebuy(self, bot: Bot, update: Update) -> None:
+        """
+        Handler for /forcebuy <asset> <price>.
+        Buys a pair trade at the given or current price
+        :param bot: telegram bot
+        :param update: message update
+        :return: None
+        """
+
+        message = update.message.text.replace('/forcebuy', '').strip().split()
+        pair = message[0]
+        price = float(message[1]) if len(message) > 1 else None
+        try:
+            self._rpc_forcebuy(pair, price)
+        except RPCException as e:
+            self._send_msg(str(e), bot=bot)
+
     @authorized_only
     def _performance(self, bot: Bot, update: Update) -> None:
         """
@@ -416,6 +440,23 @@ class Telegram(RPC):
         except RPCException as e:
             self._send_msg(str(e), bot=bot)
 
+    @authorized_only
+    def _whitelist(self, bot: Bot, update: Update) -> None:
+        """
+        Handler for /whitelist
+        Shows the currently active whitelist
+        """
+        try:
+            whitelist = self._rpc_whitelist()
+
+            message = f"Using whitelist `{whitelist['method']}` with {whitelist['length']} pairs\n"
+            message += f"`{', '.join(whitelist['whitelist'])}`"
+
+            logger.debug(message)
+            self._send_msg(message)
+        except RPCException as e:
+            self._send_msg(str(e), bot=bot)
+
     @authorized_only
     def _help(self, bot: Bot, update: Update) -> None:
         """
@@ -437,6 +478,8 @@ class Telegram(RPC):
                   "*/count:* `Show number of trades running compared to allowed number of trades`" \
                   "\n" \
                   "*/balance:* `Show account balance per currency`\n" \
+                  "*/reload_conf:* `Reload configuration file` \n" \
+                  "*/whitelist:* `Show current whitelist` \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
-    STOPPED = 1
-    RELOAD_CONF = 2
+    RUNNING = 1
+    STOPPED = 2
+    RELOAD_CONF = 3
+
+
+class RunMode(Enum):
+    """
+    Bot running mode (backtest, hyperopt, ...)
+    can be "live", "dry-run", "backtest", "edgecli", "hyperopt".
+    """
+    LIVE = "live"
+    DRY_RUN = "dry_run"
+    BACKTEST = "backtest"
+    EDGECLI = "edgecli"
+    HYPEROPT = "hyperopt"
+    OTHER = "other"  # Used for plotting scripts and test

freqtrade/strategy/default_strategy.py

@@ -16,10 +16,10 @@ class DefaultStrategy(IStrategy):
 
     # Minimal ROI designed for the strategy
     minimal_roi = {
-        "40":  0.0,
-        "30":  0.01,
-        "20":  0.02,
-        "0":  0.04
+        "40": 0.0,
+        "30": 0.01,
+        "20": 0.02,
+        "0": 0.04
     }
 
     # Optimal stoploss designed for the strategy
@@ -28,6 +28,33 @@ class DefaultStrategy(IStrategy):
     # Optimal ticker interval for the strategy
     ticker_interval = '5m'
 
+    # Optional order type mapping
+    order_types = {
+        'buy': 'limit',
+        'sell': 'limit',
+        'stoploss': 'limit',
+        'stoploss_on_exchange': False
+    }
+
+    # Optional time in force for orders
+    order_time_in_force = {
+        'buy': 'gtc',
+        '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

@@ -6,15 +6,16 @@ import logging
 from abc import ABC, abstractmethod
 from datetime import datetime
 from enum import Enum
-from typing import Dict, List, NamedTuple, Optional, Tuple
+from typing import Dict, List, NamedTuple, Tuple
 import warnings
 
 import arrow
 from pandas import DataFrame
 
 from freqtrade import constants
-from freqtrade.exchange.exchange_helpers import parse_ticker_dataframe
+from freqtrade.data.dataprovider import DataProvider
 from freqtrade.persistence import Trade
+from freqtrade.wallets import Wallets
 
 logger = logging.getLogger(__name__)
 
@@ -33,6 +34,7 @@ class SellType(Enum):
     """
     ROI = "roi"
     STOP_LOSS = "stop_loss"
+    STOPLOSS_ON_EXCHANGE = "stoploss_on_exchange"
     TRAILING_STOP_LOSS = "trailing_stop_loss"
     SELL_SIGNAL = "sell_signal"
     FORCE_SELL = "force_sell"
@@ -67,18 +69,42 @@ class IStrategy(ABC):
     # associated stoploss
     stoploss: float
 
+    # trailing stoploss
+    trailing_stop: bool = False
+    trailing_stop_positive: float
+    trailing_stop_positive_offset: float
+
     # associated ticker interval
     ticker_interval: str
 
+    # Optional order types
+    order_types: Dict = {
+        'buy': 'limit',
+        'sell': 'limit',
+        'stoploss': 'limit',
+        'stoploss_on_exchange': False,
+        'stoploss_on_exchange_interval': 60,
+    }
+
+    # Optional time in force
+    order_time_in_force: Dict = {
+        'buy': 'gtc',
+        'sell': 'gtc',
+    }
+
     # run "populate_indicators" only for new candle
     process_only_new_candles: bool = False
 
-    # Dict to determine if analysis is necessary
-    _last_candle_seen_per_pair: Dict[str, datetime] = {}
+    # Class level variables (intentional) containing
+    # 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] = {}
 
     @abstractmethod
     def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
@@ -107,58 +133,70 @@ 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 analyze_ticker(self, ticker_history: List[Dict], metadata: dict) -> DataFrame:
+    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
         """
 
-        dataframe = parse_ticker_dataframe(ticker_history)
-
         pair = str(metadata.get('pair'))
 
         # Test if seen this pair and last candle before.
-        # always run if process_only_new_candles is set to true
+        # always run if process_only_new_candles is set to false
         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")
+            logger.debug("TA Analysis Launched")
             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
 
     def get_signal(self, pair: str, interval: str,
-                   ticker_hist: Optional[List[Dict]]) -> Tuple[bool, bool]:
+                   dataframe: DataFrame) -> Tuple[bool, bool]:
         """
         Calculates current signal based several technical analysis indicators
         :param pair: pair in format ANT/BTC
         :param interval: Interval to use (in min)
+        :param dataframe: Dataframe to analyze
         :return: (Buy, Sell) A bool-tuple indicating buy/sell signal
         """
-        if not ticker_hist:
+        if not isinstance(dataframe, DataFrame) or dataframe.empty:
             logger.warning('Empty ticker history for pair %s', pair)
             return False, False
 
         try:
-            dataframe = self.analyze_ticker(ticker_hist, {'pair': pair})
+            dataframe = self.analyze_ticker(dataframe, {'pair': pair})
         except ValueError as error:
             logger.warning(
                 'Unable to analyze ticker for pair %s: %s',
@@ -203,18 +241,28 @@ class IStrategy(ABC):
         return buy, sell
 
     def should_sell(self, trade: Trade, rate: float, date: datetime, buy: bool,
-                    sell: bool) -> SellCheckTuple:
+                    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
         if the threshold is reached and updates the trade record.
         :return: True if trade should be sold, False otherwise
         """
-        current_profit = trade.calc_profit_percent(rate)
-        stoplossflag = self.stop_loss_reached(current_rate=rate, trade=trade, current_time=date,
-                                              current_profit=current_profit)
+
+        # Set current rate to low for backtesting sell
+        current_rate = low or rate
+        current_profit = trade.calc_profit_percent(current_rate)
+
+        stoplossflag = self.stop_loss_reached(current_rate=current_rate, trade=trade,
+                                              current_time=date, current_profit=current_profit,
+                                              force_stoploss=force_stoploss)
+
         if stoplossflag.sell_flag:
             return stoplossflag
 
+        # Set current rate to low for backtesting sell
+        current_rate = high or rate
+        current_profit = trade.calc_profit_percent(current_rate)
         experimental = self.config.get('experimental', {})
 
         if buy and experimental.get('ignore_roi_if_buy_signal', False):
@@ -237,7 +285,7 @@ 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,
-                          current_profit: float) -> SellCheckTuple:
+                          current_profit: float, force_stoploss: float) -> SellCheckTuple:
         """
         Based on current profit of the trade and configured (trailing) stoploss,
         decides to sell or not
@@ -245,13 +293,16 @@ class IStrategy(ABC):
         """
 
         trailing_stop = self.config.get('trailing_stop', False)
+        trade.adjust_stop_loss(trade.open_rate, force_stoploss if force_stoploss
+                               else self.stoploss, initial=True)
 
-        trade.adjust_stop_loss(trade.open_rate, self.stoploss, initial=True)
-
-        # evaluate if the stoploss was hit
-        if self.stoploss is not None and trade.stop_loss >= current_rate:
+        # 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'))):
             selltype = SellType.STOP_LOSS
-            if trailing_stop:
+            # If Trailing stop (and max-rate did move above open rate)
+            if trailing_stop and trade.open_rate != trade.max_rate:
                 selltype = SellType.TRAILING_STOP_LOSS
                 logger.debug(
                     f"HIT STOP: current price at {current_rate:.6f}, "
@@ -268,8 +319,9 @@ class IStrategy(ABC):
 
             # 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)
+            stop_loss_value = force_stoploss if force_stoploss else self.stoploss
+
+            sl_offset = self.config.get('trailing_stop_positive_offset') or 0.0
 
             if 'trailing_stop_positive' in self.config and current_profit > sl_offset:
 
@@ -286,17 +338,18 @@ class IStrategy(ABC):
     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
-        sell
+        sell. Requires current_profit to be in percent!!
         :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
-        for duration, threshold in self.minimal_roi.items():
-            if time_diff <= duration:
-                return False
-            if current_profit > threshold:
-                return True
+        trade_dur = (current_time.timestamp() - trade.open_date.timestamp()) / 60
+
+        # Get highest entry in ROI dict where key >= trade-duration
+        roi_entry = max(list(filter(lambda x: trade_dur >= x, self.minimal_roi.keys())))
+        threshold = self.minimal_roi[roi_entry]
+        if current_profit > threshold:
+            return True
 
         return False
 
@@ -304,7 +357,7 @@ class IStrategy(ABC):
         """
         Creates a dataframe and populates indicators for given ticker data
         """
-        return {pair: self.advise_indicators(parse_ticker_dataframe(pair_data), {'pair': pair})
+        return {pair: self.advise_indicators(pair_data, {'pair': pair})
                 for pair, pair_data in tickerdata.items()}
 
     def advise_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:

freqtrade/strategy/resolver.py

@@ -1,178 +0,0 @@
-# pragma pylint: disable=attribute-defined-outside-init
-
-"""
-This module load custom strategies
-"""
-import importlib.util
-import inspect
-import logging
-import os
-import tempfile
-from base64 import urlsafe_b64decode
-from collections import OrderedDict
-from pathlib import Path
-from typing import Dict, Optional, Type
-
-from freqtrade import constants
-from freqtrade.strategy import import_strategy
-from freqtrade.strategy.interface import IStrategy
-
-logger = logging.getLogger(__name__)
-
-
-class StrategyResolver(object):
-    """
-    This class contains all the logic to load custom strategy class
-    """
-
-    __slots__ = ['strategy']
-
-    def __init__(self, config: Optional[Dict] = None) -> None:
-        """
-        Load the custom class from config parameter
-        :param config: configuration dictionary or None
-        """
-        config = config or {}
-
-        # Verify the strategy is in the configuration, otherwise fallback to the default strategy
-        strategy_name = config.get('strategy') or constants.DEFAULT_STRATEGY
-        self.strategy: IStrategy = self._load_strategy(strategy_name,
-                                                       config=config,
-                                                       extra_dir=config.get('strategy_path'))
-
-        # Set attributes
-        # Check if we need to override configuration
-        if 'minimal_roi' in config:
-            self.strategy.minimal_roi = config['minimal_roi']
-            logger.info("Override strategy 'minimal_roi' with value in config file: %s.",
-                        config['minimal_roi'])
-        else:
-            config['minimal_roi'] = self.strategy.minimal_roi
-
-        if 'stoploss' in config:
-            self.strategy.stoploss = config['stoploss']
-            logger.info(
-                "Override strategy 'stoploss' with value in config file: %s.", config['stoploss']
-            )
-        else:
-            config['stoploss'] = self.strategy.stoploss
-
-        if 'ticker_interval' in config:
-            self.strategy.ticker_interval = config['ticker_interval']
-            logger.info(
-                "Override strategy 'ticker_interval' with value in config file: %s.",
-                config['ticker_interval']
-            )
-        else:
-            config['ticker_interval'] = self.strategy.ticker_interval
-
-        if 'process_only_new_candles' in config:
-            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
-
-        # 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:
-        """
-        Search and loads the specified strategy.
-        :param strategy_name: name of the module to import
-        :param config: configuration for the strategy
-        :param extra_dir: additional directory to search for the given strategy
-        :return: Strategy instance or None
-        """
-        current_path = os.path.dirname(os.path.realpath(__file__))
-        abs_paths = [
-            os.path.join(os.getcwd(), 'user_data', 'strategies'),
-            current_path,
-        ]
-
-        if extra_dir:
-            # Add extra strategy directory on top of search paths
-            abs_paths.insert(0, extra_dir)
-
-        if ":" in strategy_name:
-            logger.info("loading base64 endocded strategy")
-            strat = strategy_name.split(":")
-
-            if len(strat) == 2:
-                temp = Path(tempfile.mkdtemp("freq", "strategy"))
-                name = strat[0] + ".py"
-
-                temp.joinpath(name).write_text(urlsafe_b64decode(strat[1]).decode('utf-8'))
-                temp.joinpath("__init__.py").touch()
-
-                strategy_name = os.path.splitext(name)[0]
-
-                # register temp path with the bot
-                abs_paths.insert(0, str(temp.resolve()))
-
-        for path in abs_paths:
-            try:
-                strategy = self._search_strategy(path, strategy_name=strategy_name, config=config)
-                if strategy:
-                    logger.info('Using resolved strategy %s from \'%s\'', strategy_name, path)
-                    strategy._populate_fun_len = len(
-                        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)
-            except FileNotFoundError:
-                logger.warning('Path "%s" does not exist', path)
-
-        raise ImportError(
-            "Impossible to load Strategy '{}'. This class does not exist"
-            " or contains Python code errors".format(strategy_name)
-        )
-
-    @staticmethod
-    def _get_valid_strategies(module_path: str, strategy_name: str) -> Optional[Type[IStrategy]]:
-        """
-        Returns a list of all possible strategies for the given module_path
-        :param module_path: absolute path to the module
-        :param strategy_name: Class name of the strategy
-        :return: Tuple with (name, class) or None
-        """
-
-        # Generate spec based on absolute path
-        spec = importlib.util.spec_from_file_location('unknown', module_path)
-        module = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(module)  # type: ignore # importlib does not use typehints
-
-        valid_strategies_gen = (
-            obj for name, obj in inspect.getmembers(module, inspect.isclass)
-            if strategy_name == name and IStrategy in obj.__bases__
-        )
-        return next(valid_strategies_gen, None)
-
-    @staticmethod
-    def _search_strategy(directory: str, strategy_name: str, config: dict) -> Optional[IStrategy]:
-        """
-        Search for the strategy_name in the given directory
-        :param directory: relative or absolute directory path
-        :return: name of the strategy class
-        """
-        logger.debug('Searching for strategy %s in \'%s\'', strategy_name, directory)
-        for entry in os.listdir(directory):
-            # Only consider python files
-            if not entry.endswith('.py'):
-                logger.debug('Ignoring %s', entry)
-                continue
-            strategy = StrategyResolver._get_valid_strategies(
-                os.path.abspath(os.path.join(directory, entry)), strategy_name
-            )
-            if strategy:
-                return strategy(config)
-        return None

freqtrade/tests/conftest.py

@@ -1,6 +1,7 @@
 # pragma pylint: disable=missing-docstring
 import json
 import logging
+import re
 from datetime import datetime
 from functools import reduce
 from typing import Dict, Optional
@@ -10,8 +11,10 @@ import arrow
 import pytest
 from telegram import Chat, Message, Update
 
-from freqtrade.exchange.exchange_helpers import parse_ticker_dataframe
+from freqtrade import constants
+from freqtrade.data.converter import parse_ticker_dataframe
 from freqtrade.exchange import Exchange
+from freqtrade.edge import Edge, PairInfo
 from freqtrade.freqtradebot import FreqtradeBot
 
 logging.getLogger('').setLevel(logging.INFO)
@@ -25,24 +28,60 @@ def log_has(line, logs):
                   False)
 
 
-def patch_exchange(mocker, api_mock=None) -> None:
+def log_has_re(line, logs):
+    return reduce(lambda a, b: a or b,
+                  filter(lambda x: re.match(line, x[2]), logs),
+                  False)
+
+
+def patch_exchange(mocker, api_mock=None, id='bittrex') -> None:
     mocker.patch('freqtrade.exchange.Exchange._load_markets', MagicMock(return_value={}))
     mocker.patch('freqtrade.exchange.Exchange.validate_timeframes', MagicMock())
-    mocker.patch('freqtrade.exchange.Exchange.name', PropertyMock(return_value="Bittrex"))
-    mocker.patch('freqtrade.exchange.Exchange.id', PropertyMock(return_value="bittrex"))
+    mocker.patch('freqtrade.exchange.Exchange.validate_ordertypes', MagicMock())
+    mocker.patch('freqtrade.exchange.Exchange.id', PropertyMock(return_value=id))
+    mocker.patch('freqtrade.exchange.Exchange.name', PropertyMock(return_value=id.title()))
+
     if api_mock:
         mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
     else:
         mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock())
 
 
-def get_patched_exchange(mocker, config, api_mock=None) -> Exchange:
-    patch_exchange(mocker, api_mock)
+def get_patched_exchange(mocker, config, api_mock=None, id='bittrex') -> Exchange:
+    patch_exchange(mocker, api_mock, id)
     exchange = Exchange(config)
     return exchange
 
 
+def patch_wallet(mocker, free=999.9) -> None:
+    mocker.patch('freqtrade.wallets.Wallets.get_free', MagicMock(
+        return_value=free
+    ))
+
+
+def patch_edge(mocker) -> None:
+    # "ETH/BTC",
+    # "LTC/BTC",
+    # "XRP/BTC",
+    # "NEO/BTC"
+
+    mocker.patch('freqtrade.edge.Edge._cached_pairs', mocker.PropertyMock(
+        return_value={
+            'NEO/BTC': PairInfo(-0.20, 0.66, 3.71, 0.50, 1.71, 10, 25),
+            'LTC/BTC': PairInfo(-0.21, 0.66, 3.71, 0.50, 1.71, 11, 20),
+        }
+    ))
+    mocker.patch('freqtrade.edge.Edge.calculate', MagicMock(return_value=True))
+
+
+def get_patched_edge(mocker, config) -> Edge:
+    patch_edge(mocker)
+    edge = Edge(config)
+    return edge
+
 # Functions for recurrent object patching
+
+
 def get_patched_freqtradebot(mocker, config) -> FreqtradeBot:
     """
     This function patch _init_modules() to not call dependencies
@@ -50,7 +89,6 @@ def get_patched_freqtradebot(mocker, config) -> FreqtradeBot:
     :param config: Config to pass to the bot
     :return: None
     """
-    # mocker.patch('freqtrade.fiat_convert.Market', {'price_usd': 12345.0})
     patch_coinmarketcap(mocker, {'price_usd': 12345.0})
     mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
     mocker.patch('freqtrade.freqtradebot.persistence.init', MagicMock())
@@ -75,7 +113,7 @@ def patch_coinmarketcap(mocker, value: Optional[Dict[str, float]] = None) -> Non
                                                  'website_slug': 'ethereum'}
                                                 ]})
     mocker.patch.multiple(
-        'freqtrade.fiat_convert.Market',
+        'freqtrade.rpc.fiat_convert.Market',
         ticker=tickermock,
         listings=listmock,
 
@@ -356,6 +394,36 @@ def limit_buy_order():
     }
 
 
+@pytest.fixture(scope='function')
+def market_buy_order():
+    return {
+        'id': 'mocked_market_buy',
+        'type': 'market',
+        'side': 'buy',
+        'pair': 'mocked',
+        'datetime': arrow.utcnow().isoformat(),
+        'price': 0.00004099,
+        'amount': 91.99181073,
+        'remaining': 0.0,
+        'status': 'closed'
+    }
+
+
+@pytest.fixture
+def market_sell_order():
+    return {
+        'id': 'mocked_limit_sell',
+        'type': 'market',
+        'side': 'sell',
+        'pair': 'mocked',
+        'datetime': arrow.utcnow().isoformat(),
+        'price': 0.00004173,
+        'amount': 91.99181073,
+        'remaining': 0.0,
+        'status': 'closed'
+    }
+
+
 @pytest.fixture
 def limit_buy_order_old():
     return {
@@ -450,7 +518,7 @@ def order_book_l2():
 
 
 @pytest.fixture
-def ticker_history():
+def ticker_history_list():
     return [
         [
             1511686200000,  # unix timestamp ms
@@ -479,6 +547,11 @@ def ticker_history():
     ]
 
 
+@pytest.fixture
+def ticker_history(ticker_history_list):
+    return parse_ticker_dataframe(ticker_history_list, "5m", True)
+
+
 @pytest.fixture
 def tickers():
     return MagicMock(return_value={
@@ -658,7 +731,7 @@ def tickers():
 @pytest.fixture
 def result():
     with open('freqtrade/tests/testdata/UNITTEST_BTC-1m.json') as data_file:
-        return parse_ticker_dataframe(json.load(data_file))
+        return parse_ticker_dataframe(json.load(data_file), '1m', True)
 
 # FIX:
 # Create an fixture/function
@@ -752,3 +825,26 @@ def buy_order_fee():
         'status': 'closed',
         'fee': None
     }
+
+
+@pytest.fixture(scope="function")
+def edge_conf(default_conf):
+    default_conf['max_open_trades'] = -1
+    default_conf['stake_amount'] = constants.UNLIMITED_STAKE_AMOUNT
+    default_conf['edge'] = {
+        "enabled": True,
+        "process_throttle_secs": 1800,
+        "calculate_since_number_of_days": 14,
+        "capital_available_percentage": 0.5,
+        "allowed_risk": 0.01,
+        "stoploss_range_min": -0.01,
+        "stoploss_range_max": -0.1,
+        "stoploss_range_step": -0.01,
+        "maximum_winrate": 0.80,
+        "minimum_expectancy": 0.20,
+        "min_trade_number": 15,
+        "max_trade_duration_minute": 1440,
+        "remove_pumps": False
+    }
+
+    return default_conf

freqtrade/tests/data/test_converter.py

@@ -0,0 +1,99 @@
+# pragma pylint: disable=missing-docstring, C0103
+import logging
+
+from freqtrade.data.converter import parse_ticker_dataframe, ohlcv_fill_up_missing_data
+from freqtrade.data.history import load_pair_history
+from freqtrade.optimize import validate_backtest_data, get_timeframe
+from freqtrade.tests.conftest import log_has
+
+
+def test_dataframe_correct_columns(result):
+    assert result.columns.tolist() == ['date', 'open', 'high', 'low', 'close', 'volume']
+
+
+def test_parse_ticker_dataframe(ticker_history_list, caplog):
+    columns = ['date', 'open', 'high', 'low', 'close', 'volume']
+
+    caplog.set_level(logging.DEBUG)
+    # Test file with BV data
+    dataframe = parse_ticker_dataframe(ticker_history_list, '5m', fill_missing=True)
+    assert dataframe.columns.tolist() == columns
+    assert log_has('Parsing tickerlist to dataframe', caplog.record_tuples)
+
+
+def test_ohlcv_fill_up_missing_data(caplog):
+    data = load_pair_history(datadir=None,
+                             ticker_interval='1m',
+                             refresh_pairs=False,
+                             pair='UNITTEST/BTC',
+                             fill_up_missing=False)
+    caplog.set_level(logging.DEBUG)
+    data2 = ohlcv_fill_up_missing_data(data, '1m')
+    assert len(data2) > len(data)
+    # Column names should not change
+    assert (data.columns == data2.columns).all()
+
+    assert log_has(f"Missing data fillup: before: {len(data)} - after: {len(data2)}",
+                   caplog.record_tuples)
+
+    # Test fillup actually fixes invalid backtest data
+    min_date, max_date = get_timeframe({'UNITTEST/BTC': data})
+    assert validate_backtest_data({'UNITTEST/BTC': data}, min_date, max_date, 1)
+    assert not validate_backtest_data({'UNITTEST/BTC': data2}, min_date, max_date, 1)
+
+
+def test_ohlcv_fill_up_missing_data2(caplog):
+    ticker_interval = '5m'
+    ticks = [[
+            1511686200000,  # 8:50:00
+            8.794e-05,  # open
+            8.948e-05,  # high
+            8.794e-05,  # low
+            8.88e-05,  # close
+            2255,  # volume (in quote currency)
+        ],
+        [
+            1511686500000,  # 8:55:00
+            8.88e-05,
+            8.942e-05,
+            8.88e-05,
+            8.893e-05,
+            9911,
+        ],
+        [
+            1511687100000,  # 9:05:00
+            8.891e-05,
+            8.893e-05,
+            8.875e-05,
+            8.877e-05,
+            2251
+        ],
+        [
+            1511687400000,  # 9:10:00
+            8.877e-05,
+            8.883e-05,
+            8.895e-05,
+            8.817e-05,
+            123551
+    ]
+    ]
+
+    # Generate test-data without filling missing
+    data = parse_ticker_dataframe(ticks, ticker_interval, fill_missing=False)
+    assert len(data) == 3
+    caplog.set_level(logging.DEBUG)
+    data2 = ohlcv_fill_up_missing_data(data, ticker_interval)
+    assert len(data2) == 4
+    # 3rd candle has been filled
+    row = data2.loc[2, :]
+    assert row['volume'] == 0
+    # close shoult match close of previous candle
+    assert row['close'] == data.loc[1, 'close']
+    assert row['open'] == row['close']
+    assert row['high'] == row['close']
+    assert row['low'] == row['close']
+    # Column names should not change
+    assert (data.columns == data2.columns).all()
+
+    assert log_has(f"Missing data fillup: before: {len(data)} - after: {len(data2)}",
+                   caplog.record_tuples)

freqtrade/tests/data/test_dataprovider.py

@@ -0,0 +1,92 @@
+from unittest.mock import MagicMock
+
+from pandas import DataFrame
+
+from freqtrade.data.dataprovider import DataProvider
+from freqtrade.state import RunMode
+from freqtrade.tests.conftest import get_patched_exchange
+
+
+def test_ohlcv(mocker, default_conf, ticker_history):
+    default_conf["runmode"] = RunMode.DRY_RUN
+    tick_interval = default_conf["ticker_interval"]
+    exchange = get_patched_exchange(mocker, default_conf)
+    exchange._klines[("XRP/BTC", tick_interval)] = ticker_history
+    exchange._klines[("UNITTEST/BTC", tick_interval)] = ticker_history
+    dp = DataProvider(default_conf, exchange)
+    assert dp.runmode == RunMode.DRY_RUN
+    assert ticker_history.equals(dp.ohlcv("UNITTEST/BTC", tick_interval))
+    assert isinstance(dp.ohlcv("UNITTEST/BTC", tick_interval), DataFrame)
+    assert dp.ohlcv("UNITTEST/BTC", tick_interval) is not ticker_history
+    assert dp.ohlcv("UNITTEST/BTC", tick_interval, copy=False) is ticker_history
+    assert not dp.ohlcv("UNITTEST/BTC", tick_interval).empty
+    assert dp.ohlcv("NONESENSE/AAA", tick_interval).empty
+
+    # Test with and without parameter
+    assert dp.ohlcv("UNITTEST/BTC", tick_interval).equals(dp.ohlcv("UNITTEST/BTC"))
+
+    default_conf["runmode"] = RunMode.LIVE
+    dp = DataProvider(default_conf, exchange)
+    assert dp.runmode == RunMode.LIVE
+    assert isinstance(dp.ohlcv("UNITTEST/BTC", tick_interval), DataFrame)
+
+    default_conf["runmode"] = RunMode.BACKTEST
+    dp = DataProvider(default_conf, exchange)
+    assert dp.runmode == RunMode.BACKTEST
+    assert dp.ohlcv("UNITTEST/BTC", tick_interval).empty
+
+
+def test_historic_ohlcv(mocker, default_conf, ticker_history):
+
+    historymock = MagicMock(return_value=ticker_history)
+    mocker.patch("freqtrade.data.dataprovider.load_pair_history", historymock)
+
+    # exchange = get_patched_exchange(mocker, default_conf)
+    dp = DataProvider(default_conf, None)
+    data = dp.historic_ohlcv("UNITTEST/BTC", "5m")
+    assert isinstance(data, DataFrame)
+    assert historymock.call_count == 1
+    assert historymock.call_args_list[0][1]["datadir"] is None
+    assert historymock.call_args_list[0][1]["refresh_pairs"] is False
+    assert historymock.call_args_list[0][1]["ticker_interval"] == "5m"
+
+
+def test_available_pairs(mocker, default_conf, ticker_history):
+    exchange = get_patched_exchange(mocker, default_conf)
+
+    tick_interval = default_conf["ticker_interval"]
+    exchange._klines[("XRP/BTC", tick_interval)] = ticker_history
+    exchange._klines[("UNITTEST/BTC", tick_interval)] = ticker_history
+    dp = DataProvider(default_conf, exchange)
+
+    assert len(dp.available_pairs) == 2
+    assert dp.available_pairs == [
+        ("XRP/BTC", tick_interval),
+        ("UNITTEST/BTC", tick_interval),
+    ]
+
+
+def test_refresh(mocker, default_conf, ticker_history):
+    refresh_mock = MagicMock()
+    mocker.patch("freqtrade.exchange.Exchange.refresh_latest_ohlcv", refresh_mock)
+
+    exchange = get_patched_exchange(mocker, default_conf, id="binance")
+    tick_interval = default_conf["ticker_interval"]
+    pairs = [("XRP/BTC", tick_interval), ("UNITTEST/BTC", tick_interval)]
+
+    pairs_non_trad = [("ETH/USDT", tick_interval), ("BTC/TUSD", "1h")]
+
+    dp = DataProvider(default_conf, exchange)
+    dp.refresh(pairs)
+
+    assert refresh_mock.call_count == 1
+    assert len(refresh_mock.call_args[0]) == 1
+    assert len(refresh_mock.call_args[0][0]) == len(pairs)
+    assert refresh_mock.call_args[0][0] == pairs
+
+    refresh_mock.reset_mock()
+    dp.refresh(pairs, pairs_non_trad)
+    assert refresh_mock.call_count == 1
+    assert len(refresh_mock.call_args[0]) == 1
+    assert len(refresh_mock.call_args[0][0]) == len(pairs) + len(pairs_non_trad)
+    assert refresh_mock.call_args[0][0] == pairs + pairs_non_trad

freqtrade/tests/data/test_history.py

@@ -0,0 +1,475 @@
+# pragma pylint: disable=missing-docstring, protected-access, C0103
+
+import json
+import os
+from pathlib import Path
+import uuid
+from shutil import copyfile
+
+import arrow
+from pandas import DataFrame
+import pytest
+
+from freqtrade import OperationalException
+from freqtrade.arguments import TimeRange
+from freqtrade.data import history
+from freqtrade.data.history import (download_pair_history,
+                                    load_cached_data_for_updating,
+                                    load_tickerdata_file,
+                                    make_testdata_path,
+                                    trim_tickerlist)
+from freqtrade.misc import file_dump_json
+from freqtrade.tests.conftest import get_patched_exchange, log_has
+
+# Change this if modifying UNITTEST/BTC testdatafile
+_BTC_UNITTEST_LENGTH = 13681
+
+
+def _backup_file(file: str, copy_file: bool = False) -> None:
+    """
+    Backup existing file to avoid deleting the user file
+    :param file: complete path to the file
+    :param touch_file: create an empty file in replacement
+    :return: None
+    """
+    file_swp = file + '.swp'
+    if os.path.isfile(file):
+        os.rename(file, file_swp)
+
+        if copy_file:
+            copyfile(file_swp, file)
+
+
+def _clean_test_file(file: str) -> None:
+    """
+    Backup existing file to avoid deleting the user file
+    :param file: complete path to the file
+    :return: None
+    """
+    file_swp = file + '.swp'
+    # 1. Delete file from the test
+    if os.path.isfile(file):
+        os.remove(file)
+
+    # 2. Rollback to the initial file
+    if os.path.isfile(file_swp):
+        os.rename(file_swp, file)
+
+
+def test_load_data_30min_ticker(mocker, caplog, default_conf) -> None:
+    ld = history.load_pair_history(pair='UNITTEST/BTC', ticker_interval='30m', datadir=None)
+    assert isinstance(ld, DataFrame)
+    assert not log_has('Download the pair: "UNITTEST/BTC", Interval: 30m', caplog.record_tuples)
+
+
+def test_load_data_7min_ticker(mocker, caplog, default_conf) -> None:
+    ld = history.load_pair_history(pair='UNITTEST/BTC', ticker_interval='7m', datadir=None)
+    assert not isinstance(ld, DataFrame)
+    assert ld is None
+    assert log_has(
+        'No data for pair: "UNITTEST/BTC", Interval: 7m. '
+        'Use --refresh-pairs-cached to download the data', caplog.record_tuples)
+
+
+def test_load_data_1min_ticker(ticker_history, mocker, caplog) -> None:
+    mocker.patch('freqtrade.exchange.Exchange.get_history', return_value=ticker_history)
+    file = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'UNITTEST_BTC-1m.json')
+    _backup_file(file, copy_file=True)
+    history.load_data(datadir=None, ticker_interval='1m', pairs=['UNITTEST/BTC'])
+    assert os.path.isfile(file) is True
+    assert not log_has('Download the pair: "UNITTEST/BTC", Interval: 1m', caplog.record_tuples)
+    _clean_test_file(file)
+
+
+def test_load_data_with_new_pair_1min(ticker_history_list, mocker, caplog, default_conf) -> None:
+    """
+    Test load_pair_history() with 1 min ticker
+    """
+    mocker.patch('freqtrade.exchange.Exchange.get_history', return_value=ticker_history_list)
+    exchange = get_patched_exchange(mocker, default_conf)
+    file = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'MEME_BTC-1m.json')
+
+    _backup_file(file)
+    # do not download a new pair if refresh_pairs isn't set
+    history.load_pair_history(datadir=None,
+                              ticker_interval='1m',
+                              refresh_pairs=False,
+                              pair='MEME/BTC')
+    assert os.path.isfile(file) is False
+    assert log_has('No data for pair: "MEME/BTC", Interval: 1m. '
+                   'Use --refresh-pairs-cached to download the data',
+                   caplog.record_tuples)
+
+    # download a new pair if refresh_pairs is set
+    history.load_pair_history(datadir=None,
+                              ticker_interval='1m',
+                              refresh_pairs=True,
+                              exchange=exchange,
+                              pair='MEME/BTC')
+    assert os.path.isfile(file) is True
+    assert log_has('Download the pair: "MEME/BTC", Interval: 1m', caplog.record_tuples)
+    with pytest.raises(OperationalException, match=r'Exchange needs to be initialized when.*'):
+        history.load_pair_history(datadir=None,
+                                  ticker_interval='1m',
+                                  refresh_pairs=True,
+                                  exchange=None,
+                                  pair='MEME/BTC')
+    _clean_test_file(file)
+
+
+def test_testdata_path() -> None:
+    assert str(Path('freqtrade') / 'tests' / 'testdata') in str(make_testdata_path(None))
+
+
+def test_load_cached_data_for_updating(mocker) -> None:
+    datadir = Path(__file__).parent.parent.joinpath('testdata')
+
+    test_data = None
+    test_filename = datadir.joinpath('UNITTEST_BTC-1m.json')
+    with open(test_filename, "rt") as file:
+        test_data = json.load(file)
+
+    # change now time to test 'line' cases
+    # now = last cached item + 1 hour
+    now_ts = test_data[-1][0] / 1000 + 60 * 60
+    mocker.patch('arrow.utcnow', return_value=arrow.get(now_ts))
+
+    # timeframe starts earlier than the cached data
+    # should fully update data
+    timerange = TimeRange('date', None, test_data[0][0] / 1000 - 1, 0)
+    data, start_ts = load_cached_data_for_updating(test_filename,
+                                                   '1m',
+                                                   timerange)
+    assert data == []
+    assert start_ts == test_data[0][0] - 1000
+
+    # same with 'line' timeframe
+    num_lines = (test_data[-1][0] - test_data[1][0]) / 1000 / 60 + 120
+    data, start_ts = load_cached_data_for_updating(test_filename,
+                                                   '1m',
+                                                   TimeRange(None, 'line', 0, -num_lines))
+    assert data == []
+    assert start_ts < test_data[0][0] - 1
+
+    # timeframe starts in the center of the cached data
+    # should return the chached data w/o the last item
+    timerange = TimeRange('date', None, test_data[0][0] / 1000 + 1, 0)
+    data, start_ts = load_cached_data_for_updating(test_filename,
+                                                   '1m',
+                                                   timerange)
+    assert data == test_data[:-1]
+    assert test_data[-2][0] < start_ts < test_data[-1][0]
+
+    # same with 'line' timeframe
+    num_lines = (test_data[-1][0] - test_data[1][0]) / 1000 / 60 + 30
+    timerange = TimeRange(None, 'line', 0, -num_lines)
+    data, start_ts = load_cached_data_for_updating(test_filename,
+                                                   '1m',
+                                                   timerange)
+    assert data == test_data[:-1]
+    assert test_data[-2][0] < start_ts < test_data[-1][0]
+
+    # timeframe starts after the chached data
+    # should return the chached data w/o the last item
+    timerange = TimeRange('date', None, test_data[-1][0] / 1000 + 1, 0)
+    data, start_ts = load_cached_data_for_updating(test_filename,
+                                                   '1m',
+                                                   timerange)
+    assert data == test_data[:-1]
+    assert test_data[-2][0] < start_ts < test_data[-1][0]
+
+    # same with 'line' timeframe
+    num_lines = 30
+    timerange = TimeRange(None, 'line', 0, -num_lines)
+    data, start_ts = load_cached_data_for_updating(test_filename,
+                                                   '1m',
+                                                   timerange)
+    assert data == test_data[:-1]
+    assert test_data[-2][0] < start_ts < test_data[-1][0]
+
+    # no timeframe is set
+    # should return the chached data w/o the last item
+    num_lines = 30
+    timerange = TimeRange(None, 'line', 0, -num_lines)
+    data, start_ts = load_cached_data_for_updating(test_filename,
+                                                   '1m',
+                                                   timerange)
+    assert data == test_data[:-1]
+    assert test_data[-2][0] < start_ts < test_data[-1][0]
+
+    # no datafile exist
+    # should return timestamp start time
+    timerange = TimeRange('date', None, now_ts - 10000, 0)
+    data, start_ts = load_cached_data_for_updating(test_filename.with_name('unexist'),
+                                                   '1m',
+                                                   timerange)
+    assert data == []
+    assert start_ts == (now_ts - 10000) * 1000
+
+    # same with 'line' timeframe
+    num_lines = 30
+    timerange = TimeRange(None, 'line', 0, -num_lines)
+    data, start_ts = load_cached_data_for_updating(test_filename.with_name('unexist'),
+                                                   '1m',
+                                                   timerange)
+    assert data == []
+    assert start_ts == (now_ts - num_lines * 60) * 1000
+
+    # no datafile exist, no timeframe is set
+    # should return an empty array and None
+    data, start_ts = load_cached_data_for_updating(test_filename.with_name('unexist'),
+                                                   '1m',
+                                                   None)
+    assert data == []
+    assert start_ts is None
+
+
+def test_download_pair_history(ticker_history_list, mocker, default_conf) -> None:
+    mocker.patch('freqtrade.exchange.Exchange.get_history', return_value=ticker_history_list)
+    exchange = get_patched_exchange(mocker, default_conf)
+    file1_1 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'MEME_BTC-1m.json')
+    file1_5 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'MEME_BTC-5m.json')
+    file2_1 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'CFI_BTC-1m.json')
+    file2_5 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'CFI_BTC-5m.json')
+
+    _backup_file(file1_1)
+    _backup_file(file1_5)
+    _backup_file(file2_1)
+    _backup_file(file2_5)
+
+    assert os.path.isfile(file1_1) is False
+    assert os.path.isfile(file2_1) is False
+
+    assert download_pair_history(datadir=None, exchange=exchange,
+                                 pair='MEME/BTC',
+                                 tick_interval='1m')
+    assert download_pair_history(datadir=None, exchange=exchange,
+                                 pair='CFI/BTC',
+                                 tick_interval='1m')
+    assert not exchange._pairs_last_refresh_time
+    assert os.path.isfile(file1_1) is True
+    assert os.path.isfile(file2_1) is True
+
+    # clean files freshly downloaded
+    _clean_test_file(file1_1)
+    _clean_test_file(file2_1)
+
+    assert os.path.isfile(file1_5) is False
+    assert os.path.isfile(file2_5) is False
+
+    assert download_pair_history(datadir=None, exchange=exchange,
+                                 pair='MEME/BTC',
+                                 tick_interval='5m')
+    assert download_pair_history(datadir=None, exchange=exchange,
+                                 pair='CFI/BTC',
+                                 tick_interval='5m')
+    assert not exchange._pairs_last_refresh_time
+    assert os.path.isfile(file1_5) is True
+    assert os.path.isfile(file2_5) is True
+
+    # clean files freshly downloaded
+    _clean_test_file(file1_5)
+    _clean_test_file(file2_5)
+
+
+def test_download_pair_history2(mocker, default_conf) -> None:
+    tick = [
+        [1509836520000, 0.00162008, 0.00162008, 0.00162008, 0.00162008, 108.14853839],
+        [1509836580000, 0.00161, 0.00161, 0.00161, 0.00161, 82.390199]
+    ]
+    json_dump_mock = mocker.patch('freqtrade.misc.file_dump_json', return_value=None)
+    mocker.patch('freqtrade.exchange.Exchange.get_history', return_value=tick)
+    exchange = get_patched_exchange(mocker, default_conf)
+    download_pair_history(None, exchange, pair="UNITTEST/BTC", tick_interval='1m')
+    download_pair_history(None, exchange, pair="UNITTEST/BTC", tick_interval='3m')
+    assert json_dump_mock.call_count == 2
+
+
+def test_download_backtesting_data_exception(ticker_history, mocker, caplog, default_conf) -> None:
+    mocker.patch('freqtrade.exchange.Exchange.get_history',
+                 side_effect=BaseException('File Error'))
+
+    exchange = get_patched_exchange(mocker, default_conf)
+
+    file1_1 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'MEME_BTC-1m.json')
+    file1_5 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'MEME_BTC-5m.json')
+    _backup_file(file1_1)
+    _backup_file(file1_5)
+
+    assert not download_pair_history(datadir=None, exchange=exchange,
+                                     pair='MEME/BTC',
+                                     tick_interval='1m')
+    # clean files freshly downloaded
+    _clean_test_file(file1_1)
+    _clean_test_file(file1_5)
+    assert log_has('Failed to download the pair: "MEME/BTC", Interval: 1m', caplog.record_tuples)
+
+
+def test_load_tickerdata_file() -> None:
+    # 7 does not exist in either format.
+    assert not load_tickerdata_file(None, 'UNITTEST/BTC', '7m')
+    # 1 exists only as a .json
+    tickerdata = load_tickerdata_file(None, 'UNITTEST/BTC', '1m')
+    assert _BTC_UNITTEST_LENGTH == len(tickerdata)
+    # 8 .json is empty and will fail if it's loaded. .json.gz is a copy of 1.json
+    tickerdata = load_tickerdata_file(None, 'UNITTEST/BTC', '8m')
+    assert _BTC_UNITTEST_LENGTH == len(tickerdata)
+
+
+def test_load_partial_missing(caplog) -> None:
+    # Make sure we start fresh - test missing data at start
+    start = arrow.get('2018-01-01T00:00:00')
+    end = arrow.get('2018-01-11T00:00:00')
+    tickerdata = history.load_data(None, '5m', ['UNITTEST/BTC'],
+                                   refresh_pairs=False,
+                                   timerange=TimeRange('date', 'date',
+                                                       start.timestamp, end.timestamp))
+    # timedifference in 5 minutes
+    td = ((end - start).total_seconds() // 60 // 5) + 1
+    assert td != len(tickerdata['UNITTEST/BTC'])
+    start_real = tickerdata['UNITTEST/BTC'].iloc[0, 0]
+    assert log_has(f'Missing data at start for pair '
+                   f'UNITTEST/BTC, data starts at {start_real.strftime("%Y-%m-%d %H:%M:%S")}',
+                   caplog.record_tuples)
+    # Make sure we start fresh - test missing data at end
+    caplog.clear()
+    start = arrow.get('2018-01-10T00:00:00')
+    end = arrow.get('2018-02-20T00:00:00')
+    tickerdata = history.load_data(datadir=None, ticker_interval='5m',
+                                   pairs=['UNITTEST/BTC'], refresh_pairs=False,
+                                   timerange=TimeRange('date', 'date',
+                                                       start.timestamp, end.timestamp))
+    # timedifference in 5 minutes
+    td = ((end - start).total_seconds() // 60 // 5) + 1
+    assert td != len(tickerdata['UNITTEST/BTC'])
+    # Shift endtime with +5 - as last candle is dropped (partial candle)
+    end_real = arrow.get(tickerdata['UNITTEST/BTC'].iloc[-1, 0]).shift(minutes=5)
+    assert log_has(f'Missing data at end for pair '
+                   f'UNITTEST/BTC, data ends at {end_real.strftime("%Y-%m-%d %H:%M:%S")}',
+                   caplog.record_tuples)
+
+
+def test_init(default_conf, mocker) -> None:
+    exchange = get_patched_exchange(mocker, default_conf)
+    assert {} == history.load_data(
+        datadir='',
+        exchange=exchange,
+        pairs=[],
+        refresh_pairs=True,
+        ticker_interval=default_conf['ticker_interval']
+    )
+
+
+def test_trim_tickerlist() -> None:
+    file = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'UNITTEST_BTC-1m.json')
+    with open(file) as data_file:
+        ticker_list = json.load(data_file)
+    ticker_list_len = len(ticker_list)
+
+    # Test the pattern ^(-\d+)$
+    # This pattern uses the latest N elements
+    timerange = TimeRange(None, 'line', 0, -5)
+    ticker = trim_tickerlist(ticker_list, timerange)
+    ticker_len = len(ticker)
+
+    assert ticker_len == 5
+    assert ticker_list[0] is not ticker[0]  # The first element should be different
+    assert ticker_list[-1] is ticker[-1]  # The last element must be the same
+
+    # Test the pattern ^(\d+)-$
+    # This pattern keep X element from the end
+    timerange = TimeRange('line', None, 5, 0)
+    ticker = trim_tickerlist(ticker_list, timerange)
+    ticker_len = len(ticker)
+
+    assert ticker_len == 5
+    assert ticker_list[0] is ticker[0]  # The first element must be the same
+    assert ticker_list[-1] is not ticker[-1]  # The last element should be different
+
+    # Test the pattern ^(\d+)-(\d+)$
+    # This pattern extract a window
+    timerange = TimeRange('index', 'index', 5, 10)
+    ticker = trim_tickerlist(ticker_list, timerange)
+    ticker_len = len(ticker)
+
+    assert ticker_len == 5
+    assert ticker_list[0] is not ticker[0]  # The first element should be different
+    assert ticker_list[5] is ticker[0]  # The list starts at the index 5
+    assert ticker_list[9] is ticker[-1]  # The list ends at the index 9 (5 elements)
+
+    # Test the pattern ^(\d{8})-(\d{8})$
+    # This pattern extract a window between the dates
+    timerange = TimeRange('date', 'date', ticker_list[5][0] / 1000, ticker_list[10][0] / 1000 - 1)
+    ticker = trim_tickerlist(ticker_list, timerange)
+    ticker_len = len(ticker)
+
+    assert ticker_len == 5
+    assert ticker_list[0] is not ticker[0]  # The first element should be different
+    assert ticker_list[5] is ticker[0]  # The list starts at the index 5
+    assert ticker_list[9] is ticker[-1]  # The list ends at the index 9 (5 elements)
+
+    # Test the pattern ^-(\d{8})$
+    # This pattern extracts elements from the start to the date
+    timerange = TimeRange(None, 'date', 0, ticker_list[10][0] / 1000 - 1)
+    ticker = trim_tickerlist(ticker_list, timerange)
+    ticker_len = len(ticker)
+
+    assert ticker_len == 10
+    assert ticker_list[0] is ticker[0]  # The start of the list is included
+    assert ticker_list[9] is ticker[-1]  # The element 10 is not included
+
+    # Test the pattern ^(\d{8})-$
+    # This pattern extracts elements from the date to now
+    timerange = TimeRange('date', None, ticker_list[10][0] / 1000 - 1, None)
+    ticker = trim_tickerlist(ticker_list, timerange)
+    ticker_len = len(ticker)
+
+    assert ticker_len == ticker_list_len - 10
+    assert ticker_list[10] is ticker[0]  # The first element is element #10
+    assert ticker_list[-1] is ticker[-1]  # The last element is the same
+
+    # Test a wrong pattern
+    # This pattern must return the list unchanged
+    timerange = TimeRange(None, None, None, 5)
+    ticker = trim_tickerlist(ticker_list, timerange)
+    ticker_len = len(ticker)
+
+    assert ticker_list_len == ticker_len
+
+    # Test invalid timerange (start after stop)
+    timerange = TimeRange('index', 'index', 10, 5)
+    with pytest.raises(ValueError, match=r'The timerange .* is incorrect'):
+        trim_tickerlist(ticker_list, timerange)
+
+    assert ticker_list_len == ticker_len
+
+    # passing empty list
+    timerange = TimeRange(None, None, None, 5)
+    ticker = trim_tickerlist([], timerange)
+    assert 0 == len(ticker)
+    assert not ticker
+
+
+def test_file_dump_json_tofile() -> None:
+    file = os.path.join(os.path.dirname(__file__), '..', 'testdata',
+                        'test_{id}.json'.format(id=str(uuid.uuid4())))
+    data = {'bar': 'foo'}
+
+    # check the file we will create does not exist
+    assert os.path.isfile(file) is False
+
+    # Create the Json file
+    file_dump_json(file, data)
+
+    # Check the file was create
+    assert os.path.isfile(file) is True
+
+    # Open the Json file created and test the data is in it
+    with open(file) as data_file:
+        json_from_file = json.load(data_file)
+
+    assert 'bar' in json_from_file
+    assert json_from_file['bar'] == 'foo'
+
+    # Remove the file
+    _clean_test_file(file)

freqtrade/tests/edge/test_edge.py

@@ -0,0 +1,362 @@
+# pragma pylint: disable=missing-docstring, C0103, C0330
+# pragma pylint: disable=protected-access, too-many-lines, invalid-name, too-many-arguments
+
+import logging
+import math
+from unittest.mock import MagicMock
+
+import arrow
+import numpy as np
+import pytest
+from pandas import DataFrame, to_datetime
+
+from freqtrade.data.converter import parse_ticker_dataframe
+from freqtrade.edge import Edge, PairInfo
+from freqtrade.strategy.interface import SellType
+from freqtrade.tests.conftest import get_patched_freqtradebot
+from freqtrade.tests.optimize import (BTContainer, BTrade,
+                                      _build_backtest_dataframe,
+                                      _get_frame_time_from_offset)
+
+# Cases to be tested:
+# 1) Open trade should be removed from the end
+# 2) Two complete trades within dataframe (with sell hit for all)
+# 3) Entered, sl 1%, candle drops 8% => Trade closed, 1% loss
+# 4) Entered, sl 3%, candle drops 4%, recovers to 1% => Trade closed, 3% loss
+# 5) Stoploss and sell are hit. should sell on stoploss
+####################################################################
+
+ticker_start_time = arrow.get(2018, 10, 3)
+ticker_interval_in_minute = 60
+_ohlc = {'date': 0, 'buy': 1, 'open': 2, 'high': 3, 'low': 4, 'close': 5, 'sell': 6, 'volume': 7}
+
+
+# Open trade should be removed from the end
+tc0 = BTContainer(data=[
+    # D  O     H     L     C     V    B  S
+    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
+    [1, 5000, 5025, 4975, 4987, 6172, 0, 1]],  # enter trade (signal on last candle)
+    stop_loss=-0.99, roi=float('inf'), profit_perc=0.00,
+    trades=[]
+)
+
+# Two complete trades within dataframe(with sell hit for all)
+tc1 = BTContainer(data=[
+    # D  O     H     L     C     V    B  S
+    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
+    [1, 5000, 5025, 4975, 4987, 6172, 0, 1],  # enter trade (signal on last candle)
+    [2, 5000, 5025, 4975, 4987, 6172, 0, 0],  # exit at open
+    [3, 5000, 5025, 4975, 4987, 6172, 1, 0],  # no action
+    [4, 5000, 5025, 4975, 4987, 6172, 0, 0],  # should enter the trade
+    [5, 5000, 5025, 4975, 4987, 6172, 0, 1],  # no action
+    [6, 5000, 5025, 4975, 4987, 6172, 0, 0],  # should sell
+],
+    stop_loss=-0.99, roi=float('inf'), profit_perc=0.00,
+    trades=[BTrade(sell_reason=SellType.SELL_SIGNAL, open_tick=1, close_tick=2),
+            BTrade(sell_reason=SellType.SELL_SIGNAL, open_tick=4, close_tick=6)]
+)
+
+# 3) Entered, sl 1%, candle drops 8% => Trade closed, 1% loss
+tc2 = BTContainer(data=[
+    # D  O     H     L     C     V    B  S
+    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
+    [1, 5000, 5025, 4600, 4987, 6172, 0, 0],  # enter trade, stoploss hit
+    [2, 5000, 5025, 4975, 4987, 6172, 0, 0],
+],
+    stop_loss=-0.01, roi=float('inf'), profit_perc=-0.01,
+    trades=[BTrade(sell_reason=SellType.STOP_LOSS, open_tick=1, close_tick=1)]
+)
+
+# 4) Entered, sl 3 %, candle drops 4%, recovers to 1 % = > Trade closed, 3 % loss
+tc3 = BTContainer(data=[
+    # D  O     H     L     C     V    B  S
+    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
+    [1, 5000, 5025, 4800, 4987, 6172, 0, 0],  # enter trade, stoploss hit
+    [2, 5000, 5025, 4975, 4987, 6172, 0, 0],
+],
+    stop_loss=-0.03, roi=float('inf'), profit_perc=-0.03,
+    trades=[BTrade(sell_reason=SellType.STOP_LOSS, open_tick=1, close_tick=1)]
+)
+
+# 5) Stoploss and sell are hit. should sell on stoploss
+tc4 = BTContainer(data=[
+    # D  O     H     L     C     V    B  S
+    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
+    [1, 5000, 5025, 4800, 4987, 6172, 0, 1],  # enter trade, stoploss hit, sell signal
+    [2, 5000, 5025, 4975, 4987, 6172, 0, 0],
+],
+    stop_loss=-0.03, roi=float('inf'), profit_perc=-0.03,
+    trades=[BTrade(sell_reason=SellType.STOP_LOSS, open_tick=1, close_tick=1)]
+)
+
+TESTS = [
+    tc0,
+    tc1,
+    tc2,
+    tc3,
+    tc4
+]
+
+
+@pytest.mark.parametrize("data", TESTS)
+def test_edge_results(edge_conf, mocker, caplog, data) -> None:
+    """
+    run functional tests
+    """
+    freqtrade = get_patched_freqtradebot(mocker, edge_conf)
+    edge = Edge(edge_conf, freqtrade.exchange, freqtrade.strategy)
+    frame = _build_backtest_dataframe(data.data)
+    caplog.set_level(logging.DEBUG)
+    edge.fee = 0
+
+    trades = edge._find_trades_for_stoploss_range(frame, 'TEST/BTC', [data.stop_loss])
+    results = edge._fill_calculable_fields(DataFrame(trades)) if trades else DataFrame()
+
+    print(results)
+
+    assert len(trades) == len(data.trades)
+
+    if not results.empty:
+        assert round(results["profit_percent"].sum(), 3) == round(data.profit_perc, 3)
+
+    for c, trade in enumerate(data.trades):
+        res = results.iloc[c]
+        assert res.exit_type == trade.sell_reason
+        assert res.open_time == _get_frame_time_from_offset(trade.open_tick)
+        assert res.close_time == _get_frame_time_from_offset(trade.close_tick)
+
+
+def test_adjust(mocker, edge_conf):
+    freqtrade = get_patched_freqtradebot(mocker, edge_conf)
+    edge = Edge(edge_conf, freqtrade.exchange, freqtrade.strategy)
+    mocker.patch('freqtrade.edge.Edge._cached_pairs', mocker.PropertyMock(
+        return_value={
+            'E/F': PairInfo(-0.01, 0.66, 3.71, 0.50, 1.71, 10, 60),
+            'C/D': PairInfo(-0.01, 0.66, 3.71, 0.50, 1.71, 10, 60),
+            'N/O': PairInfo(-0.01, 0.66, 3.71, 0.50, 1.71, 10, 60)
+        }
+    ))
+
+    pairs = ['A/B', 'C/D', 'E/F', 'G/H']
+    assert(edge.adjust(pairs) == ['E/F', 'C/D'])
+
+
+def test_stoploss(mocker, edge_conf):
+    freqtrade = get_patched_freqtradebot(mocker, edge_conf)
+    edge = Edge(edge_conf, freqtrade.exchange, freqtrade.strategy)
+    mocker.patch('freqtrade.edge.Edge._cached_pairs', mocker.PropertyMock(
+        return_value={
+            'E/F': PairInfo(-0.01, 0.66, 3.71, 0.50, 1.71, 10, 60),
+            'C/D': PairInfo(-0.01, 0.66, 3.71, 0.50, 1.71, 10, 60),
+            'N/O': PairInfo(-0.01, 0.66, 3.71, 0.50, 1.71, 10, 60)
+        }
+    ))
+
+    assert edge.stoploss('E/F') == -0.01
+
+
+def test_nonexisting_stoploss(mocker, edge_conf):
+    freqtrade = get_patched_freqtradebot(mocker, edge_conf)
+    edge = Edge(edge_conf, freqtrade.exchange, freqtrade.strategy)
+    mocker.patch('freqtrade.edge.Edge._cached_pairs', mocker.PropertyMock(
+        return_value={
+            'E/F': PairInfo(-0.01, 0.66, 3.71, 0.50, 1.71, 10, 60),
+        }
+    ))
+
+    assert edge.stoploss('N/O') == -0.1
+
+
+def test_stake_amount(mocker, edge_conf):
+    freqtrade = get_patched_freqtradebot(mocker, edge_conf)
+    edge = Edge(edge_conf, freqtrade.exchange, freqtrade.strategy)
+    mocker.patch('freqtrade.edge.Edge._cached_pairs', mocker.PropertyMock(
+        return_value={
+            'E/F': PairInfo(-0.02, 0.66, 3.71, 0.50, 1.71, 10, 60),
+        }
+    ))
+    free = 100
+    total = 100
+    in_trade = 25
+    assert edge.stake_amount('E/F', free, total, in_trade) == 31.25
+
+    free = 20
+    total = 100
+    in_trade = 25
+    assert edge.stake_amount('E/F', free, total, in_trade) == 20
+
+    free = 0
+    total = 100
+    in_trade = 25
+    assert edge.stake_amount('E/F', free, total, in_trade) == 0
+
+
+def test_nonexisting_stake_amount(mocker, edge_conf):
+    freqtrade = get_patched_freqtradebot(mocker, edge_conf)
+    edge = Edge(edge_conf, freqtrade.exchange, freqtrade.strategy)
+    mocker.patch('freqtrade.edge.Edge._cached_pairs', mocker.PropertyMock(
+        return_value={
+            'E/F': PairInfo(-0.11, 0.66, 3.71, 0.50, 1.71, 10, 60),
+        }
+    ))
+    # should use strategy stoploss
+    assert edge.stake_amount('N/O', 1, 2, 1) == 0.15
+
+
+def _validate_ohlc(buy_ohlc_sell_matrice):
+    for index, ohlc in enumerate(buy_ohlc_sell_matrice):
+        # if not high < open < low or not high < close < low
+        if not ohlc[3] >= ohlc[2] >= ohlc[4] or not ohlc[3] >= ohlc[5] >= ohlc[4]:
+            raise Exception('Line ' + str(index + 1) + ' of ohlc has invalid values!')
+    return True
+
+
+def _build_dataframe(buy_ohlc_sell_matrice):
+    _validate_ohlc(buy_ohlc_sell_matrice)
+    tickers = []
+    for ohlc in buy_ohlc_sell_matrice:
+        ticker = {
+            'date': ticker_start_time.shift(
+                minutes=(
+                    ohlc[0] *
+                    ticker_interval_in_minute)).timestamp *
+            1000,
+            'buy': ohlc[1],
+            'open': ohlc[2],
+            'high': ohlc[3],
+            'low': ohlc[4],
+            'close': ohlc[5],
+            'sell': ohlc[6]}
+        tickers.append(ticker)
+
+    frame = DataFrame(tickers)
+    frame['date'] = to_datetime(frame['date'],
+                                unit='ms',
+                                utc=True,
+                                infer_datetime_format=True)
+
+    return frame
+
+
+def _time_on_candle(number):
+    return np.datetime64(ticker_start_time.shift(
+        minutes=(number * ticker_interval_in_minute)).timestamp * 1000, 'ms')
+
+
+def test_edge_heartbeat_calculate(mocker, edge_conf):
+    freqtrade = get_patched_freqtradebot(mocker, edge_conf)
+    edge = Edge(edge_conf, freqtrade.exchange, freqtrade.strategy)
+    heartbeat = edge_conf['edge']['process_throttle_secs']
+
+    # should not recalculate if heartbeat not reached
+    edge._last_updated = arrow.utcnow().timestamp - heartbeat + 1
+
+    assert edge.calculate() is False
+
+
+def mocked_load_data(datadir, pairs=[], ticker_interval='0m', refresh_pairs=False,
+                     timerange=None, exchange=None):
+    hz = 0.1
+    base = 0.001
+
+    ETHBTC = [
+        [
+            ticker_start_time.shift(minutes=(x * ticker_interval_in_minute)).timestamp * 1000,
+            math.sin(x * hz) / 1000 + base,
+            math.sin(x * hz) / 1000 + base + 0.0001,
+            math.sin(x * hz) / 1000 + base - 0.0001,
+            math.sin(x * hz) / 1000 + base,
+            123.45
+        ] for x in range(0, 500)]
+
+    hz = 0.2
+    base = 0.002
+    LTCBTC = [
+        [
+            ticker_start_time.shift(minutes=(x * ticker_interval_in_minute)).timestamp * 1000,
+            math.sin(x * hz) / 1000 + base,
+            math.sin(x * hz) / 1000 + base + 0.0001,
+            math.sin(x * hz) / 1000 + base - 0.0001,
+            math.sin(x * hz) / 1000 + base,
+            123.45
+        ] for x in range(0, 500)]
+
+    pairdata = {'NEO/BTC': parse_ticker_dataframe(ETHBTC, '1h', fill_missing=True),
+                'LTC/BTC': parse_ticker_dataframe(LTCBTC, '1h', fill_missing=True)}
+    return pairdata
+
+
+def test_edge_process_downloaded_data(mocker, edge_conf):
+    edge_conf['datadir'] = None
+    freqtrade = get_patched_freqtradebot(mocker, edge_conf)
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', MagicMock(return_value=0.001))
+    mocker.patch('freqtrade.data.history.load_data', mocked_load_data)
+    edge = Edge(edge_conf, freqtrade.exchange, freqtrade.strategy)
+
+    assert edge.calculate()
+    assert len(edge._cached_pairs) == 2
+    assert edge._last_updated <= arrow.utcnow().timestamp + 2
+
+
+def test_process_expectancy(mocker, edge_conf):
+    edge_conf['edge']['min_trade_number'] = 2
+    freqtrade = get_patched_freqtradebot(mocker, edge_conf)
+
+    def get_fee():
+        return 0.001
+
+    freqtrade.exchange.get_fee = get_fee
+    edge = Edge(edge_conf, freqtrade.exchange, freqtrade.strategy)
+
+    trades = [
+        {'pair': 'TEST/BTC',
+         'stoploss': -0.9,
+         'profit_percent': '',
+         'profit_abs': '',
+         'open_time': np.datetime64('2018-10-03T00:05:00.000000000'),
+         'close_time': np.datetime64('2018-10-03T00:10:00.000000000'),
+         'open_index': 1,
+         'close_index': 1,
+         'trade_duration': '',
+         'open_rate': 17,
+         'close_rate': 17,
+         'exit_type': 'sell_signal'},
+
+        {'pair': 'TEST/BTC',
+         'stoploss': -0.9,
+         'profit_percent': '',
+         'profit_abs': '',
+         'open_time': np.datetime64('2018-10-03T00:20:00.000000000'),
+         'close_time': np.datetime64('2018-10-03T00:25:00.000000000'),
+         'open_index': 4,
+         'close_index': 4,
+         'trade_duration': '',
+         'open_rate': 20,
+         'close_rate': 20,
+         'exit_type': 'sell_signal'},
+
+        {'pair': 'TEST/BTC',
+         'stoploss': -0.9,
+         'profit_percent': '',
+         'profit_abs': '',
+         'open_time': np.datetime64('2018-10-03T00:30:00.000000000'),
+         'close_time': np.datetime64('2018-10-03T00:40:00.000000000'),
+         'open_index': 6,
+         'close_index': 7,
+         'trade_duration': '',
+         'open_rate': 26,
+         'close_rate': 34,
+         'exit_type': 'sell_signal'}
+    ]
+
+    trades_df = DataFrame(trades)
+    trades_df = edge._fill_calculable_fields(trades_df)
+    final = edge._process_expectancy(trades_df)
+    assert len(final) == 1
+
+    assert 'TEST/BTC' in final
+    assert final['TEST/BTC'].stoploss == -0.9
+    assert round(final['TEST/BTC'].winrate, 10) == 0.3333333333
+    assert round(final['TEST/BTC'].risk_reward_ratio, 10) == 306.5384615384
+    assert round(final['TEST/BTC'].required_risk_reward, 10) == 2.0
+    assert round(final['TEST/BTC'].expectancy, 10) == 101.5128205128

freqtrade/tests/exchange/test_exchange.py

@@ -1,5 +1,6 @@
 # pragma pylint: disable=missing-docstring, C0103, bad-continuation, global-statement
 # pragma pylint: disable=protected-access
+import copy
 import logging
 from datetime import datetime
 from random import randint
@@ -8,6 +9,7 @@ from unittest.mock import Mock, MagicMock, PropertyMock
 import arrow
 import ccxt
 import pytest
+from pandas import DataFrame
 
 from freqtrade import DependencyException, OperationalException, TemporaryError
 from freqtrade.exchange import API_RETRY_COUNT, Exchange
@@ -56,6 +58,32 @@ def test_init(default_conf, mocker, caplog):
     assert log_has('Instance is running with dry_run enabled', caplog.record_tuples)
 
 
+def test_init_ccxt_kwargs(default_conf, mocker, caplog):
+    mocker.patch('freqtrade.exchange.Exchange._load_markets', MagicMock(return_value={}))
+    caplog.set_level(logging.INFO)
+    conf = copy.deepcopy(default_conf)
+    conf['exchange']['ccxt_async_config'] = {'aiohttp_trust_env': True}
+    ex = Exchange(conf)
+    assert log_has("Applying additional ccxt config: {'aiohttp_trust_env': True}",
+                   caplog.record_tuples)
+    assert ex._api_async.aiohttp_trust_env
+    assert not ex._api.aiohttp_trust_env
+
+    # Reset logging and config
+    caplog.clear()
+    conf = copy.deepcopy(default_conf)
+    conf['exchange']['ccxt_config'] = {'TestKWARG': 11}
+    ex = Exchange(conf)
+    assert not log_has("Applying additional ccxt config: {'aiohttp_trust_env': True}",
+                       caplog.record_tuples)
+    assert not ex._api_async.aiohttp_trust_env
+    assert hasattr(ex._api, 'TestKWARG')
+    assert ex._api.TestKWARG == 11
+    assert not hasattr(ex._api_async, 'TestKWARG')
+    assert log_has("Applying additional ccxt config: {'TestKWARG': 11}",
+                   caplog.record_tuples)
+
+
 def test_destroy(default_conf, mocker, caplog):
     caplog.set_level(logging.DEBUG)
     get_patched_exchange(mocker, default_conf)
@@ -328,6 +356,59 @@ def test_validate_timeframes_not_in_config(default_conf, mocker):
     Exchange(default_conf)
 
 
+def test_validate_order_types(default_conf, mocker):
+    api_mock = MagicMock()
+
+    type(api_mock).has = PropertyMock(return_value={'createMarketOrder': True})
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
+    mocker.patch('freqtrade.exchange.Exchange._load_markets', MagicMock(return_value={}))
+    mocker.patch('freqtrade.exchange.Exchange.validate_timeframes', MagicMock())
+    mocker.patch('freqtrade.exchange.Exchange.name', 'Bittrex')
+    default_conf['order_types'] = {
+        'buy': 'limit',
+        'sell': 'limit',
+        'stoploss': 'market',
+        'stoploss_on_exchange': False
+    }
+
+    Exchange(default_conf)
+
+    type(api_mock).has = PropertyMock(return_value={'createMarketOrder': False})
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
+
+    default_conf['order_types'] = {
+        'buy': 'limit',
+        'sell': 'limit',
+        'stoploss': 'market',
+        'stoploss_on_exchange': 'false'
+    }
+
+    with pytest.raises(OperationalException,
+                       match=r'Exchange .* does not support market orders.'):
+        Exchange(default_conf)
+
+    default_conf['order_types'] = {
+        'buy': 'limit',
+        'sell': 'limit',
+        'stoploss': 'limit',
+        'stoploss_on_exchange': True
+    }
+
+    with pytest.raises(OperationalException,
+                       match=r'On exchange stoploss is not supported for .*'):
+        Exchange(default_conf)
+
+
+def test_validate_order_types_not_in_config(default_conf, mocker):
+    api_mock = MagicMock()
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
+    mocker.patch('freqtrade.exchange.Exchange._load_markets', MagicMock(return_value={}))
+    mocker.patch('freqtrade.exchange.Exchange.validate_timeframes', MagicMock())
+
+    conf = copy.deepcopy(default_conf)
+    Exchange(conf)
+
+
 def test_exchange_has(default_conf, mocker):
     exchange = get_patched_exchange(mocker, default_conf)
     assert not exchange.exchange_has('ASDFASDF')
@@ -346,7 +427,8 @@ def test_buy_dry_run(default_conf, mocker):
     default_conf['dry_run'] = True
     exchange = get_patched_exchange(mocker, default_conf)
 
-    order = exchange.buy(pair='ETH/BTC', rate=200, amount=1)
+    order = exchange.buy(pair='ETH/BTC', ordertype='limit',
+                         amount=1, rate=200, time_in_force='gtc')
     assert 'id' in order
     assert 'dry_run_buy_' in order['id']
 
@@ -354,47 +436,106 @@ def test_buy_dry_run(default_conf, mocker):
 def test_buy_prod(default_conf, mocker):
     api_mock = MagicMock()
     order_id = 'test_prod_buy_{}'.format(randint(0, 10 ** 6))
-    api_mock.create_limit_buy_order = MagicMock(return_value={
+    order_type = 'market'
+    time_in_force = 'gtc'
+    api_mock.create_order = MagicMock(return_value={
         'id': order_id,
         'info': {
             'foo': 'bar'
         }
     })
     default_conf['dry_run'] = False
+    mocker.patch('freqtrade.exchange.Exchange.symbol_amount_prec', lambda s, x, y: y)
+    mocker.patch('freqtrade.exchange.Exchange.symbol_price_prec', lambda s, x, y: y)
     exchange = get_patched_exchange(mocker, default_conf, api_mock)
 
-    order = exchange.buy(pair='ETH/BTC', rate=200, amount=1)
+    order = exchange.buy(pair='ETH/BTC', ordertype=order_type,
+                         amount=1, rate=200, time_in_force=time_in_force)
+
     assert 'id' in order
     assert 'info' in order
     assert order['id'] == order_id
+    assert api_mock.create_order.call_args[0][0] == 'ETH/BTC'
+    assert api_mock.create_order.call_args[0][1] == order_type
+    assert api_mock.create_order.call_args[0][2] == 'buy'
+    assert api_mock.create_order.call_args[0][3] == 1
+    assert api_mock.create_order.call_args[0][4] is None
+
+    api_mock.create_order.reset_mock()
+    order_type = 'limit'
+    order = exchange.buy(
+        pair='ETH/BTC',
+        ordertype=order_type,
+        amount=1,
+        rate=200,
+        time_in_force=time_in_force)
+    assert api_mock.create_order.call_args[0][0] == 'ETH/BTC'
+    assert api_mock.create_order.call_args[0][1] == order_type
+    assert api_mock.create_order.call_args[0][2] == 'buy'
+    assert api_mock.create_order.call_args[0][3] == 1
+    assert api_mock.create_order.call_args[0][4] == 200
 
     # test exception handling
     with pytest.raises(DependencyException):
-        api_mock.create_limit_buy_order = MagicMock(side_effect=ccxt.InsufficientFunds)
+        api_mock.create_order = MagicMock(side_effect=ccxt.InsufficientFunds)
         exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.buy(pair='ETH/BTC', rate=200, amount=1)
+        exchange.buy(pair='ETH/BTC', ordertype=order_type,
+                     amount=1, rate=200, time_in_force=time_in_force)
 
     with pytest.raises(DependencyException):
-        api_mock.create_limit_buy_order = MagicMock(side_effect=ccxt.InvalidOrder)
+        api_mock.create_order = MagicMock(side_effect=ccxt.InvalidOrder)
         exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.buy(pair='ETH/BTC', rate=200, amount=1)
+        exchange.buy(pair='ETH/BTC', ordertype=order_type,
+                     amount=1, rate=200, time_in_force=time_in_force)
 
     with pytest.raises(TemporaryError):
-        api_mock.create_limit_buy_order = MagicMock(side_effect=ccxt.NetworkError)
+        api_mock.create_order = MagicMock(side_effect=ccxt.NetworkError)
         exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.buy(pair='ETH/BTC', rate=200, amount=1)
+        exchange.buy(pair='ETH/BTC', ordertype=order_type,
+                     amount=1, rate=200, time_in_force=time_in_force)
 
     with pytest.raises(OperationalException):
-        api_mock.create_limit_buy_order = MagicMock(side_effect=ccxt.BaseError)
+        api_mock.create_order = MagicMock(side_effect=ccxt.BaseError)
         exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.buy(pair='ETH/BTC', rate=200, amount=1)
+        exchange.buy(pair='ETH/BTC', ordertype=order_type,
+                     amount=1, rate=200, time_in_force=time_in_force)
+
+
+def test_buy_considers_time_in_force(default_conf, mocker):
+    api_mock = MagicMock()
+    order_id = 'test_prod_buy_{}'.format(randint(0, 10 ** 6))
+    order_type = 'market'
+    time_in_force = 'ioc'
+    api_mock.create_order = MagicMock(return_value={
+        'id': order_id,
+        'info': {
+            'foo': 'bar'
+        }
+    })
+    default_conf['dry_run'] = False
+    mocker.patch('freqtrade.exchange.Exchange.symbol_amount_prec', lambda s, x, y: y)
+    mocker.patch('freqtrade.exchange.Exchange.symbol_price_prec', lambda s, x, y: y)
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+
+    order = exchange.buy(pair='ETH/BTC', ordertype=order_type,
+                         amount=1, rate=200, time_in_force=time_in_force)
+
+    assert 'id' in order
+    assert 'info' in order
+    assert order['id'] == order_id
+    assert api_mock.create_order.call_args[0][0] == 'ETH/BTC'
+    assert api_mock.create_order.call_args[0][1] == order_type
+    assert api_mock.create_order.call_args[0][2] == 'buy'
+    assert api_mock.create_order.call_args[0][3] == 1
+    assert api_mock.create_order.call_args[0][4] is None
+    assert api_mock.create_order.call_args[0][5] == {'timeInForce': 'ioc'}
 
 
 def test_sell_dry_run(default_conf, mocker):
     default_conf['dry_run'] = True
     exchange = get_patched_exchange(mocker, default_conf)
 
-    order = exchange.sell(pair='ETH/BTC', rate=200, amount=1)
+    order = exchange.sell(pair='ETH/BTC', ordertype='limit', amount=1, rate=200)
     assert 'id' in order
     assert 'dry_run_sell_' in order['id']
 
@@ -402,7 +543,8 @@ def test_sell_dry_run(default_conf, mocker):
 def test_sell_prod(default_conf, mocker):
     api_mock = MagicMock()
     order_id = 'test_prod_sell_{}'.format(randint(0, 10 ** 6))
-    api_mock.create_limit_sell_order = MagicMock(return_value={
+    order_type = 'market'
+    api_mock.create_order = MagicMock(return_value={
         'id': order_id,
         'info': {
             'foo': 'bar'
@@ -411,32 +553,48 @@ def test_sell_prod(default_conf, mocker):
     default_conf['dry_run'] = False
 
     exchange = get_patched_exchange(mocker, default_conf, api_mock)
+    mocker.patch('freqtrade.exchange.Exchange.symbol_amount_prec', lambda s, x, y: y)
+    mocker.patch('freqtrade.exchange.Exchange.symbol_price_prec', lambda s, x, y: y)
 
-    order = exchange.sell(pair='ETH/BTC', rate=200, amount=1)
+    order = exchange.sell(pair='ETH/BTC', ordertype=order_type, amount=1, rate=200)
     assert 'id' in order
     assert 'info' in order
     assert order['id'] == order_id
+    assert api_mock.create_order.call_args[0][0] == 'ETH/BTC'
+    assert api_mock.create_order.call_args[0][1] == order_type
+    assert api_mock.create_order.call_args[0][2] == 'sell'
+    assert api_mock.create_order.call_args[0][3] == 1
+    assert api_mock.create_order.call_args[0][4] is None
+
+    api_mock.create_order.reset_mock()
+    order_type = 'limit'
+    order = exchange.sell(pair='ETH/BTC', ordertype=order_type, amount=1, rate=200)
+    assert api_mock.create_order.call_args[0][0] == 'ETH/BTC'
+    assert api_mock.create_order.call_args[0][1] == order_type
+    assert api_mock.create_order.call_args[0][2] == 'sell'
+    assert api_mock.create_order.call_args[0][3] == 1
+    assert api_mock.create_order.call_args[0][4] == 200
 
     # test exception handling
     with pytest.raises(DependencyException):
-        api_mock.create_limit_sell_order = MagicMock(side_effect=ccxt.InsufficientFunds)
+        api_mock.create_order = MagicMock(side_effect=ccxt.InsufficientFunds)
         exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.sell(pair='ETH/BTC', rate=200, amount=1)
+        exchange.sell(pair='ETH/BTC', ordertype=order_type, amount=1, rate=200)
 
     with pytest.raises(DependencyException):
-        api_mock.create_limit_sell_order = MagicMock(side_effect=ccxt.InvalidOrder)
+        api_mock.create_order = MagicMock(side_effect=ccxt.InvalidOrder)
         exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.sell(pair='ETH/BTC', rate=200, amount=1)
+        exchange.sell(pair='ETH/BTC', ordertype=order_type, amount=1, rate=200)
 
     with pytest.raises(TemporaryError):
-        api_mock.create_limit_sell_order = MagicMock(side_effect=ccxt.NetworkError)
+        api_mock.create_order = MagicMock(side_effect=ccxt.NetworkError)
         exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.sell(pair='ETH/BTC', rate=200, amount=1)
+        exchange.sell(pair='ETH/BTC', ordertype=order_type, amount=1, rate=200)
 
     with pytest.raises(OperationalException):
-        api_mock.create_limit_sell_order = MagicMock(side_effect=ccxt.BaseError)
+        api_mock.create_order = MagicMock(side_effect=ccxt.BaseError)
         exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.sell(pair='ETH/BTC', rate=200, amount=1)
+        exchange.sell(pair='ETH/BTC', ordertype=order_type, amount=1, rate=200)
 
 
 def test_get_balance_dry_run(default_conf, mocker):
@@ -545,6 +703,7 @@ def test_get_ticker(default_conf, mocker):
         'last': 0.0001,
     }
     api_mock.fetch_ticker = MagicMock(return_value=tick)
+    api_mock.markets = {'ETH/BTC': {}}
     exchange = get_patched_exchange(mocker, default_conf, api_mock)
     # retrieve original ticker
     ticker = exchange.get_ticker(pair='ETH/BTC')
@@ -587,6 +746,9 @@ def test_get_ticker(default_conf, mocker):
     exchange = get_patched_exchange(mocker, default_conf, api_mock)
     exchange.get_ticker(pair='ETH/BTC', refresh=True)
 
+    with pytest.raises(DependencyException, match=r'Pair XRP/ETH not available'):
+        exchange.get_ticker(pair='XRP/ETH', refresh=True)
+
 
 def test_get_history(default_conf, mocker, caplog):
     exchange = get_patched_exchange(mocker, default_conf)
@@ -603,7 +765,7 @@ def test_get_history(default_conf, mocker, caplog):
     pair = 'ETH/BTC'
 
     async def mock_candle_hist(pair, tick_interval, since_ms):
-        return pair, tick
+        return pair, tick_interval, tick
 
     exchange._async_get_candle_history = Mock(wraps=mock_candle_hist)
     # one_call calculation * 1.8 should do 2 calls
@@ -616,15 +778,23 @@ def test_get_history(default_conf, mocker, caplog):
     assert len(ret) == 2
 
 
-def test_refresh_tickers(mocker, default_conf, caplog) -> None:
+def test_refresh_latest_ohlcv(mocker, default_conf, caplog) -> None:
     tick = [
         [
-            1511686200000,  # unix timestamp ms
+            (arrow.utcnow().timestamp - 1) * 1000,  # unix timestamp ms
             1,  # open
             2,  # high
             3,  # low
             4,  # close
             5,  # volume (in quote currency)
+        ],
+        [
+            arrow.utcnow().timestamp * 1000,  # unix timestamp ms
+            3,  # open
+            1,  # high
+            4,  # low
+            6,  # close
+            5,  # volume (in quote currency)
         ]
     ]
 
@@ -632,15 +802,31 @@ def test_refresh_tickers(mocker, default_conf, caplog) -> None:
     exchange = get_patched_exchange(mocker, default_conf)
     exchange._api_async.fetch_ohlcv = get_mock_coro(tick)
 
-    pairs = ['IOTA/ETH', 'XRP/ETH']
+    pairs = [('IOTA/ETH', '5m'), ('XRP/ETH', '5m')]
     # empty dicts
-    assert not exchange.klines
-    exchange.refresh_tickers(['IOTA/ETH', 'XRP/ETH'], '5m')
+    assert not exchange._klines
+    exchange.refresh_latest_ohlcv(pairs)
 
-    assert log_has(f'Refreshing klines for {len(pairs)} pairs', caplog.record_tuples)
-    assert exchange.klines
+    assert log_has(f'Refreshing ohlcv data for {len(pairs)} pairs', caplog.record_tuples)
+    assert exchange._klines
+    assert exchange._api_async.fetch_ohlcv.call_count == 2
     for pair in pairs:
-        assert exchange.klines[pair]
+        assert isinstance(exchange.klines(pair), DataFrame)
+        assert len(exchange.klines(pair)) > 0
+
+        # klines function should return a different object on each call
+        # if copy is "True"
+        assert exchange.klines(pair) is not exchange.klines(pair)
+        assert exchange.klines(pair) is not exchange.klines(pair, copy=True)
+        assert exchange.klines(pair, copy=True) is not exchange.klines(pair, copy=True)
+        assert exchange.klines(pair, copy=False) is exchange.klines(pair, copy=False)
+
+    # test caching
+    exchange.refresh_latest_ohlcv([('IOTA/ETH', '5m'), ('XRP/ETH', '5m')])
+
+    assert exchange._api_async.fetch_ohlcv.call_count == 2
+    assert log_has(f"Using cached ohlcv data for {pairs[0][0]}, {pairs[0][1]} ...",
+                   caplog.record_tuples)
 
 
 @pytest.mark.asyncio
@@ -665,15 +851,12 @@ async def test__async_get_candle_history(default_conf, mocker, caplog):
     pair = 'ETH/BTC'
     res = await exchange._async_get_candle_history(pair, "5m")
     assert type(res) is tuple
-    assert len(res) == 2
+    assert len(res) == 3
     assert res[0] == pair
-    assert res[1] == tick
+    assert res[1] == "5m"
+    assert res[2] == tick
     assert exchange._api_async.fetch_ohlcv.call_count == 1
-    assert not log_has(f"Using cached klines data for {pair} ...", caplog.record_tuples)
-    # test caching
-    res = await exchange._async_get_candle_history(pair, "5m")
-    assert exchange._api_async.fetch_ohlcv.call_count == 1
-    assert log_has(f"Using cached klines data for {pair} ...", caplog.record_tuples)
+    assert not log_has(f"Using cached ohlcv data for {pair} ...", caplog.record_tuples)
 
     # exchange = Exchange(default_conf)
     await async_ccxt_exception(mocker, default_conf, MagicMock(),
@@ -702,44 +885,38 @@ async def test__async_get_candle_history_empty(default_conf, mocker, caplog):
     pair = 'ETH/BTC'
     res = await exchange._async_get_candle_history(pair, "5m")
     assert type(res) is tuple
-    assert len(res) == 2
+    assert len(res) == 3
     assert res[0] == pair
-    assert res[1] == tick
+    assert res[1] == "5m"
+    assert res[2] == tick
     assert exchange._api_async.fetch_ohlcv.call_count == 1
 
 
-@pytest.mark.asyncio
-async def test_async_get_candles_history(default_conf, mocker):
-    tick = [
-        [
-            1511686200000,  # unix timestamp ms
-            1,  # open
-            2,  # high
-            3,  # low
-            4,  # close
-            5,  # volume (in quote currency)
-        ]
-    ]
+def test_refresh_latest_ohlcv_inv_result(default_conf, mocker, caplog):
 
-    async def mock_get_candle_hist(pair, tick_interval, since_ms=None):
-        return (pair, tick)
+    async def mock_get_candle_hist(pair, *args, **kwargs):
+        if pair == 'ETH/BTC':
+            return [[]]
+        else:
+            raise TypeError()
 
     exchange = get_patched_exchange(mocker, default_conf)
-    # Monkey-patch async function
-    exchange._api_async.fetch_ohlcv = get_mock_coro(tick)
 
-    exchange._async_get_candle_history = Mock(wraps=mock_get_candle_hist)
+    # Monkey-patch async function with empty result
+    exchange._api_async.fetch_ohlcv = MagicMock(side_effect=mock_get_candle_hist)
+
+    pairs = [("ETH/BTC", "5m"), ("XRP/BTC", "5m")]
+    res = exchange.refresh_latest_ohlcv(pairs)
+    assert exchange._klines
+    assert exchange._api_async.fetch_ohlcv.call_count == 2
 
-    pairs = ['ETH/BTC', 'XRP/BTC']
-    res = await exchange.async_get_candles_history(pairs, "5m")
     assert type(res) is list
     assert len(res) == 2
-    assert type(res[0]) is tuple
-    assert res[0][0] == pairs[0]
-    assert res[0][1] == tick
-    assert res[1][0] == pairs[1]
-    assert res[1][1] == tick
-    assert exchange._async_get_candle_history.call_count == 2
+    # Test that each is in list at least once as order is not guaranteed
+    assert type(res[0]) is tuple or type(res[1]) is tuple
+    assert type(res[0]) is TypeError or type(res[1]) is TypeError
+    assert log_has("Error loading ETH/BTC. Result was [[]].", caplog.record_tuples)
+    assert log_has("Async code raised an exception: TypeError", caplog.record_tuples)
 
 
 def test_get_order_book(default_conf, mocker, order_book_l2):
@@ -780,65 +957,10 @@ def make_fetch_ohlcv_mock(data):
     return fetch_ohlcv_mock
 
 
-def test_get_candle_history(default_conf, mocker):
-    api_mock = MagicMock()
-    tick = [
-        [
-            1511686200000,  # unix timestamp ms
-            1,  # open
-            2,  # high
-            3,  # low
-            4,  # close
-            5,  # volume (in quote currency)
-        ]
-    ]
-    type(api_mock).has = PropertyMock(return_value={'fetchOHLCV': True})
-    api_mock.fetch_ohlcv = MagicMock(side_effect=make_fetch_ohlcv_mock(tick))
-    exchange = get_patched_exchange(mocker, default_conf, api_mock)
-
-    # retrieve original ticker
-    ticks = exchange.get_candle_history('ETH/BTC', default_conf['ticker_interval'])
-    assert ticks[0][0] == 1511686200000
-    assert ticks[0][1] == 1
-    assert ticks[0][2] == 2
-    assert ticks[0][3] == 3
-    assert ticks[0][4] == 4
-    assert ticks[0][5] == 5
-
-    # change ticker and ensure tick changes
-    new_tick = [
-        [
-            1511686210000,  # unix timestamp ms
-            6,  # open
-            7,  # high
-            8,  # low
-            9,  # close
-            10,  # volume (in quote currency)
-        ]
-    ]
-    api_mock.fetch_ohlcv = MagicMock(side_effect=make_fetch_ohlcv_mock(new_tick))
-    exchange = get_patched_exchange(mocker, default_conf, api_mock)
-
-    ticks = exchange.get_candle_history('ETH/BTC', default_conf['ticker_interval'])
-    assert ticks[0][0] == 1511686210000
-    assert ticks[0][1] == 6
-    assert ticks[0][2] == 7
-    assert ticks[0][3] == 8
-    assert ticks[0][4] == 9
-    assert ticks[0][5] == 10
-
-    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
-                           "get_candle_history", "fetch_ohlcv",
-                           pair='ABCD/BTC', tick_interval=default_conf['ticker_interval'])
-
-    with pytest.raises(OperationalException, match=r'Exchange .* does not support.*'):
-        api_mock.fetch_ohlcv = MagicMock(side_effect=ccxt.NotSupported)
-        exchange = get_patched_exchange(mocker, default_conf, api_mock)
-        exchange.get_candle_history(pair='ABCD/BTC', tick_interval=default_conf['ticker_interval'])
-
-
-def test_get_candle_history_sort(default_conf, mocker):
-    api_mock = MagicMock()
+@pytest.mark.asyncio
+async def test___async_get_candle_history_sort(default_conf, mocker):
+    def sort_data(data, key):
+        return sorted(data, key=key)
 
     # GDAX use-case (real data from GDAX)
     # This ticker history is ordered DESC (newest first, oldest last)
@@ -854,13 +976,15 @@ def test_get_candle_history_sort(default_conf, mocker):
         [1527830700000, 0.07652, 0.07652, 0.07651, 0.07652, 10.04822687],
         [1527830400000, 0.07649, 0.07651, 0.07649, 0.07651, 2.5734867]
     ]
-    type(api_mock).has = PropertyMock(return_value={'fetchOHLCV': True})
-    api_mock.fetch_ohlcv = MagicMock(side_effect=make_fetch_ohlcv_mock(tick))
-
-    exchange = get_patched_exchange(mocker, default_conf, api_mock)
-
+    exchange = get_patched_exchange(mocker, default_conf)
+    exchange._api_async.fetch_ohlcv = get_mock_coro(tick)
+    sort_mock = mocker.patch('freqtrade.exchange.sorted', MagicMock(side_effect=sort_data))
     # Test the ticker history sort
-    ticks = exchange.get_candle_history('ETH/BTC', default_conf['ticker_interval'])
+    res = await exchange._async_get_candle_history('ETH/BTC', default_conf['ticker_interval'])
+    assert res[0] == 'ETH/BTC'
+    ticks = res[2]
+
+    assert sort_mock.call_count == 1
     assert ticks[0][0] == 1527830400000
     assert ticks[0][1] == 0.07649
     assert ticks[0][2] == 0.07651
@@ -889,11 +1013,16 @@ def test_get_candle_history_sort(default_conf, mocker):
         [1527830100000, 0.076695, 0.07671, 0.07624171, 0.07671, 1.80689244],
         [1527830400000, 0.07671, 0.07674399, 0.07629216, 0.07655213, 2.31452783]
     ]
-    type(api_mock).has = PropertyMock(return_value={'fetchOHLCV': True})
-    api_mock.fetch_ohlcv = MagicMock(side_effect=make_fetch_ohlcv_mock(tick))
-    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+    exchange._api_async.fetch_ohlcv = get_mock_coro(tick)
+    # Reset sort mock
+    sort_mock = mocker.patch('freqtrade.exchange.sorted', MagicMock(side_effect=sort_data))
     # Test the ticker history sort
-    ticks = exchange.get_candle_history('ETH/BTC', default_conf['ticker_interval'])
+    res = await exchange._async_get_candle_history('ETH/BTC', default_conf['ticker_interval'])
+    assert res[0] == 'ETH/BTC'
+    assert res[1] == default_conf['ticker_interval']
+    ticks = res[2]
+    # Sorted not called again - data is already in order
+    assert sort_mock.call_count == 0
     assert ticks[0][0] == 1527827700000
     assert ticks[0][1] == 0.07659999
     assert ticks[0][2] == 0.0766
@@ -1076,3 +1205,85 @@ def test_get_fee(default_conf, mocker):
 
     ccxt_exceptionhandlers(mocker, default_conf, api_mock,
                            'get_fee', 'calculate_fee')
+
+
+def test_stoploss_limit_order(default_conf, mocker):
+    api_mock = MagicMock()
+    order_id = 'test_prod_buy_{}'.format(randint(0, 10 ** 6))
+    order_type = 'stop_loss_limit'
+
+    api_mock.create_order = MagicMock(return_value={
+        'id': order_id,
+        'info': {
+            'foo': 'bar'
+        }
+    })
+
+    default_conf['dry_run'] = False
+    mocker.patch('freqtrade.exchange.Exchange.symbol_amount_prec', lambda s, x, y: y)
+    mocker.patch('freqtrade.exchange.Exchange.symbol_price_prec', lambda s, x, y: y)
+
+    exchange = get_patched_exchange(mocker, default_conf, api_mock, 'binance')
+
+    with pytest.raises(OperationalException):
+        order = exchange.stoploss_limit(pair='ETH/BTC', amount=1, stop_price=190, rate=200)
+
+    api_mock.create_order.reset_mock()
+
+    order = exchange.stoploss_limit(pair='ETH/BTC', amount=1, stop_price=220, rate=200)
+
+    assert 'id' in order
+    assert 'info' in order
+    assert order['id'] == order_id
+    assert api_mock.create_order.call_args[0][0] == 'ETH/BTC'
+    assert api_mock.create_order.call_args[0][1] == order_type
+    assert api_mock.create_order.call_args[0][2] == 'sell'
+    assert api_mock.create_order.call_args[0][3] == 1
+    assert api_mock.create_order.call_args[0][4] == 200
+    assert api_mock.create_order.call_args[0][5] == {'stopPrice': 220}
+
+    # test exception handling
+    with pytest.raises(DependencyException):
+        api_mock.create_order = MagicMock(side_effect=ccxt.InsufficientFunds)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.stoploss_limit(pair='ETH/BTC', amount=1, stop_price=220, rate=200)
+
+    with pytest.raises(DependencyException):
+        api_mock.create_order = MagicMock(side_effect=ccxt.InvalidOrder)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.stoploss_limit(pair='ETH/BTC', amount=1, stop_price=220, rate=200)
+
+    with pytest.raises(TemporaryError):
+        api_mock.create_order = MagicMock(side_effect=ccxt.NetworkError)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.stoploss_limit(pair='ETH/BTC', amount=1, stop_price=220, rate=200)
+
+    with pytest.raises(OperationalException):
+        api_mock.create_order = MagicMock(side_effect=ccxt.BaseError)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.stoploss_limit(pair='ETH/BTC', amount=1, stop_price=220, rate=200)
+
+
+def test_stoploss_limit_order_dry_run(default_conf, mocker):
+    api_mock = MagicMock()
+    order_type = 'stop_loss_limit'
+    default_conf['dry_run'] = True
+    mocker.patch('freqtrade.exchange.Exchange.symbol_amount_prec', lambda s, x, y: y)
+    mocker.patch('freqtrade.exchange.Exchange.symbol_price_prec', lambda s, x, y: y)
+
+    exchange = get_patched_exchange(mocker, default_conf, api_mock, 'binance')
+
+    with pytest.raises(OperationalException):
+        order = exchange.stoploss_limit(pair='ETH/BTC', amount=1, stop_price=190, rate=200)
+
+    api_mock.create_order.reset_mock()
+
+    order = exchange.stoploss_limit(pair='ETH/BTC', amount=1, stop_price=220, rate=200)
+
+    assert 'id' in order
+    assert 'info' in order
+    assert 'type' in order
+
+    assert order['type'] == order_type
+    assert order['price'] == 220
+    assert order['amount'] == 1

freqtrade/tests/exchange/test_exchange_helpers.py

@@ -1,21 +0,0 @@
-# pragma pylint: disable=missing-docstring, C0103
-
-from freqtrade.exchange.exchange_helpers import parse_ticker_dataframe
-
-
-def test_dataframe_correct_length(result):
-    dataframe = parse_ticker_dataframe(result)
-    assert len(result.index) - 1 == len(dataframe.index)    # last partial candle removed
-
-
-def test_dataframe_correct_columns(result):
-    assert result.columns.tolist() == \
-        ['date', 'open', 'high', 'low', 'close', 'volume']
-
-
-def test_parse_ticker_dataframe(ticker_history):
-    columns = ['date', 'open', 'high', 'low', 'close', 'volume']
-
-    # Test file with BV data
-    dataframe = parse_ticker_dataframe(ticker_history)
-    assert dataframe.columns.tolist() == columns

freqtrade/tests/optimize/__init__.py

@@ -0,0 +1,46 @@
+from typing import NamedTuple, List
+
+import arrow
+from pandas import DataFrame
+
+from freqtrade.strategy.interface import SellType
+from freqtrade.constants import TICKER_INTERVAL_MINUTES
+
+ticker_start_time = arrow.get(2018, 10, 3)
+tests_ticker_interval = "1h"
+
+
+class BTrade(NamedTuple):
+    """
+    Minimalistic Trade result used for functional backtesting
+    """
+    sell_reason: SellType
+    open_tick: int
+    close_tick: int
+
+
+class BTContainer(NamedTuple):
+    """
+    Minimal BacktestContainer defining Backtest inputs and results.
+    """
+    data: List[float]
+    stop_loss: float
+    roi: float
+    trades: List[BTrade]
+    profit_perc: float
+
+
+def _get_frame_time_from_offset(offset):
+    return ticker_start_time.shift(minutes=(offset * TICKER_INTERVAL_MINUTES[tests_ticker_interval])
+                                   ).datetime.replace(tzinfo=None)
+
+
+def _build_backtest_dataframe(ticker_with_signals):
+    columns = ['date', 'open', 'high', 'low', 'close', 'volume', 'buy', 'sell']
+
+    frame = DataFrame.from_records(ticker_with_signals, columns=columns)
+    frame['date'] = frame['date'].apply(_get_frame_time_from_offset)
+    # Ensure floats are in place
+    for column in ['open', 'high', 'low', 'close', 'volume']:
+        frame[column] = frame[column].astype('float64')
+    return frame

freqtrade/tests/optimize/test_backtest_detail.py

@@ -0,0 +1,182 @@
+# pragma pylint: disable=missing-docstring, W0212, line-too-long, C0103, C0330, unused-argument
+import logging
+from unittest.mock import MagicMock
+
+from pandas import DataFrame
+import pytest
+
+
+from freqtrade.optimize import get_timeframe
+from freqtrade.optimize.backtesting import Backtesting
+from freqtrade.strategy.interface import SellType
+from freqtrade.tests.optimize import (BTrade, BTContainer, _build_backtest_dataframe,
+                                      _get_frame_time_from_offset, tests_ticker_interval)
+from freqtrade.tests.conftest import patch_exchange
+
+
+# Test 0 Minus 8% Close
+# Test with Stop-loss at 1%
+# TC1: Stop-Loss Triggered 1% loss
+tc0 = BTContainer(data=[
+    # D  O     H     L     C     V    B  S
+    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
+    [1, 5000, 5025, 4975, 4987, 6172, 0, 0],  # enter trade (signal on last candle)
+    [2, 4987, 5012, 4600, 4600, 6172, 0, 0],  # exit with stoploss hit
+    [3, 4975, 5000, 4980, 4977, 6172, 0, 0],
+    [4, 4977, 4987, 4977, 4995, 6172, 0, 0],
+    [5, 4995, 4995, 4995, 4950, 6172, 0, 0]],
+    stop_loss=-0.01, roi=1, profit_perc=-0.01,
+    trades=[BTrade(sell_reason=SellType.STOP_LOSS, open_tick=1, close_tick=2)]
+)
+
+
+# Test 1 Minus 4% Low, minus 1% close
+# Test with Stop-Loss at 3%
+# TC2: Stop-Loss Triggered 3% Loss
+tc1 = BTContainer(data=[
+    # D  O     H     L     C     V    B  S
+    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
+    [1, 5000, 5025, 4975, 4987, 6172, 0, 0],  # enter trade (signal on last candle)
+    [2, 4987, 5012, 4962, 4975, 6172, 0, 0],
+    [3, 4975, 5000, 4800, 4962, 6172, 0, 0],  # exit with stoploss hit
+    [4, 4962, 4987, 4937, 4950, 6172, 0, 0],
+    [5, 4950, 4975, 4925, 4950, 6172, 0, 0]],
+    stop_loss=-0.03, roi=1, profit_perc=-0.03,
+    trades=[BTrade(sell_reason=SellType.STOP_LOSS, open_tick=1, close_tick=3)]
+)
+
+
+# Test 3 Candle drops 4%, Recovers 1%.
+#               Entry Criteria Met
+# 	            Candle drops 20%
+# Candle Data for test 3
+# Test with Stop-Loss at 2%
+# TC3: Trade-A: Stop-Loss Triggered 2% Loss
+#          Trade-B: Stop-Loss Triggered 2% Loss
+tc2 = BTContainer(data=[
+    # D  O     H     L     C     V    B  S
+    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
+    [1, 5000, 5025, 4975, 4987, 6172, 0, 0],  # enter trade (signal on last candle)
+    [2, 4987, 5012, 4800, 4975, 6172, 0, 0],  # exit with stoploss hit
+    [3, 4975, 5000, 4950, 4962, 6172, 1, 0],
+    [4, 4975, 5000, 4950, 4962, 6172, 0, 0],  # enter trade 2 (signal on last candle)
+    [5, 4962, 4987, 4000, 4000, 6172, 0, 0],  # exit with stoploss hit
+    [6, 4950, 4975, 4975, 4950, 6172, 0, 0]],
+    stop_loss=-0.02, roi=1, profit_perc=-0.04,
+    trades=[BTrade(sell_reason=SellType.STOP_LOSS, open_tick=1, close_tick=2),
+            BTrade(sell_reason=SellType.STOP_LOSS, open_tick=4, close_tick=5)]
+)
+
+# Test 4 Minus 3% / recovery +15%
+# Candle Data for test 3 – Candle drops 3% Closed 15% up
+# Test with Stop-loss at 2% ROI 6%
+# TC4: Stop-Loss Triggered 2% Loss
+tc3 = BTContainer(data=[
+    # D  O     H     L     C     V    B  S
+    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
+    [1, 5000, 5025, 4975, 4987, 6172, 0, 0],  # enter trade (signal on last candle)
+    [2, 4987, 5750, 4850, 5750, 6172, 0, 0],  # Exit with stoploss hit
+    [3, 4975, 5000, 4950, 4962, 6172, 0, 0],
+    [4, 4962, 4987, 4937, 4950, 6172, 0, 0],
+    [5, 4950, 4975, 4925, 4950, 6172, 0, 0]],
+    stop_loss=-0.02, roi=0.06, profit_perc=-0.02,
+    trades=[BTrade(sell_reason=SellType.STOP_LOSS, open_tick=1, close_tick=2)]
+)
+
+# Test 4 / Drops 0.5% Closes +20%
+# Set stop-loss at 1% ROI 3%
+# TC5: ROI triggers 3% Gain
+tc4 = BTContainer(data=[
+    # D  O     H     L     C     V    B  S
+    [0, 5000, 5025, 4980, 4987, 6172, 1, 0],
+    [1, 5000, 5025, 4980, 4987, 6172, 0, 0],  # enter trade (signal on last candle)
+    [2, 4987, 5025, 4975, 4987, 6172, 0, 0],
+    [3, 4975, 6000, 4975, 6000, 6172, 0, 0],  # ROI
+    [4, 4962, 4987, 4972, 4950, 6172, 0, 0],
+    [5, 4950, 4975, 4925, 4950, 6172, 0, 0]],
+    stop_loss=-0.01, roi=0.03, profit_perc=0.03,
+    trades=[BTrade(sell_reason=SellType.ROI, open_tick=1, close_tick=3)]
+)
+
+# Test 6 / Drops 3% / Recovers 6% Positive / Closes 1% positve
+# Candle Data for test 6
+# Set stop-loss at 2% ROI at 5%
+# TC6: Stop-Loss triggers 2% Loss
+tc5 = BTContainer(data=[
+    # D  O     H     L     C     V    B  S
+    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
+    [1, 5000, 5025, 4975, 4987, 6172, 0, 0],  # enter trade (signal on last candle)
+    [2, 4987, 5300, 4850, 5050, 6172, 0, 0],  # Exit with stoploss
+    [3, 4975, 5000, 4950, 4962, 6172, 0, 0],
+    [4, 4962, 4987, 4972, 4950, 6172, 0, 0],
+    [5, 4950, 4975, 4925, 4950, 6172, 0, 0]],
+    stop_loss=-0.02, roi=0.05, profit_perc=-0.02,
+    trades=[BTrade(sell_reason=SellType.STOP_LOSS, open_tick=1, close_tick=2)]
+)
+
+# Test 7 - 6% Positive / 1% Negative / Close 1% Positve
+# Candle Data for test 7
+# Set stop-loss at 2% ROI at 3%
+# TC7: ROI Triggers 3% Gain
+tc6 = BTContainer(data=[
+    # D  O     H     L     C     V    B  S
+    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
+    [1, 5000, 5025, 4975, 4987, 6172, 0, 0],
+    [2, 4987, 5300, 4950, 5050, 6172, 0, 0],
+    [3, 4975, 5000, 4950, 4962, 6172, 0, 0],
+    [4, 4962, 4987, 4972, 4950, 6172, 0, 0],
+    [5, 4950, 4975, 4925, 4950, 6172, 0, 0]],
+    stop_loss=-0.02, roi=0.03, profit_perc=0.03,
+    trades=[BTrade(sell_reason=SellType.ROI, open_tick=1, close_tick=2)]
+)
+
+TESTS = [
+    tc0,
+    tc1,
+    tc2,
+    tc3,
+    tc4,
+    tc5,
+    tc6,
+]
+
+
+@pytest.mark.parametrize("data", TESTS)
+def test_backtest_results(default_conf, fee, mocker, caplog, data) -> None:
+    """
+    run functional tests
+    """
+    default_conf["stoploss"] = data.stop_loss
+    default_conf["minimal_roi"] = {"0": data.roi}
+    default_conf['ticker_interval'] = tests_ticker_interval
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', MagicMock(return_value=0.0))
+    patch_exchange(mocker)
+    frame = _build_backtest_dataframe(data.data)
+    backtesting = Backtesting(default_conf)
+    backtesting.advise_buy = lambda a, m: frame
+    backtesting.advise_sell = lambda a, m: frame
+    caplog.set_level(logging.DEBUG)
+
+    pair = 'UNITTEST/BTC'
+    # Dummy data as we mock the analyze functions
+    data_processed = {pair: DataFrame()}
+    min_date, max_date = get_timeframe({pair: frame})
+    results = backtesting.backtest(
+        {
+            'stake_amount': default_conf['stake_amount'],
+            'processed': data_processed,
+            'max_open_trades': 10,
+            'start_date': min_date,
+            'end_date': max_date,
+        }
+    )
+    print(results.T)
+
+    assert len(results) == len(data.trades)
+    assert round(results["profit_percent"].sum(), 3) == round(data.profit_perc, 3)
+
+    for c, trade in enumerate(data.trades):
+        res = results.iloc[c]
+        assert res.sell_reason == trade.sell_reason
+        assert res.open_time == _get_frame_time_from_offset(trade.open_tick)
+        assert res.close_time == _get_frame_time_from_offset(trade.close_tick)

freqtrade/tests/optimize/test_backtesting.py

@@ -11,13 +11,17 @@ import pandas as pd
 import pytest
 from arrow import Arrow
 
-from freqtrade import DependencyException, constants, optimize
+from freqtrade import DependencyException, constants
 from freqtrade.arguments import Arguments, TimeRange
+from freqtrade.data import history
+from freqtrade.data.converter import parse_ticker_dataframe
+from freqtrade.optimize import get_timeframe
 from freqtrade.optimize.backtesting import (Backtesting, setup_configuration,
                                             start)
-from freqtrade.tests.conftest import log_has, patch_exchange
-from freqtrade.strategy.interface import SellType
+from freqtrade.state import RunMode
 from freqtrade.strategy.default_strategy import DefaultStrategy
+from freqtrade.strategy.interface import SellType
+from freqtrade.tests.conftest import log_has, patch_exchange
 
 
 def get_args(args) -> List[str]:
@@ -33,22 +37,13 @@ def trim_dictlist(dict_list, num):
 
 def load_data_test(what):
     timerange = TimeRange(None, 'line', 0, -101)
-    data = optimize.load_data(None, ticker_interval='1m',
-                              pairs=['UNITTEST/BTC'], timerange=timerange)
-    pair = data['UNITTEST/BTC']
+    pair = history.load_tickerdata_file(None, ticker_interval='1m',
+                                        pair='UNITTEST/BTC', timerange=timerange)
     datalen = len(pair)
-    # Depending on the what parameter we now adjust the
-    # loaded data looks:
-    # pair :: [[    1509836520000,   unix timestamp in ms
-    #               0.00162008,      open
-    #               0.00162008,      high
-    #               0.00162008,      low
-    #               0.00162008,      close
-    #               108.14853839     base volume
-    #           ]]
+
     base = 0.001
     if what == 'raise':
-        return {'UNITTEST/BTC': [
+        data = [
             [
                 pair[x][0],  # Keep old dates
                 x * base,  # But replace O,H,L,C
@@ -57,9 +52,9 @@ def load_data_test(what):
                 x * base,
                 pair[x][5],  # Keep old volume
             ] for x in range(0, datalen)
-        ]}
+        ]
     if what == 'lower':
-        return {'UNITTEST/BTC': [
+        data = [
             [
                 pair[x][0],  # Keep old dates
                 1 - x * base,  # But replace O,H,L,C
@@ -68,10 +63,10 @@ def load_data_test(what):
                 1 - x * base,
                 pair[x][5]  # Keep old volume
             ] for x in range(0, datalen)
-        ]}
+        ]
     if what == 'sine':
         hz = 0.1  # frequency
-        return {'UNITTEST/BTC': [
+        data = [
             [
                 pair[x][0],  # Keep old dates
                 math.sin(x * hz) / 1000 + base,  # But replace O,H,L,C
@@ -80,23 +75,27 @@ def load_data_test(what):
                 math.sin(x * hz) / 1000 + base,
                 pair[x][5]  # Keep old volume
             ] for x in range(0, datalen)
-        ]}
-    return data
+        ]
+    return {'UNITTEST/BTC': parse_ticker_dataframe(data, '1m', fill_missing=True)}
 
 
 def simple_backtest(config, contour, num_results, mocker) -> None:
     patch_exchange(mocker)
+    config['ticker_interval'] = '1m'
     backtesting = Backtesting(config)
 
     data = load_data_test(contour)
-    processed = backtesting.tickerdata_to_dataframe(data)
+    processed = backtesting.strategy.tickerdata_to_dataframe(data)
+    min_date, max_date = get_timeframe(processed)
     assert isinstance(processed, dict)
     results = backtesting.backtest(
         {
             'stake_amount': config['stake_amount'],
             'processed': processed,
             'max_open_trades': 1,
-            'position_stacking': False
+            'position_stacking': False,
+            'start_date': min_date,
+            'end_date': max_date,
         }
     )
     # results :: <class 'pandas.core.frame.DataFrame'>
@@ -105,30 +104,34 @@ def simple_backtest(config, contour, num_results, mocker) -> None:
 
 def mocked_load_data(datadir, pairs=[], ticker_interval='0m', refresh_pairs=False,
                      timerange=None, exchange=None):
-    tickerdata = optimize.load_tickerdata_file(datadir, 'UNITTEST/BTC', '1m', timerange=timerange)
-    pairdata = {'UNITTEST/BTC': tickerdata}
+    tickerdata = history.load_tickerdata_file(datadir, 'UNITTEST/BTC', '1m', timerange=timerange)
+    pairdata = {'UNITTEST/BTC': parse_ticker_dataframe(tickerdata, '1m', fill_missing=True)}
     return pairdata
 
 
 # use for mock ccxt.fetch_ohlvc'
 def _load_pair_as_ticks(pair, tickfreq):
-    ticks = optimize.load_data(None, ticker_interval=tickfreq, pairs=[pair])
-    ticks = trim_dictlist(ticks, -201)
-    return ticks[pair]
+    ticks = history.load_tickerdata_file(None, ticker_interval=tickfreq, pair=pair)
+    ticks = ticks[-201:]
+    return ticks
 
 
 # FIX: fixturize this?
 def _make_backtest_conf(mocker, conf=None, pair='UNITTEST/BTC', record=None):
-    data = optimize.load_data(None, ticker_interval='8m', pairs=[pair])
+    data = history.load_data(datadir=None, ticker_interval='1m', pairs=[pair])
     data = trim_dictlist(data, -201)
     patch_exchange(mocker)
     backtesting = Backtesting(conf)
+    processed = backtesting.strategy.tickerdata_to_dataframe(data)
+    min_date, max_date = get_timeframe(processed)
     return {
         'stake_amount': conf['stake_amount'],
-        'processed': backtesting.tickerdata_to_dataframe(data),
+        'processed': processed,
         'max_open_trades': 10,
         'position_stacking': False,
-        'record': record
+        'record': record,
+        'start_date': min_date,
+        'end_date': max_date,
     }
 
 
@@ -198,12 +201,15 @@ def test_setup_configuration_without_arguments(mocker, default_conf, caplog) ->
 
     assert 'timerange' not in config
     assert 'export' not in config
+    assert 'runmode' in config
+    assert config['runmode'] == RunMode.BACKTEST
 
 
-def test_setup_configuration_with_arguments(mocker, default_conf, caplog) -> None:
+def test_setup_bt_configuration_with_arguments(mocker, default_conf, caplog) -> None:
     mocker.patch('freqtrade.configuration.open', mocker.mock_open(
         read_data=json.dumps(default_conf)
     ))
+    mocker.patch('freqtrade.configuration.Configuration._create_datadir', lambda s, c, x: x)
 
     args = [
         '--config', 'config.json',
@@ -227,6 +233,8 @@ def test_setup_configuration_with_arguments(mocker, default_conf, caplog) -> Non
     assert 'exchange' in config
     assert 'pair_whitelist' in config['exchange']
     assert 'datadir' in config
+    assert config['runmode'] == RunMode.BACKTEST
+
     assert log_has(
         'Using data folder: {} ...'.format(config['datadir']),
         caplog.record_tuples
@@ -313,22 +321,22 @@ def test_backtesting_init(mocker, default_conf) -> None:
     backtesting = Backtesting(default_conf)
     assert backtesting.config == default_conf
     assert backtesting.ticker_interval == '5m'
-    assert callable(backtesting.tickerdata_to_dataframe)
+    assert callable(backtesting.strategy.tickerdata_to_dataframe)
     assert callable(backtesting.advise_buy)
     assert callable(backtesting.advise_sell)
     get_fee.assert_called()
     assert backtesting.fee == 0.5
 
 
-def test_tickerdata_to_dataframe(default_conf, mocker) -> None:
+def test_tickerdata_to_dataframe_bt(default_conf, mocker) -> None:
     patch_exchange(mocker)
     timerange = TimeRange(None, 'line', 0, -100)
-    tick = optimize.load_tickerdata_file(None, 'UNITTEST/BTC', '1m', timerange=timerange)
-    tickerlist = {'UNITTEST/BTC': tick}
+    tick = history.load_tickerdata_file(None, 'UNITTEST/BTC', '1m', timerange=timerange)
+    tickerlist = {'UNITTEST/BTC': parse_ticker_dataframe(tick, '1m', fill_missing=True)}
 
     backtesting = Backtesting(default_conf)
-    data = backtesting.tickerdata_to_dataframe(tickerlist)
-    assert len(data['UNITTEST/BTC']) == 99
+    data = backtesting.strategy.tickerdata_to_dataframe(tickerlist)
+    assert len(data['UNITTEST/BTC']) == 102
 
     # Load strategy to compare the result between Backtesting function and strategy are the same
     strategy = DefaultStrategy(default_conf)
@@ -336,24 +344,9 @@ def test_tickerdata_to_dataframe(default_conf, mocker) -> None:
     assert data['UNITTEST/BTC'].equals(data2['UNITTEST/BTC'])
 
 
-def test_get_timeframe(default_conf, mocker) -> None:
-    patch_exchange(mocker)
-    backtesting = Backtesting(default_conf)
-
-    data = backtesting.tickerdata_to_dataframe(
-        optimize.load_data(
-            None,
-            ticker_interval='1m',
-            pairs=['UNITTEST/BTC']
-        )
-    )
-    min_date, max_date = backtesting.get_timeframe(data)
-    assert min_date.isoformat() == '2017-11-04T23:02:00+00:00'
-    assert max_date.isoformat() == '2017-11-14T22:58:00+00:00'
-
-
 def test_generate_text_table(default_conf, mocker):
     patch_exchange(mocker)
+    default_conf['max_open_trades'] = 2
     backtesting = Backtesting(default_conf)
 
     results = pd.DataFrame(
@@ -369,13 +362,13 @@ def test_generate_text_table(default_conf, mocker):
 
     result_str = (
         '| pair    |   buy count |   avg profit % |   cum profit % |   '
-        'total profit BTC | avg duration   |   profit |   loss |\n'
+        'tot profit BTC |   tot profit % | avg duration   |   profit |   loss |\n'
         '|:--------|------------:|---------------:|---------------:|'
-        '-------------------:|:---------------|---------:|-------:|\n'
-        '| ETH/BTC |           2 |          15.00 |          30.00 |         '
-        '0.60000000 | 0:20:00        |        2 |      0 |\n'
-        '| TOTAL   |           2 |          15.00 |          30.00 |         '
-        '0.60000000 | 0:20:00        |        2 |      0 |'
+        '-----------------:|---------------:|:---------------|---------:|-------:|\n'
+        '| ETH/BTC |           2 |          15.00 |          30.00 |       '
+        '0.60000000 |          15.00 | 0:20:00        |        2 |      0 |\n'
+        '| TOTAL   |           2 |          15.00 |          30.00 |       '
+        '0.60000000 |          15.00 | 0:20:00        |        2 |      0 |'
     )
     assert backtesting._generate_text_table(data={'ETH/BTC': {}}, results=results) == result_str
 
@@ -411,6 +404,7 @@ def test_generate_text_table_strategyn(default_conf, mocker):
     Test Backtesting.generate_text_table_sell_reason() method
     """
     patch_exchange(mocker)
+    default_conf['max_open_trades'] = 2
     backtesting = Backtesting(default_conf)
     results = {}
     results['ETH/BTC'] = pd.DataFrame(
@@ -438,34 +432,34 @@ def test_generate_text_table_strategyn(default_conf, mocker):
 
     result_str = (
         '| Strategy   |   buy count |   avg profit % |   cum profit % '
-        '|   total profit BTC | avg duration   |   profit |   loss |\n'
+        '|   tot profit BTC |   tot profit % | avg duration   |   profit |   loss |\n'
         '|:-----------|------------:|---------------:|---------------:'
-        '|-------------------:|:---------------|---------:|-------:|\n'
+        '|-----------------:|---------------:|:---------------|---------:|-------:|\n'
         '| ETH/BTC    |           3 |          20.00 |          60.00 '
-        '|         1.10000000 | 0:17:00        |        3 |      0 |\n'
+        '|       1.10000000 |          30.00 | 0:17:00        |        3 |      0 |\n'
         '| LTC/BTC    |           3 |          30.00 |          90.00 '
-        '|         1.30000000 | 0:20:00        |        3 |      0 |'
+        '|       1.30000000 |          45.00 | 0:20:00        |        3 |      0 |'
     )
     print(backtesting._generate_text_table_strategy(all_results=results))
     assert backtesting._generate_text_table_strategy(all_results=results) == result_str
 
 
 def test_backtesting_start(default_conf, mocker, caplog) -> None:
-    def get_timeframe(input1, input2):
+    def get_timeframe(input1):
         return Arrow(2017, 11, 14, 21, 17), Arrow(2017, 11, 14, 22, 59)
 
-    mocker.patch('freqtrade.optimize.load_data', mocked_load_data)
-    mocker.patch('freqtrade.exchange.Exchange.refresh_tickers', MagicMock())
+    mocker.patch('freqtrade.data.history.load_data', mocked_load_data)
+    mocker.patch('freqtrade.optimize.get_timeframe', get_timeframe)
+    mocker.patch('freqtrade.exchange.Exchange.refresh_latest_ohlcv', MagicMock())
     patch_exchange(mocker)
     mocker.patch.multiple(
         'freqtrade.optimize.backtesting.Backtesting',
         backtest=MagicMock(),
         _generate_text_table=MagicMock(return_value='1'),
-        get_timeframe=get_timeframe,
     )
 
     default_conf['exchange']['pair_whitelist'] = ['UNITTEST/BTC']
-    default_conf['ticker_interval'] = 1
+    default_conf['ticker_interval'] = '1m'
     default_conf['live'] = False
     default_conf['datadir'] = None
     default_conf['export'] = None
@@ -486,17 +480,17 @@ def test_backtesting_start(default_conf, mocker, caplog) -> None:
 
 
 def test_backtesting_start_no_data(default_conf, mocker, caplog) -> None:
-    def get_timeframe(input1, input2):
+    def get_timeframe(input1):
         return Arrow(2017, 11, 14, 21, 17), Arrow(2017, 11, 14, 22, 59)
 
-    mocker.patch('freqtrade.optimize.load_data', MagicMock(return_value={}))
-    mocker.patch('freqtrade.exchange.Exchange.refresh_tickers', MagicMock())
+    mocker.patch('freqtrade.data.history.load_data', MagicMock(return_value={}))
+    mocker.patch('freqtrade.optimize.get_timeframe', get_timeframe)
+    mocker.patch('freqtrade.exchange.Exchange.refresh_latest_ohlcv', MagicMock())
     patch_exchange(mocker)
     mocker.patch.multiple(
         'freqtrade.optimize.backtesting.Backtesting',
         backtest=MagicMock(),
         _generate_text_table=MagicMock(return_value='1'),
-        get_timeframe=get_timeframe,
     )
 
     default_conf['exchange']['pair_whitelist'] = ['UNITTEST/BTC']
@@ -518,15 +512,19 @@ def test_backtest(default_conf, fee, mocker) -> None:
     patch_exchange(mocker)
     backtesting = Backtesting(default_conf)
     pair = 'UNITTEST/BTC'
-    data = optimize.load_data(None, ticker_interval='5m', pairs=['UNITTEST/BTC'])
-    data = trim_dictlist(data, -200)
-    data_processed = backtesting.tickerdata_to_dataframe(data)
+    timerange = TimeRange(None, 'line', 0, -201)
+    data = history.load_data(datadir=None, ticker_interval='5m', pairs=['UNITTEST/BTC'],
+                             timerange=timerange)
+    data_processed = backtesting.strategy.tickerdata_to_dataframe(data)
+    min_date, max_date = get_timeframe(data_processed)
     results = backtesting.backtest(
         {
             'stake_amount': default_conf['stake_amount'],
             'processed': data_processed,
             'max_open_trades': 10,
-            'position_stacking': False
+            'position_stacking': False,
+            'start_date': min_date,
+            'end_date': max_date,
         }
     )
     assert not results.empty
@@ -534,18 +532,19 @@ def test_backtest(default_conf, fee, mocker) -> None:
 
     expected = pd.DataFrame(
         {'pair': [pair, pair],
-         'profit_percent': [0.00029975, 0.00056708],
-         'profit_abs': [1.49e-06, 7.6e-07],
-         'open_time': [Arrow(2018, 1, 29, 18, 40, 0).datetime,
-                       Arrow(2018, 1, 30, 3, 30, 0).datetime],
-         'close_time': [Arrow(2018, 1, 29, 22, 40, 0).datetime,
-                        Arrow(2018, 1, 30, 4, 20, 0).datetime],
-         'open_index': [77, 183],
-         'close_index': [125, 193],
-         'trade_duration': [240, 50],
+         'profit_percent': [0.0, 0.0],
+         'profit_abs': [0.0, 0.0],
+         'open_time': pd.to_datetime([Arrow(2018, 1, 29, 18, 40, 0).datetime,
+                                      Arrow(2018, 1, 30, 3, 30, 0).datetime], utc=True
+                                     ),
+         'close_time': pd.to_datetime([Arrow(2018, 1, 29, 22, 35, 0).datetime,
+                                       Arrow(2018, 1, 30, 4, 10, 0).datetime], utc=True),
+         'open_index': [78, 184],
+         'close_index': [125, 192],
+         'trade_duration': [235, 40],
          'open_at_end': [False, False],
          'open_rate': [0.104445, 0.10302485],
-         'close_rate': [0.105, 0.10359999],
+         'close_rate': [0.104969, 0.103541],
          'sell_reason': [SellType.ROI, SellType.ROI]
          })
     pd.testing.assert_frame_equal(results, expected)
@@ -555,9 +554,11 @@ def test_backtest(default_conf, fee, mocker) -> None:
         # Check open trade rate alignes to open rate
         assert ln is not None
         assert round(ln.iloc[0]["open"], 6) == round(t["open_rate"], 6)
-        # check close trade rate alignes to close rate
+        # check close trade rate alignes to close rate or is between high and low
         ln = data_pair.loc[data_pair["date"] == t["close_time"]]
-        assert round(ln.iloc[0]["open"], 6) == round(t["close_rate"], 6)
+        assert (round(ln.iloc[0]["open"], 6) == round(t["close_rate"], 6) or
+                round(ln.iloc[0]["low"], 6) < round(
+                t["close_rate"], 6) < round(ln.iloc[0]["high"], 6))
 
 
 def test_backtest_1min_ticker_interval(default_conf, fee, mocker) -> None:
@@ -565,15 +566,20 @@ def test_backtest_1min_ticker_interval(default_conf, fee, mocker) -> None:
     patch_exchange(mocker)
     backtesting = Backtesting(default_conf)
 
-    # Run a backtesting for an exiting 5min ticker_interval
-    data = optimize.load_data(None, ticker_interval='1m', pairs=['UNITTEST/BTC'])
-    data = trim_dictlist(data, -200)
+    # Run a backtesting for an exiting 1min ticker_interval
+    timerange = TimeRange(None, 'line', 0, -200)
+    data = history.load_data(datadir=None, ticker_interval='1m', pairs=['UNITTEST/BTC'],
+                             timerange=timerange)
+    processed = backtesting.strategy.tickerdata_to_dataframe(data)
+    min_date, max_date = get_timeframe(processed)
     results = backtesting.backtest(
         {
             'stake_amount': default_conf['stake_amount'],
-            'processed': backtesting.tickerdata_to_dataframe(data),
+            'processed': processed,
             'max_open_trades': 1,
-            'position_stacking': False
+            'position_stacking': False,
+            'start_date': min_date,
+            'end_date': max_date,
         }
     )
     assert not results.empty
@@ -585,7 +591,7 @@ def test_processed(default_conf, mocker) -> None:
     backtesting = Backtesting(default_conf)
 
     dict_of_tickerrows = load_data_test('raise')
-    dataframes = backtesting.tickerdata_to_dataframe(dict_of_tickerrows)
+    dataframes = backtesting.strategy.tickerdata_to_dataframe(dict_of_tickerrows)
     dataframe = dataframes['UNITTEST/BTC']
     cols = dataframe.columns
     # assert the dataframe got some of the indicator columns
@@ -596,26 +602,14 @@ def test_processed(default_conf, mocker) -> None:
 
 def test_backtest_pricecontours(default_conf, fee, mocker) -> None:
     mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
-    tests = [['raise', 18], ['lower', 0], ['sine', 16]]
+    tests = [['raise', 19], ['lower', 0], ['sine', 18]]
+    # We need to enable sell-signal - otherwise it sells on ROI!!
+    default_conf['experimental'] = {"use_sell_signal": True}
+
     for [contour, numres] in tests:
         simple_backtest(default_conf, contour, numres, mocker)
 
 
-# Test backtest using offline data (testdata directory)
-def test_backtest_ticks(default_conf, fee, mocker):
-    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
-    patch_exchange(mocker)
-    ticks = [1, 5]
-    fun = Backtesting(default_conf).advise_buy
-    for _ in ticks:
-        backtest_conf = _make_backtest_conf(mocker, conf=default_conf)
-        backtesting = Backtesting(default_conf)
-        backtesting.advise_buy = fun  # Override
-        backtesting.advise_sell = fun  # Override
-        results = backtesting.backtest(backtest_conf)
-        assert not results.empty
-
-
 def test_backtest_clash_buy_sell(mocker, default_conf):
     # Override the default buy trend function in our default_strategy
     def fun(dataframe=None, pair=None):
@@ -648,15 +642,94 @@ def test_backtest_only_sell(mocker, default_conf):
 
 def test_backtest_alternate_buy_sell(default_conf, fee, mocker):
     mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
+    mocker.patch('freqtrade.optimize.backtesting.file_dump_json', MagicMock())
     backtest_conf = _make_backtest_conf(mocker, conf=default_conf, pair='UNITTEST/BTC')
+    # We need to enable sell-signal - otherwise it sells on ROI!!
+    default_conf['experimental'] = {"use_sell_signal": True}
+    default_conf['ticker_interval'] = '1m'
     backtesting = Backtesting(default_conf)
     backtesting.advise_buy = _trend_alternate  # Override
     backtesting.advise_sell = _trend_alternate  # Override
     results = backtesting.backtest(backtest_conf)
     backtesting._store_backtest_result("test_.json", results)
-    assert len(results) == 4
+    # 200 candles in backtest data
+    # won't buy on first (shifted by 1)
+    # 100 buys signals
+    assert len(results) == 100
     # One trade was force-closed at the end
-    assert len(results.loc[results.open_at_end]) == 1
+    assert len(results.loc[results.open_at_end]) == 0
+
+
+def test_backtest_multi_pair(default_conf, fee, mocker):
+
+    def evaluate_result_multi(results, freq, max_open_trades):
+        # Find overlapping trades by expanding each trade once per period
+        # and then counting overlaps
+        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 = df2.astype(dtype={"open_time": "datetime64", "close_time": "datetime64"})
+        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 _trend_alternate_hold(dataframe=None, metadata=None):
+        """
+        Buy every 8th candle - sell every other 8th -2 (hold on to pairs a bit)
+        """
+        multi = 8
+        dataframe['buy'] = np.where(dataframe.index % multi == 0, 1, 0)
+        dataframe['sell'] = np.where((dataframe.index + multi - 2) % multi == 0, 1, 0)
+        if metadata['pair'] in('ETH/BTC', 'LTC/BTC'):
+            dataframe['buy'] = dataframe['buy'].shift(-4)
+            dataframe['sell'] = dataframe['sell'].shift(-4)
+        return dataframe
+
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
+    patch_exchange(mocker)
+    pairs = ['ADA/BTC', 'DASH/BTC', 'ETH/BTC', 'LTC/BTC', 'NXT/BTC']
+    data = history.load_data(datadir=None, ticker_interval='5m', pairs=pairs)
+    data = trim_dictlist(data, -500)
+    # We need to enable sell-signal - otherwise it sells on ROI!!
+    default_conf['experimental'] = {"use_sell_signal": True}
+    default_conf['ticker_interval'] = '5m'
+
+    backtesting = Backtesting(default_conf)
+    backtesting.advise_buy = _trend_alternate_hold  # Override
+    backtesting.advise_sell = _trend_alternate_hold  # Override
+
+    data_processed = backtesting.strategy.tickerdata_to_dataframe(data)
+    min_date, max_date = get_timeframe(data_processed)
+    backtest_conf = {
+        'stake_amount': default_conf['stake_amount'],
+        'processed': data_processed,
+        'max_open_trades': 3,
+        'position_stacking': False,
+        'start_date': min_date,
+        'end_date': max_date,
+    }
+
+    results = backtesting.backtest(backtest_conf)
+
+    # Make sure we have parallel trades
+    assert len(evaluate_result_multi(results, '5min', 2)) > 0
+    # make sure we don't have trades with more than configured max_open_trades
+    assert len(evaluate_result_multi(results, '5min', 3)) == 0
+
+    backtest_conf = {
+        'stake_amount': default_conf['stake_amount'],
+        'processed': data_processed,
+        'max_open_trades': 1,
+        'position_stacking': False,
+        'start_date': min_date,
+        'end_date': max_date,
+    }
+    results = backtesting.backtest(backtest_conf)
+    assert len(evaluate_result_multi(results, '5min', 1)) == 0
 
 
 def test_backtest_record(default_conf, fee, mocker):

freqtrade/tests/optimize/test_edge_cli.py

@@ -0,0 +1,136 @@
+# pragma pylint: disable=missing-docstring, C0103, C0330
+# pragma pylint: disable=protected-access, too-many-lines, invalid-name, too-many-arguments
+
+from unittest.mock import MagicMock
+import json
+from typing import List
+from freqtrade.edge import PairInfo
+from freqtrade.arguments import Arguments
+from freqtrade.optimize.edge_cli import (EdgeCli, setup_configuration, start)
+from freqtrade.state import RunMode
+from freqtrade.tests.conftest import log_has, patch_exchange
+
+
+def get_args(args) -> List[str]:
+    return Arguments(args, '').get_parsed_arg()
+
+
+def test_setup_configuration_without_arguments(mocker, default_conf, caplog) -> None:
+    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
+        read_data=json.dumps(default_conf)
+    ))
+
+    args = [
+        '--config', 'config.json',
+        '--strategy', 'DefaultStrategy',
+        'edge'
+    ]
+
+    config = setup_configuration(get_args(args))
+    assert config['runmode'] == RunMode.EDGECLI
+
+    assert 'max_open_trades' in config
+    assert 'stake_currency' in config
+    assert 'stake_amount' in config
+    assert 'exchange' in config
+    assert 'pair_whitelist' in config['exchange']
+    assert 'datadir' in config
+    assert log_has(
+        'Using data folder: {} ...'.format(config['datadir']),
+        caplog.record_tuples
+    )
+    assert 'ticker_interval' in config
+    assert not log_has('Parameter -i/--ticker-interval detected ...', caplog.record_tuples)
+
+    assert 'refresh_pairs' not in config
+    assert not log_has('Parameter -r/--refresh-pairs-cached detected ...', caplog.record_tuples)
+
+    assert 'timerange' not in config
+    assert 'stoploss_range' not in config
+
+
+def test_setup_edge_configuration_with_arguments(mocker, edge_conf, caplog) -> None:
+    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
+        read_data=json.dumps(edge_conf)
+    ))
+    mocker.patch('freqtrade.configuration.Configuration._create_datadir', lambda s, c, x: x)
+
+    args = [
+        '--config', 'config.json',
+        '--strategy', 'DefaultStrategy',
+        '--datadir', '/foo/bar',
+        'edge',
+        '--ticker-interval', '1m',
+        '--refresh-pairs-cached',
+        '--timerange', ':100',
+        '--stoplosses=-0.01,-0.10,-0.001'
+    ]
+
+    config = setup_configuration(get_args(args))
+    assert 'max_open_trades' in config
+    assert 'stake_currency' in config
+    assert 'stake_amount' in config
+    assert 'exchange' in config
+    assert 'pair_whitelist' in config['exchange']
+    assert 'datadir' in config
+    assert config['runmode'] == RunMode.EDGECLI
+    assert log_has(
+        'Using data folder: {} ...'.format(config['datadir']),
+        caplog.record_tuples
+    )
+    assert 'ticker_interval' in config
+    assert log_has('Parameter -i/--ticker-interval detected ...', caplog.record_tuples)
+    assert log_has(
+        'Using ticker_interval: 1m ...',
+        caplog.record_tuples
+    )
+
+    assert 'refresh_pairs' in config
+    assert log_has('Parameter -r/--refresh-pairs-cached detected ...', caplog.record_tuples)
+    assert 'timerange' in config
+    assert log_has(
+        'Parameter --timerange detected: {} ...'.format(config['timerange']),
+        caplog.record_tuples
+    )
+
+
+def test_start(mocker, fee, edge_conf, caplog) -> None:
+    start_mock = MagicMock()
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
+    patch_exchange(mocker)
+    mocker.patch('freqtrade.optimize.edge_cli.EdgeCli.start', start_mock)
+    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
+        read_data=json.dumps(edge_conf)
+    ))
+    args = [
+        '--config', 'config.json',
+        '--strategy', 'DefaultStrategy',
+        'edge'
+    ]
+    args = get_args(args)
+    start(args)
+    assert log_has(
+        'Starting freqtrade in Edge mode',
+        caplog.record_tuples
+    )
+    assert start_mock.call_count == 1
+
+
+def test_edge_init(mocker, edge_conf) -> None:
+    patch_exchange(mocker)
+    edge_cli = EdgeCli(edge_conf)
+    assert edge_cli.config == edge_conf
+    assert callable(edge_cli.edge.calculate)
+
+
+def test_generate_edge_table(edge_conf, mocker):
+    patch_exchange(mocker)
+    edge_cli = EdgeCli(edge_conf)
+
+    results = {}
+    results['ETH/BTC'] = PairInfo(-0.01, 0.60, 2, 1, 3, 10, 60)
+
+    assert edge_cli._generate_edge_table(results).count(':|') == 7
+    assert edge_cli._generate_edge_table(results).count('| ETH/BTC |') == 1
+    assert edge_cli._generate_edge_table(results).count(
+        '|   risk reward ratio |   required risk reward |   expectancy |') == 1

freqtrade/tests/optimize/test_hyperopt.py

@@ -1,13 +1,16 @@
 # pragma pylint: disable=missing-docstring,W0212,C0103
+from datetime import datetime
 import os
 from unittest.mock import MagicMock
 
 import pandas as pd
 import pytest
 
-from freqtrade.optimize.__init__ import load_tickerdata_file
+from freqtrade.data.converter import parse_ticker_dataframe
+from freqtrade.data.history import load_tickerdata_file
 from freqtrade.optimize.hyperopt import Hyperopt, start
-from freqtrade.strategy.resolver import StrategyResolver
+from freqtrade.optimize.default_hyperopt import DefaultHyperOpts
+from freqtrade.resolvers import StrategyResolver, HyperOptResolver
 from freqtrade.tests.conftest import log_has, patch_exchange
 from freqtrade.tests.optimize.test_backtesting import get_args
 
@@ -36,6 +39,28 @@ def create_trials(mocker, hyperopt) -> None:
     return [{'loss': 1, 'result': 'foo', 'params': {}}]
 
 
+def test_hyperoptresolver(mocker, default_conf, caplog) -> None:
+
+    mocker.patch(
+        'freqtrade.configuration.Configuration._load_config_file',
+        lambda *args, **kwargs: default_conf
+    )
+    hyperopts = DefaultHyperOpts
+    delattr(hyperopts, 'populate_buy_trend')
+    delattr(hyperopts, 'populate_sell_trend')
+    mocker.patch(
+        'freqtrade.resolvers.hyperopt_resolver.HyperOptResolver._load_hyperopt',
+        MagicMock(return_value=hyperopts)
+    )
+    x = HyperOptResolver(default_conf, ).hyperopt
+    assert not hasattr(x, 'populate_buy_trend')
+    assert not hasattr(x, 'populate_sell_trend')
+    assert log_has("Custom Hyperopt does not provide populate_sell_trend. "
+                   "Using populate_sell_trend from DefaultStrategy.", caplog.record_tuples)
+    assert log_has("Custom Hyperopt does not provide populate_buy_trend. "
+                   "Using populate_buy_trend from DefaultStrategy.", caplog.record_tuples)
+
+
 def test_start(mocker, default_conf, caplog) -> None:
     start_mock = MagicMock()
     mocker.patch(
@@ -175,7 +200,7 @@ def test_roi_table_generation(hyperopt) -> None:
         'roi_p3': 3,
     }
 
-    assert hyperopt.generate_roi_table(params) == {0: 6, 15: 3, 25: 1, 30: 0}
+    assert hyperopt.custom_hyperopt.generate_roi_table(params) == {0: 6, 15: 3, 25: 1, 30: 0}
 
 
 def test_start_calls_optimizer(mocker, default_conf, caplog) -> None:
@@ -194,12 +219,12 @@ def test_start_calls_optimizer(mocker, default_conf, caplog) -> None:
     default_conf.update({'spaces': 'all'})
 
     hyperopt = Hyperopt(default_conf)
-    hyperopt.tickerdata_to_dataframe = MagicMock()
+    hyperopt.strategy.tickerdata_to_dataframe = MagicMock()
 
     hyperopt.start()
     parallel.assert_called_once()
 
-    assert 'Best result:\nfoo result\nwith values:\n{}' in caplog.text
+    assert 'Best result:\nfoo result\nwith values:\n\n' in caplog.text
     assert dumper.called
 
 
@@ -241,9 +266,10 @@ def test_has_space(hyperopt):
 
 def test_populate_indicators(hyperopt) -> None:
     tick = load_tickerdata_file(None, 'UNITTEST/BTC', '1m')
-    tickerlist = {'UNITTEST/BTC': tick}
-    dataframes = hyperopt.tickerdata_to_dataframe(tickerlist)
-    dataframe = hyperopt.populate_indicators(dataframes['UNITTEST/BTC'], {'pair': 'UNITTEST/BTC'})
+    tickerlist = {'UNITTEST/BTC': parse_ticker_dataframe(tick, '1m', fill_missing=True)}
+    dataframes = hyperopt.strategy.tickerdata_to_dataframe(tickerlist)
+    dataframe = hyperopt.custom_hyperopt.populate_indicators(dataframes['UNITTEST/BTC'],
+                                                             {'pair': 'UNITTEST/BTC'})
 
     # Check if some indicators are generated. We will not test all of them
     assert 'adx' in dataframe
@@ -253,11 +279,12 @@ def test_populate_indicators(hyperopt) -> None:
 
 def test_buy_strategy_generator(hyperopt) -> None:
     tick = load_tickerdata_file(None, 'UNITTEST/BTC', '1m')
-    tickerlist = {'UNITTEST/BTC': tick}
-    dataframes = hyperopt.tickerdata_to_dataframe(tickerlist)
-    dataframe = hyperopt.populate_indicators(dataframes['UNITTEST/BTC'], {'pair': 'UNITTEST/BTC'})
+    tickerlist = {'UNITTEST/BTC': parse_ticker_dataframe(tick, '1m', fill_missing=True)}
+    dataframes = hyperopt.strategy.tickerdata_to_dataframe(tickerlist)
+    dataframe = hyperopt.custom_hyperopt.populate_indicators(dataframes['UNITTEST/BTC'],
+                                                             {'pair': 'UNITTEST/BTC'})
 
-    populate_buy_trend = hyperopt.buy_strategy_generator(
+    populate_buy_trend = hyperopt.custom_hyperopt.buy_strategy_generator(
         {
             'adx-value': 20,
             'fastd-value': 20,
@@ -291,6 +318,10 @@ def test_generate_optimizer(mocker, default_conf) -> None:
         'freqtrade.optimize.hyperopt.Hyperopt.backtest',
         MagicMock(return_value=backtest_result)
     )
+    mocker.patch(
+        'freqtrade.optimize.hyperopt.get_timeframe',
+        MagicMock(return_value=(datetime(2017, 12, 10), datetime(2017, 12, 13)))
+    )
     patch_exchange(mocker)
     mocker.patch('freqtrade.optimize.hyperopt.load', MagicMock())
 
@@ -304,6 +335,15 @@ def test_generate_optimizer(mocker, default_conf) -> None:
         'mfi-enabled': False,
         'rsi-enabled': False,
         'trigger': 'macd_cross_signal',
+        'sell-adx-value': 0,
+        'sell-fastd-value': 75,
+        'sell-mfi-value': 0,
+        'sell-rsi-value': 0,
+        'sell-adx-enabled': False,
+        'sell-fastd-enabled': True,
+        'sell-mfi-enabled': False,
+        'sell-rsi-enabled': False,
+        'sell-trigger': 'macd_cross_signal',
         'roi_t1': 60.0,
         'roi_t2': 30.0,
         'roi_t3': 20.0,

freqtrade/tests/optimize/test_optimize.py

@@ -1,435 +1,65 @@
 # pragma pylint: disable=missing-docstring, protected-access, C0103
-
-import json
-import os
-import uuid
-from shutil import copyfile
-
-import arrow
-
-from freqtrade import optimize
+from freqtrade import optimize, constants
 from freqtrade.arguments import TimeRange
-from freqtrade.misc import file_dump_json
-from freqtrade.optimize.__init__ import (download_backtesting_testdata,
-                                         download_pairs,
-                                         load_cached_data_for_updating,
-                                         load_tickerdata_file,
-                                         make_testdata_path, trim_tickerlist)
-from freqtrade.tests.conftest import get_patched_exchange, log_has
-
-# Change this if modifying UNITTEST/BTC testdatafile
-_BTC_UNITTEST_LENGTH = 13681
+from freqtrade.data import history
+from freqtrade.strategy.default_strategy import DefaultStrategy
+from freqtrade.tests.conftest import log_has, patch_exchange
 
 
-def _backup_file(file: str, copy_file: bool = False) -> None:
-    """
-    Backup existing file to avoid deleting the user file
-    :param file: complete path to the file
-    :param touch_file: create an empty file in replacement
-    :return: None
-    """
-    file_swp = file + '.swp'
-    if os.path.isfile(file):
-        os.rename(file, file_swp)
+def test_get_timeframe(default_conf, mocker) -> None:
+    patch_exchange(mocker)
+    strategy = DefaultStrategy(default_conf)
 
-        if copy_file:
-            copyfile(file_swp, file)
+    data = strategy.tickerdata_to_dataframe(
+        history.load_data(
+            datadir=None,
+            ticker_interval='1m',
+            pairs=['UNITTEST/BTC']
+        )
+    )
+    min_date, max_date = optimize.get_timeframe(data)
+    assert min_date.isoformat() == '2017-11-04T23:02:00+00:00'
+    assert max_date.isoformat() == '2017-11-14T22:58:00+00:00'
 
 
-def _clean_test_file(file: str) -> None:
-    """
-    Backup existing file to avoid deleting the user file
-    :param file: complete path to the file
-    :return: None
-    """
-    file_swp = file + '.swp'
-    # 1. Delete file from the test
-    if os.path.isfile(file):
-        os.remove(file)
+def test_validate_backtest_data_warn(default_conf, mocker, caplog) -> None:
+    patch_exchange(mocker)
+    strategy = DefaultStrategy(default_conf)
 
-    # 2. Rollback to the initial file
-    if os.path.isfile(file_swp):
-        os.rename(file_swp, file)
+    data = strategy.tickerdata_to_dataframe(
+        history.load_data(
+            datadir=None,
+            ticker_interval='1m',
+            pairs=['UNITTEST/BTC'],
+            fill_up_missing=False
+        )
+    )
+    min_date, max_date = optimize.get_timeframe(data)
+    caplog.clear()
+    assert optimize.validate_backtest_data(data, min_date, max_date,
+                                           constants.TICKER_INTERVAL_MINUTES["1m"])
+    assert len(caplog.record_tuples) == 1
+    assert log_has(
+        "UNITTEST/BTC has missing frames: expected 14396, got 13680, that's 716 missing values",
+        caplog.record_tuples)
 
 
-def test_load_data_30min_ticker(ticker_history, mocker, caplog, default_conf) -> None:
-    mocker.patch('freqtrade.exchange.Exchange.get_history', return_value=ticker_history)
-    file = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'UNITTEST_BTC-30m.json')
-    _backup_file(file, copy_file=True)
-    optimize.load_data(None, pairs=['UNITTEST/BTC'], ticker_interval='30m')
-    assert os.path.isfile(file) is True
-    assert not log_has('Download the pair: "UNITTEST/BTC", Interval: 30m', caplog.record_tuples)
-    _clean_test_file(file)
+def test_validate_backtest_data(default_conf, mocker, caplog) -> None:
+    patch_exchange(mocker)
+    strategy = DefaultStrategy(default_conf)
 
-
-def test_load_data_5min_ticker(ticker_history, mocker, caplog, default_conf) -> None:
-    mocker.patch('freqtrade.exchange.Exchange.get_history', return_value=ticker_history)
-
-    file = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'UNITTEST_BTC-5m.json')
-    _backup_file(file, copy_file=True)
-    optimize.load_data(None, pairs=['UNITTEST/BTC'], ticker_interval='5m')
-    assert os.path.isfile(file) is True
-    assert not log_has('Download the pair: "UNITTEST/BTC", Interval: 5m', caplog.record_tuples)
-    _clean_test_file(file)
-
-
-def test_load_data_1min_ticker(ticker_history, mocker, caplog) -> None:
-    mocker.patch('freqtrade.exchange.Exchange.get_history', return_value=ticker_history)
-    file = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'UNITTEST_BTC-1m.json')
-    _backup_file(file, copy_file=True)
-    optimize.load_data(None, ticker_interval='1m', pairs=['UNITTEST/BTC'])
-    assert os.path.isfile(file) is True
-    assert not log_has('Download the pair: "UNITTEST/BTC", Interval: 1m', caplog.record_tuples)
-    _clean_test_file(file)
-
-
-def test_load_data_with_new_pair_1min(ticker_history, mocker, caplog, default_conf) -> None:
-    """
-    Test load_data() with 1 min ticker
-    """
-    mocker.patch('freqtrade.exchange.Exchange.get_history', return_value=ticker_history)
-    exchange = get_patched_exchange(mocker, default_conf)
-    file = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'MEME_BTC-1m.json')
-
-    _backup_file(file)
-    # do not download a new pair if refresh_pairs isn't set
-    optimize.load_data(None,
-                       ticker_interval='1m',
-                       refresh_pairs=False,
-                       pairs=['MEME/BTC'])
-    assert os.path.isfile(file) is False
-    assert log_has('No data for pair: "MEME/BTC", Interval: 1m. '
-                   'Use --refresh-pairs-cached to download the data',
-                   caplog.record_tuples)
-
-    # download a new pair if refresh_pairs is set
-    optimize.load_data(None,
-                       ticker_interval='1m',
-                       refresh_pairs=True,
-                       exchange=exchange,
-                       pairs=['MEME/BTC'])
-    assert os.path.isfile(file) is True
-    assert log_has('Download the pair: "MEME/BTC", Interval: 1m', caplog.record_tuples)
-    _clean_test_file(file)
-
-
-def test_testdata_path() -> None:
-    assert os.path.join('freqtrade', 'tests', 'testdata') in make_testdata_path(None)
-
-
-def test_download_pairs(ticker_history, mocker, default_conf) -> None:
-    mocker.patch('freqtrade.exchange.Exchange.get_history', return_value=ticker_history)
-    exchange = get_patched_exchange(mocker, default_conf)
-    file1_1 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'MEME_BTC-1m.json')
-    file1_5 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'MEME_BTC-5m.json')
-    file2_1 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'CFI_BTC-1m.json')
-    file2_5 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'CFI_BTC-5m.json')
-
-    _backup_file(file1_1)
-    _backup_file(file1_5)
-    _backup_file(file2_1)
-    _backup_file(file2_5)
-
-    assert os.path.isfile(file1_1) is False
-    assert os.path.isfile(file2_1) is False
-
-    assert download_pairs(None, exchange,
-                          pairs=['MEME/BTC', 'CFI/BTC'], ticker_interval='1m') is True
-
-    assert os.path.isfile(file1_1) is True
-    assert os.path.isfile(file2_1) is True
-
-    # clean files freshly downloaded
-    _clean_test_file(file1_1)
-    _clean_test_file(file2_1)
-
-    assert os.path.isfile(file1_5) is False
-    assert os.path.isfile(file2_5) is False
-
-    assert download_pairs(None, exchange,
-                          pairs=['MEME/BTC', 'CFI/BTC'], ticker_interval='5m') is True
-
-    assert os.path.isfile(file1_5) is True
-    assert os.path.isfile(file2_5) is True
-
-    # clean files freshly downloaded
-    _clean_test_file(file1_5)
-    _clean_test_file(file2_5)
-
-
-def test_load_cached_data_for_updating(mocker) -> None:
-    datadir = os.path.join(os.path.dirname(__file__), '..', 'testdata')
-
-    test_data = None
-    test_filename = os.path.join(datadir, 'UNITTEST_BTC-1m.json')
-    with open(test_filename, "rt") as file:
-        test_data = json.load(file)
-
-    # change now time to test 'line' cases
-    # now = last cached item + 1 hour
-    now_ts = test_data[-1][0] / 1000 + 60 * 60
-    mocker.patch('arrow.utcnow', return_value=arrow.get(now_ts))
-
-    # timeframe starts earlier than the cached data
-    # should fully update data
-    timerange = TimeRange('date', None, test_data[0][0] / 1000 - 1, 0)
-    data, start_ts = load_cached_data_for_updating(test_filename,
-                                                   '1m',
-                                                   timerange)
-    assert data == []
-    assert start_ts == test_data[0][0] - 1000
-
-    # same with 'line' timeframe
-    num_lines = (test_data[-1][0] - test_data[1][0]) / 1000 / 60 + 120
-    data, start_ts = load_cached_data_for_updating(test_filename,
-                                                   '1m',
-                                                   TimeRange(None, 'line', 0, -num_lines))
-    assert data == []
-    assert start_ts < test_data[0][0] - 1
-
-    # timeframe starts in the center of the cached data
-    # should return the chached data w/o the last item
-    timerange = TimeRange('date', None, test_data[0][0] / 1000 + 1, 0)
-    data, start_ts = load_cached_data_for_updating(test_filename,
-                                                   '1m',
-                                                   timerange)
-    assert data == test_data[:-1]
-    assert test_data[-2][0] < start_ts < test_data[-1][0]
-
-    # same with 'line' timeframe
-    num_lines = (test_data[-1][0] - test_data[1][0]) / 1000 / 60 + 30
-    timerange = TimeRange(None, 'line', 0, -num_lines)
-    data, start_ts = load_cached_data_for_updating(test_filename,
-                                                   '1m',
-                                                   timerange)
-    assert data == test_data[:-1]
-    assert test_data[-2][0] < start_ts < test_data[-1][0]
-
-    # timeframe starts after the chached data
-    # should return the chached data w/o the last item
-    timerange = TimeRange('date', None, test_data[-1][0] / 1000 + 1, 0)
-    data, start_ts = load_cached_data_for_updating(test_filename,
-                                                   '1m',
-                                                   timerange)
-    assert data == test_data[:-1]
-    assert test_data[-2][0] < start_ts < test_data[-1][0]
-
-    # same with 'line' timeframe
-    num_lines = 30
-    timerange = TimeRange(None, 'line', 0, -num_lines)
-    data, start_ts = load_cached_data_for_updating(test_filename,
-                                                   '1m',
-                                                   timerange)
-    assert data == test_data[:-1]
-    assert test_data[-2][0] < start_ts < test_data[-1][0]
-
-    # no timeframe is set
-    # should return the chached data w/o the last item
-    num_lines = 30
-    timerange = TimeRange(None, 'line', 0, -num_lines)
-    data, start_ts = load_cached_data_for_updating(test_filename,
-                                                   '1m',
-                                                   timerange)
-    assert data == test_data[:-1]
-    assert test_data[-2][0] < start_ts < test_data[-1][0]
-
-    # no datafile exist
-    # should return timestamp start time
-    timerange = TimeRange('date', None, now_ts - 10000, 0)
-    data, start_ts = load_cached_data_for_updating(test_filename + 'unexist',
-                                                   '1m',
-                                                   timerange)
-    assert data == []
-    assert start_ts == (now_ts - 10000) * 1000
-
-    # same with 'line' timeframe
-    num_lines = 30
-    timerange = TimeRange(None, 'line', 0, -num_lines)
-    data, start_ts = load_cached_data_for_updating(test_filename + 'unexist',
-                                                   '1m',
-                                                   timerange)
-    assert data == []
-    assert start_ts == (now_ts - num_lines * 60) * 1000
-
-    # no datafile exist, no timeframe is set
-    # should return an empty array and None
-    data, start_ts = load_cached_data_for_updating(test_filename + 'unexist',
-                                                   '1m',
-                                                   None)
-    assert data == []
-    assert start_ts is None
-
-
-def test_download_pairs_exception(ticker_history, mocker, caplog, default_conf) -> None:
-    mocker.patch('freqtrade.exchange.Exchange.get_history', return_value=ticker_history)
-    mocker.patch('freqtrade.optimize.__init__.download_backtesting_testdata',
-                 side_effect=BaseException('File Error'))
-    exchange = get_patched_exchange(mocker, default_conf)
-
-    file1_1 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'MEME_BTC-1m.json')
-    file1_5 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'MEME_BTC-5m.json')
-    _backup_file(file1_1)
-    _backup_file(file1_5)
-
-    download_pairs(None, exchange, pairs=['MEME/BTC'], ticker_interval='1m')
-    # clean files freshly downloaded
-    _clean_test_file(file1_1)
-    _clean_test_file(file1_5)
-    assert log_has('Failed to download the pair: "MEME/BTC", Interval: 1m', caplog.record_tuples)
-
-
-def test_download_backtesting_testdata(ticker_history, mocker, default_conf) -> None:
-    mocker.patch('freqtrade.exchange.Exchange.get_history', return_value=ticker_history)
-    exchange = get_patched_exchange(mocker, default_conf)
-
-    # Download a 1 min ticker file
-    file1 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'XEL_BTC-1m.json')
-    _backup_file(file1)
-    download_backtesting_testdata(None, exchange, pair="XEL/BTC", tick_interval='1m')
-    assert os.path.isfile(file1) is True
-    _clean_test_file(file1)
-
-    # Download a 5 min ticker file
-    file2 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'STORJ_BTC-5m.json')
-    _backup_file(file2)
-
-    download_backtesting_testdata(None, exchange, pair="STORJ/BTC", tick_interval='5m')
-    assert os.path.isfile(file2) is True
-    _clean_test_file(file2)
-
-
-def test_download_backtesting_testdata2(mocker, default_conf) -> None:
-    tick = [
-        [1509836520000, 0.00162008, 0.00162008, 0.00162008, 0.00162008, 108.14853839],
-        [1509836580000, 0.00161, 0.00161, 0.00161, 0.00161, 82.390199]
-    ]
-    json_dump_mock = mocker.patch('freqtrade.misc.file_dump_json', return_value=None)
-    mocker.patch('freqtrade.exchange.Exchange.get_history', return_value=tick)
-    exchange = get_patched_exchange(mocker, default_conf)
-    download_backtesting_testdata(None, exchange, pair="UNITTEST/BTC", tick_interval='1m')
-    download_backtesting_testdata(None, exchange, pair="UNITTEST/BTC", tick_interval='3m')
-    assert json_dump_mock.call_count == 2
-
-
-def test_load_tickerdata_file() -> None:
-    # 7 does not exist in either format.
-    assert not load_tickerdata_file(None, 'UNITTEST/BTC', '7m')
-    # 1 exists only as a .json
-    tickerdata = load_tickerdata_file(None, 'UNITTEST/BTC', '1m')
-    assert _BTC_UNITTEST_LENGTH == len(tickerdata)
-    # 8 .json is empty and will fail if it's loaded. .json.gz is a copy of 1.json
-    tickerdata = load_tickerdata_file(None, 'UNITTEST/BTC', '8m')
-    assert _BTC_UNITTEST_LENGTH == len(tickerdata)
-
-
-def test_init(default_conf, mocker) -> None:
-    exchange = get_patched_exchange(mocker, default_conf)
-    assert {} == optimize.load_data(
-        '',
-        exchange=exchange,
-        pairs=[],
-        refresh_pairs=True,
-        ticker_interval=default_conf['ticker_interval']
+    timerange = TimeRange('index', 'index', 200, 250)
+    data = strategy.tickerdata_to_dataframe(
+        history.load_data(
+            datadir=None,
+            ticker_interval='5m',
+            pairs=['UNITTEST/BTC'],
+            timerange=timerange
+        )
     )
 
-
-def test_trim_tickerlist() -> None:
-    file = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'UNITTEST_BTC-1m.json')
-    with open(file) as data_file:
-        ticker_list = json.load(data_file)
-    ticker_list_len = len(ticker_list)
-
-    # Test the pattern ^(-\d+)$
-    # This pattern uses the latest N elements
-    timerange = TimeRange(None, 'line', 0, -5)
-    ticker = trim_tickerlist(ticker_list, timerange)
-    ticker_len = len(ticker)
-
-    assert ticker_len == 5
-    assert ticker_list[0] is not ticker[0]  # The first element should be different
-    assert ticker_list[-1] is ticker[-1]  # The last element must be the same
-
-    # Test the pattern ^(\d+)-$
-    # This pattern keep X element from the end
-    timerange = TimeRange('line', None, 5, 0)
-    ticker = trim_tickerlist(ticker_list, timerange)
-    ticker_len = len(ticker)
-
-    assert ticker_len == 5
-    assert ticker_list[0] is ticker[0]  # The first element must be the same
-    assert ticker_list[-1] is not ticker[-1]  # The last element should be different
-
-    # Test the pattern ^(\d+)-(\d+)$
-    # This pattern extract a window
-    timerange = TimeRange('index', 'index', 5, 10)
-    ticker = trim_tickerlist(ticker_list, timerange)
-    ticker_len = len(ticker)
-
-    assert ticker_len == 5
-    assert ticker_list[0] is not ticker[0]  # The first element should be different
-    assert ticker_list[5] is ticker[0]  # The list starts at the index 5
-    assert ticker_list[9] is ticker[-1]  # The list ends at the index 9 (5 elements)
-
-    # Test the pattern ^(\d{8})-(\d{8})$
-    # This pattern extract a window between the dates
-    timerange = TimeRange('date', 'date', ticker_list[5][0] / 1000, ticker_list[10][0] / 1000 - 1)
-    ticker = trim_tickerlist(ticker_list, timerange)
-    ticker_len = len(ticker)
-
-    assert ticker_len == 5
-    assert ticker_list[0] is not ticker[0]  # The first element should be different
-    assert ticker_list[5] is ticker[0]  # The list starts at the index 5
-    assert ticker_list[9] is ticker[-1]  # The list ends at the index 9 (5 elements)
-
-    # Test the pattern ^-(\d{8})$
-    # This pattern extracts elements from the start to the date
-    timerange = TimeRange(None, 'date', 0, ticker_list[10][0] / 1000 - 1)
-    ticker = trim_tickerlist(ticker_list, timerange)
-    ticker_len = len(ticker)
-
-    assert ticker_len == 10
-    assert ticker_list[0] is ticker[0]  # The start of the list is included
-    assert ticker_list[9] is ticker[-1]  # The element 10 is not included
-
-    # Test the pattern ^(\d{8})-$
-    # This pattern extracts elements from the date to now
-    timerange = TimeRange('date', None, ticker_list[10][0] / 1000 - 1, None)
-    ticker = trim_tickerlist(ticker_list, timerange)
-    ticker_len = len(ticker)
-
-    assert ticker_len == ticker_list_len - 10
-    assert ticker_list[10] is ticker[0]  # The first element is element #10
-    assert ticker_list[-1] is ticker[-1]  # The last element is the same
-
-    # Test a wrong pattern
-    # This pattern must return the list unchanged
-    timerange = TimeRange(None, None, None, 5)
-    ticker = trim_tickerlist(ticker_list, timerange)
-    ticker_len = len(ticker)
-
-    assert ticker_list_len == ticker_len
-
-
-def test_file_dump_json() -> None:
-    file = os.path.join(os.path.dirname(__file__), '..', 'testdata',
-                        'test_{id}.json'.format(id=str(uuid.uuid4())))
-    data = {'bar': 'foo'}
-
-    # check the file we will create does not exist
-    assert os.path.isfile(file) is False
-
-    # Create the Json file
-    file_dump_json(file, data)
-
-    # Check the file was create
-    assert os.path.isfile(file) is True
-
-    # Open the Json file created and test the data is in it
-    with open(file) as data_file:
-        json_from_file = json.load(data_file)
-
-    assert 'bar' in json_from_file
-    assert json_from_file['bar'] == 'foo'
-
-    # Remove the file
-    _clean_test_file(file)
+    min_date, max_date = optimize.get_timeframe(data)
+    caplog.clear()
+    assert not optimize.validate_backtest_data(data, min_date, max_date,
+                                               constants.TICKER_INTERVAL_MINUTES["5m"])
+    assert len(caplog.record_tuples) == 0

freqtrade/tests/pairlist/test_pairlist.py

@@ -0,0 +1,170 @@
+# pragma pylint: disable=missing-docstring,C0103,protected-access
+
+from unittest.mock import MagicMock
+
+from freqtrade import OperationalException
+from freqtrade.constants import AVAILABLE_PAIRLISTS
+from freqtrade.resolvers import PairListResolver
+from freqtrade.tests.conftest import get_patched_freqtradebot
+import pytest
+
+# whitelist, blacklist
+
+
+@pytest.fixture(scope="function")
+def whitelist_conf(default_conf):
+    default_conf['stake_currency'] = 'BTC'
+    default_conf['exchange']['pair_whitelist'] = [
+        'ETH/BTC',
+        'TKN/BTC',
+        'TRST/BTC',
+        'SWT/BTC',
+        'BCC/BTC'
+    ]
+    default_conf['exchange']['pair_blacklist'] = [
+        'BLK/BTC'
+    ]
+    default_conf['pairlist'] = {'method': 'StaticPairList',
+                                'config': {'number_assets': 3}
+                                }
+
+    return default_conf
+
+
+def test_load_pairlist_noexist(mocker, markets, default_conf):
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
+    mocker.patch('freqtrade.exchange.Exchange.get_markets', markets)
+    with pytest.raises(ImportError,
+                       match=r"Impossible to load Pairlist 'NonexistingPairList'."
+                             r" This class does not exist or contains Python code errors"):
+        PairListResolver('NonexistingPairList', freqtradebot, default_conf).pairlist
+
+
+def test_refresh_market_pair_not_in_whitelist(mocker, markets, whitelist_conf):
+
+    freqtradebot = get_patched_freqtradebot(mocker, whitelist_conf)
+
+    mocker.patch('freqtrade.exchange.Exchange.get_markets', markets)
+    freqtradebot.pairlists.refresh_pairlist()
+    # List ordered by BaseVolume
+    whitelist = ['ETH/BTC', 'TKN/BTC']
+    # Ensure all except those in whitelist are removed
+    assert set(whitelist) == set(freqtradebot.pairlists.whitelist)
+    # Ensure config dict hasn't been changed
+    assert (whitelist_conf['exchange']['pair_whitelist'] ==
+            freqtradebot.config['exchange']['pair_whitelist'])
+
+
+def test_refresh_pairlists(mocker, markets, whitelist_conf):
+    freqtradebot = get_patched_freqtradebot(mocker, whitelist_conf)
+
+    mocker.patch('freqtrade.exchange.Exchange.get_markets', markets)
+    freqtradebot.pairlists.refresh_pairlist()
+    # List ordered by BaseVolume
+    whitelist = ['ETH/BTC', 'TKN/BTC']
+    # Ensure all except those in whitelist are removed
+    assert set(whitelist) == set(freqtradebot.pairlists.whitelist)
+    assert whitelist_conf['exchange']['pair_blacklist'] == freqtradebot.pairlists.blacklist
+
+
+def test_refresh_pairlist_dynamic(mocker, markets, tickers, whitelist_conf):
+    whitelist_conf['pairlist'] = {'method': 'VolumePairList',
+                                  'config': {'number_assets': 5}
+                                  }
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        get_markets=markets,
+        get_tickers=tickers,
+        exchange_has=MagicMock(return_value=True)
+    )
+    freqtradebot = get_patched_freqtradebot(mocker, whitelist_conf)
+
+    # argument: use the whitelist dynamically by exchange-volume
+    whitelist = ['ETH/BTC', 'TKN/BTC']
+    freqtradebot.pairlists.refresh_pairlist()
+
+    assert whitelist == freqtradebot.pairlists.whitelist
+
+    whitelist_conf['pairlist'] = {'method': 'VolumePairList',
+                                  'config': {}
+                                  }
+    with pytest.raises(OperationalException,
+                       match=r'`number_assets` not specified. Please check your configuration '
+                             r'for "pairlist.config.number_assets"'):
+        PairListResolver('VolumePairList', freqtradebot, whitelist_conf).pairlist
+
+
+def test_VolumePairList_refresh_empty(mocker, markets_empty, whitelist_conf):
+    freqtradebot = get_patched_freqtradebot(mocker, whitelist_conf)
+    mocker.patch('freqtrade.exchange.Exchange.get_markets', markets_empty)
+
+    # argument: use the whitelist dynamically by exchange-volume
+    whitelist = []
+    whitelist_conf['exchange']['pair_whitelist'] = []
+    freqtradebot.pairlists.refresh_pairlist()
+    pairslist = whitelist_conf['exchange']['pair_whitelist']
+
+    assert set(whitelist) == set(pairslist)
+
+
+def test_VolumePairList_whitelist_gen(mocker, whitelist_conf, markets, tickers) -> None:
+    whitelist_conf['pairlist']['method'] = 'VolumePairList'
+    mocker.patch('freqtrade.exchange.Exchange.exchange_has', MagicMock(return_value=True))
+    freqtrade = get_patched_freqtradebot(mocker, whitelist_conf)
+    mocker.patch('freqtrade.exchange.Exchange.get_markets', markets)
+    mocker.patch('freqtrade.exchange.Exchange.get_tickers', tickers)
+
+    # Test to retrieved BTC sorted on quoteVolume (default)
+    whitelist = freqtrade.pairlists._gen_pair_whitelist(base_currency='BTC', key='quoteVolume')
+    assert whitelist == ['ETH/BTC', 'TKN/BTC', 'BLK/BTC', 'LTC/BTC']
+
+    # Test to retrieve BTC sorted on bidVolume
+    whitelist = freqtrade.pairlists._gen_pair_whitelist(base_currency='BTC', key='bidVolume')
+    assert whitelist == ['LTC/BTC', 'TKN/BTC', 'ETH/BTC', 'BLK/BTC']
+
+    # Test with USDT sorted on quoteVolume (default)
+    whitelist = freqtrade.pairlists._gen_pair_whitelist(base_currency='USDT', key='quoteVolume')
+    assert whitelist == ['TKN/USDT', 'ETH/USDT', 'LTC/USDT', 'BLK/USDT']
+
+    # Test with ETH (our fixture does not have ETH, so result should be empty)
+    whitelist = freqtrade.pairlists._gen_pair_whitelist(base_currency='ETH', key='quoteVolume')
+    assert whitelist == []
+
+
+def test_gen_pair_whitelist_not_supported(mocker, default_conf, tickers) -> None:
+    default_conf['pairlist'] = {'method': 'VolumePairList',
+                                'config': {'number_assets': 10}
+                                }
+    mocker.patch('freqtrade.exchange.Exchange.get_tickers', tickers)
+    mocker.patch('freqtrade.exchange.Exchange.exchange_has', MagicMock(return_value=False))
+
+    with pytest.raises(OperationalException):
+        get_patched_freqtradebot(mocker, default_conf)
+
+
+@pytest.mark.parametrize("pairlist", AVAILABLE_PAIRLISTS)
+def test_pairlist_class(mocker, whitelist_conf, markets, pairlist):
+    whitelist_conf['pairlist']['method'] = pairlist
+    mocker.patch('freqtrade.exchange.Exchange.get_markets', markets)
+    mocker.patch('freqtrade.exchange.Exchange.exchange_has', MagicMock(return_value=True))
+    freqtrade = get_patched_freqtradebot(mocker, whitelist_conf)
+
+    assert freqtrade.pairlists.name == pairlist
+    assert pairlist in freqtrade.pairlists.short_desc()
+    assert isinstance(freqtrade.pairlists.whitelist, list)
+    assert isinstance(freqtrade.pairlists.blacklist, list)
+
+    whitelist = ['ETH/BTC', 'TKN/BTC']
+    new_whitelist = freqtrade.pairlists._validate_whitelist(whitelist)
+
+    assert set(whitelist) == set(new_whitelist)
+
+    whitelist = ['ETH/BTC', 'TKN/BTC', 'TRX/ETH']
+    new_whitelist = freqtrade.pairlists._validate_whitelist(whitelist)
+    # TRX/ETH was removed
+    assert set(['ETH/BTC', 'TKN/BTC']) == set(new_whitelist)
+
+    whitelist = ['ETH/BTC', 'TKN/BTC', 'BLK/BTC']
+    new_whitelist = freqtrade.pairlists._validate_whitelist(whitelist)
+    # BLK/BTC is in blacklist ...
+    assert set(['ETH/BTC', 'TKN/BTC']) == set(new_whitelist)

freqtrade/tests/rpc/test_fiat_convert.py

@@ -7,7 +7,7 @@ from unittest.mock import MagicMock
 import pytest
 from requests.exceptions import RequestException
 
-from freqtrade.fiat_convert import CryptoFiat, CryptoToFiatConverter
+from freqtrade.rpc.fiat_convert import CryptoFiat, CryptoToFiatConverter
 from freqtrade.tests.conftest import log_has, patch_coinmarketcap
 
 
@@ -81,16 +81,18 @@ def test_fiat_convert_find_price(mocker):
 
     assert fiat_convert.get_price(crypto_symbol='XRP', fiat_symbol='USD') == 0.0
 
-    mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=12345.0)
+    mocker.patch('freqtrade.rpc.fiat_convert.CryptoToFiatConverter._find_price',
+                 return_value=12345.0)
     assert fiat_convert.get_price(crypto_symbol='BTC', fiat_symbol='USD') == 12345.0
     assert fiat_convert.get_price(crypto_symbol='btc', fiat_symbol='usd') == 12345.0
 
-    mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=13000.2)
+    mocker.patch('freqtrade.rpc.fiat_convert.CryptoToFiatConverter._find_price',
+                 return_value=13000.2)
     assert fiat_convert.get_price(crypto_symbol='BTC', fiat_symbol='EUR') == 13000.2
 
 
 def test_fiat_convert_unsupported_crypto(mocker, caplog):
-    mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._cryptomap', return_value=[])
+    mocker.patch('freqtrade.rpc.fiat_convert.CryptoToFiatConverter._cryptomap', return_value=[])
     patch_coinmarketcap(mocker)
     fiat_convert = CryptoToFiatConverter()
     assert fiat_convert._find_price(crypto_symbol='CRYPTO_123', fiat_symbol='EUR') == 0.0
@@ -100,7 +102,8 @@ def test_fiat_convert_unsupported_crypto(mocker, caplog):
 def test_fiat_convert_get_price(mocker):
     patch_coinmarketcap(mocker)
 
-    mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=28000.0)
+    mocker.patch('freqtrade.rpc.fiat_convert.CryptoToFiatConverter._find_price',
+                 return_value=28000.0)
 
     fiat_convert = CryptoToFiatConverter()
 
@@ -114,7 +117,7 @@ def test_fiat_convert_get_price(mocker):
     assert fiat_convert._pairs[0].crypto_symbol == 'BTC'
     assert fiat_convert._pairs[0].fiat_symbol == 'USD'
     assert fiat_convert._pairs[0].price == 28000.0
-    assert fiat_convert._pairs[0]._expiration is not 0
+    assert fiat_convert._pairs[0]._expiration != 0
     assert len(fiat_convert._pairs) == 1
 
     # Verify the cached is used
@@ -157,7 +160,7 @@ def test_fiat_init_network_exception(mocker):
     # Because CryptoToFiatConverter is a Singleton we reset the listings
     listmock = MagicMock(side_effect=RequestException)
     mocker.patch.multiple(
-        'freqtrade.fiat_convert.Market',
+        'freqtrade.rpc.fiat_convert.Market',
         listings=listmock,
     )
     # with pytest.raises(RequestEsxception):
@@ -187,7 +190,7 @@ def test_fiat_invalid_response(mocker, caplog):
     # Because CryptoToFiatConverter is a Singleton we reset the listings
     listmock = MagicMock(return_value="{'novalidjson':DEADBEEFf}")
     mocker.patch.multiple(
-        'freqtrade.fiat_convert.Market',
+        'freqtrade.rpc.fiat_convert.Market',
         listings=listmock,
     )
     # with pytest.raises(RequestEsxception):
@@ -203,7 +206,7 @@ def test_fiat_invalid_response(mocker, caplog):
 
 def test_convert_amount(mocker):
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter.get_price', return_value=12345.0)
+    mocker.patch('freqtrade.rpc.fiat_convert.CryptoToFiatConverter.get_price', return_value=12345.0)
 
     fiat_convert = CryptoToFiatConverter()
     result = fiat_convert.convert_amount(

freqtrade/tests/rpc/test_rpc.py

@@ -5,12 +5,13 @@ from datetime import datetime
 from unittest.mock import MagicMock, ANY
 
 import pytest
+from numpy import isnan
 
-from freqtrade import TemporaryError
-from freqtrade.fiat_convert import CryptoToFiatConverter
+from freqtrade import TemporaryError, DependencyException
 from freqtrade.freqtradebot import FreqtradeBot
 from freqtrade.persistence import Trade
 from freqtrade.rpc import RPC, RPCException
+from freqtrade.rpc.fiat_convert import CryptoToFiatConverter
 from freqtrade.state import State
 from freqtrade.tests.test_freqtradebot import patch_get_signal
 from freqtrade.tests.conftest import patch_coinmarketcap, patch_exchange
@@ -40,10 +41,6 @@ def test_rpc_trade_status(default_conf, ticker, fee, markets, mocker) -> None:
     patch_get_signal(freqtradebot, (True, False))
     rpc = RPC(freqtradebot)
 
-    freqtradebot.state = State.STOPPED
-    with pytest.raises(RPCException, match=r'.*trader is not running*'):
-        rpc._rpc_trade_status()
-
     freqtradebot.state = State.RUNNING
     with pytest.raises(RPCException, match=r'.*no active trade*'):
         rpc._rpc_trade_status()
@@ -65,6 +62,27 @@ def test_rpc_trade_status(default_conf, ticker, fee, markets, mocker) -> None:
         'open_order': '(limit buy rem=0.00000000)'
     } == results[0]
 
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker',
+                 MagicMock(side_effect=DependencyException(f"Pair 'ETH/BTC' not available")))
+    # invalidate ticker cache
+    rpc._freqtrade.exchange._cached_ticker = {}
+    results = rpc._rpc_trade_status()
+    assert isnan(results[0]['current_profit'])
+    assert isnan(results[0]['current_rate'])
+    assert {
+        'trade_id': 1,
+        'pair': 'ETH/BTC',
+        'market_url': 'https://bittrex.com/Market/Index?MarketName=BTC-ETH',
+        'date': ANY,
+        'open_rate': 1.099e-05,
+        'close_rate': None,
+        'current_rate': ANY,
+        'amount': 90.99181074,
+        'close_profit': None,
+        'current_profit': ANY,
+        'open_order': '(limit buy rem=0.00000000)'
+    } == results[0]
+
 
 def test_rpc_status_table(default_conf, ticker, fee, markets, mocker) -> None:
     patch_coinmarketcap(mocker)
@@ -81,10 +99,6 @@ def test_rpc_status_table(default_conf, ticker, fee, markets, mocker) -> None:
     patch_get_signal(freqtradebot, (True, False))
     rpc = RPC(freqtradebot)
 
-    freqtradebot.state = State.STOPPED
-    with pytest.raises(RPCException, match=r'.*trader is not running*'):
-        rpc._rpc_status_table()
-
     freqtradebot.state = State.RUNNING
     with pytest.raises(RPCException, match=r'.*no active order*'):
         rpc._rpc_status_table()
@@ -95,6 +109,15 @@ def test_rpc_status_table(default_conf, ticker, fee, markets, mocker) -> None:
     assert 'ETH/BTC' in result['Pair'].all()
     assert '-0.59%' in result['Profit'].all()
 
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker',
+                 MagicMock(side_effect=DependencyException(f"Pair 'ETH/BTC' not available")))
+    # invalidate ticker cache
+    rpc._freqtrade.exchange._cached_ticker = {}
+    result = rpc._rpc_status_table()
+    assert 'just now' in result['Since'].all()
+    assert 'ETH/BTC' in result['Pair'].all()
+    assert 'nan%' in result['Profit'].all()
+
 
 def test_rpc_daily_profit(default_conf, update, ticker, fee,
                           limit_buy_order, limit_sell_order, markets, mocker) -> None:
@@ -148,7 +171,7 @@ def test_rpc_daily_profit(default_conf, update, ticker, fee,
 def test_rpc_trade_statistics(default_conf, ticker, ticker_sell_up, fee,
                               limit_buy_order, limit_sell_order, markets, mocker) -> None:
     mocker.patch.multiple(
-        'freqtrade.fiat_convert.Market',
+        'freqtrade.rpc.fiat_convert.Market',
         ticker=MagicMock(return_value={'price_usd': 15000.0}),
     )
     patch_coinmarketcap(mocker)
@@ -216,6 +239,20 @@ def test_rpc_trade_statistics(default_conf, ticker, ticker_sell_up, fee,
     assert stats['best_pair'] == 'ETH/BTC'
     assert prec_satoshi(stats['best_rate'], 6.2)
 
+    # Test non-available pair
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker',
+                 MagicMock(side_effect=DependencyException(f"Pair 'ETH/BTC' not available")))
+    # invalidate ticker cache
+    rpc._freqtrade.exchange._cached_ticker = {}
+    stats = rpc._rpc_trade_statistics(stake_currency, fiat_display_currency)
+    assert stats['trade_count'] == 2
+    assert stats['first_trade_date'] == 'just now'
+    assert stats['latest_trade_date'] == 'just now'
+    assert stats['avg_duration'] == '0:00:00'
+    assert stats['best_pair'] == 'ETH/BTC'
+    assert prec_satoshi(stats['best_rate'], 6.2)
+    assert isnan(stats['profit_all_coin'])
+
 
 # Test that rpc_trade_statistics can handle trades that lacks
 # trade.open_rate (it is set to None)
@@ -223,10 +260,11 @@ def test_rpc_trade_statistics_closed(mocker, default_conf, ticker, fee, markets,
                                      ticker_sell_up, limit_buy_order, limit_sell_order):
     patch_exchange(mocker)
     mocker.patch.multiple(
-        'freqtrade.fiat_convert.Market',
+        'freqtrade.rpc.fiat_convert.Market',
         ticker=MagicMock(return_value={'price_usd': 15000.0}),
     )
-    mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
+    mocker.patch('freqtrade.rpc.fiat_convert.CryptoToFiatConverter._find_price',
+                 return_value=15000.0)
     mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
     mocker.patch.multiple(
         'freqtrade.exchange.Exchange',
@@ -291,7 +329,7 @@ def test_rpc_balance_handle(default_conf, mocker):
     # ETH will be skipped due to mocked Error below
 
     mocker.patch.multiple(
-        'freqtrade.fiat_convert.Market',
+        'freqtrade.rpc.fiat_convert.Market',
         ticker=MagicMock(return_value={'price_usd': 15000.0}),
     )
     patch_coinmarketcap(mocker)
@@ -532,3 +570,108 @@ def test_rpc_count(mocker, default_conf, ticker, fee, markets) -> None:
     trades = rpc._rpc_count()
     nb_trades = len(trades)
     assert nb_trades == 1
+
+
+def test_rpcforcebuy(mocker, default_conf, ticker, fee, markets, limit_buy_order) -> None:
+    default_conf['forcebuy_enable'] = True
+    patch_coinmarketcap(mocker)
+    patch_exchange(mocker)
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
+    buy_mm = MagicMock(return_value={'id': limit_buy_order['id']})
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        get_balances=MagicMock(return_value=ticker),
+        get_ticker=ticker,
+        get_fee=fee,
+        get_markets=markets,
+        buy=buy_mm
+    )
+
+    freqtradebot = FreqtradeBot(default_conf)
+    patch_get_signal(freqtradebot, (True, False))
+    rpc = RPC(freqtradebot)
+    pair = 'ETH/BTC'
+    trade = rpc._rpc_forcebuy(pair, None)
+    assert isinstance(trade, Trade)
+    assert trade.pair == pair
+    assert trade.open_rate == ticker()['ask']
+
+    # Test buy duplicate
+    with pytest.raises(RPCException, match=r'position for ETH/BTC already open - id: 1'):
+        rpc._rpc_forcebuy(pair, 0.0001)
+    pair = 'XRP/BTC'
+    trade = rpc._rpc_forcebuy(pair, 0.0001)
+    assert isinstance(trade, Trade)
+    assert trade.pair == pair
+    assert trade.open_rate == 0.0001
+
+    # Test buy pair not with stakes
+    with pytest.raises(RPCException, match=r'Wrong pair selected. Please pairs with stake.*'):
+        rpc._rpc_forcebuy('XRP/ETH', 0.0001)
+    pair = 'XRP/BTC'
+
+    # Test not buying
+    default_conf['stake_amount'] = 0.0000001
+    freqtradebot = FreqtradeBot(default_conf)
+    patch_get_signal(freqtradebot, (True, False))
+    rpc = RPC(freqtradebot)
+    pair = 'TKN/BTC'
+    trade = rpc._rpc_forcebuy(pair, None)
+    assert trade is None
+
+
+def test_rpcforcebuy_stopped(mocker, default_conf) -> None:
+    default_conf['forcebuy_enable'] = True
+    default_conf['initial_state'] = 'stopped'
+    patch_coinmarketcap(mocker)
+    patch_exchange(mocker)
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
+
+    freqtradebot = FreqtradeBot(default_conf)
+    patch_get_signal(freqtradebot, (True, False))
+    rpc = RPC(freqtradebot)
+    pair = 'ETH/BTC'
+    with pytest.raises(RPCException, match=r'trader is not running'):
+        rpc._rpc_forcebuy(pair, None)
+
+
+def test_rpcforcebuy_disabled(mocker, default_conf) -> None:
+    patch_coinmarketcap(mocker)
+    patch_exchange(mocker)
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
+
+    freqtradebot = FreqtradeBot(default_conf)
+    patch_get_signal(freqtradebot, (True, False))
+    rpc = RPC(freqtradebot)
+    pair = 'ETH/BTC'
+    with pytest.raises(RPCException, match=r'Forcebuy not enabled.'):
+        rpc._rpc_forcebuy(pair, None)
+
+
+def test_rpc_whitelist(mocker, default_conf) -> None:
+    patch_coinmarketcap(mocker)
+    patch_exchange(mocker)
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
+
+    freqtradebot = FreqtradeBot(default_conf)
+    rpc = RPC(freqtradebot)
+    ret = rpc._rpc_whitelist()
+    assert ret['method'] == 'StaticPairList'
+    assert ret['whitelist'] == default_conf['exchange']['pair_whitelist']
+
+
+def test_rpc_whitelist_dynamic(mocker, default_conf) -> None:
+    patch_coinmarketcap(mocker)
+    patch_exchange(mocker)
+    default_conf['pairlist'] = {'method': 'VolumePairList',
+                                'config': {'number_assets': 4}
+                                }
+    mocker.patch('freqtrade.exchange.Exchange.exchange_has', MagicMock(return_value=True))
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
+
+    freqtradebot = FreqtradeBot(default_conf)
+    rpc = RPC(freqtradebot)
+    ret = rpc._rpc_whitelist()
+    assert ret['method'] == 'VolumePairList'
+    assert ret['length'] == 4
+    assert ret['whitelist'] == default_conf['exchange']['pair_whitelist']

freqtrade/tests/rpc/test_rpc_manager.py

@@ -113,3 +113,25 @@ def test_init_webhook_enabled(mocker, default_conf, caplog) -> None:
     assert log_has('Enabling rpc.webhook ...', caplog.record_tuples)
     assert len(rpc_manager.registered_modules) == 1
     assert 'webhook' in [mod.name for mod in rpc_manager.registered_modules]
+
+
+def test_startupmessages_telegram_enabled(mocker, default_conf, caplog) -> None:
+    telegram_mock = mocker.patch('freqtrade.rpc.telegram.Telegram.send_msg', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock())
+
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
+    rpc_manager = RPCManager(freqtradebot)
+    rpc_manager.startup_messages(default_conf, freqtradebot.pairlists)
+
+    assert telegram_mock.call_count == 3
+    assert "*Exchange:* `bittrex`" in telegram_mock.call_args_list[1][0][0]['status']
+
+    telegram_mock.reset_mock()
+    default_conf['dry_run'] = True
+    default_conf['whitelist'] = {'method': 'VolumePairList',
+                                 'config': {'number_assets': 20}
+                                 }
+
+    rpc_manager.startup_messages(default_conf,  freqtradebot.pairlists)
+    assert telegram_mock.call_count == 3
+    assert "Dry run is enabled." in telegram_mock.call_args_list[0][0][0]['status']

freqtrade/tests/rpc/test_rpc_telegram.py

@@ -17,6 +17,7 @@ from freqtrade.freqtradebot import FreqtradeBot
 from freqtrade.persistence import Trade
 from freqtrade.rpc import RPCMessageType
 from freqtrade.rpc.telegram import Telegram, authorized_only
+from freqtrade.strategy.interface import SellType
 from freqtrade.state import State
 from freqtrade.tests.conftest import (get_patched_freqtradebot, log_has,
                                       patch_exchange)
@@ -71,8 +72,9 @@ def test_init(default_conf, mocker, caplog) -> None:
     assert start_polling.start_polling.call_count == 1
 
     message_str = "rpc.telegram is listening for following commands: [['status'], ['profit'], " \
-                  "['balance'], ['start'], ['stop'], ['forcesell'], ['performance'], ['daily'], " \
-                  "['count'], ['reload_conf'], ['help'], ['version']]"
+                  "['balance'], ['start'], ['stop'], ['forcesell'], ['forcebuy'], " \
+                  "['performance'], ['daily'], ['count'], ['reload_conf'], " \
+                  "['whitelist'], ['help'], ['version']]"
 
     assert log_has(message_str, caplog.record_tuples)
 
@@ -250,9 +252,10 @@ def test_status_handle(default_conf, update, ticker, fee, markets, mocker) -> No
     telegram = Telegram(freqtradebot)
 
     freqtradebot.state = State.STOPPED
+    # Status is also enabled when stopped
     telegram._status(bot=MagicMock(), update=update)
     assert msg_mock.call_count == 1
-    assert 'trader is not running' in msg_mock.call_args_list[0][0][0]
+    assert 'no active trade' in msg_mock.call_args_list[0][0][0]
     msg_mock.reset_mock()
 
     freqtradebot.state = State.RUNNING
@@ -295,9 +298,10 @@ def test_status_table_handle(default_conf, update, ticker, fee, markets, mocker)
     telegram = Telegram(freqtradebot)
 
     freqtradebot.state = State.STOPPED
+    # Status table is also enabled when stopped
     telegram._status_table(bot=MagicMock(), update=update)
     assert msg_mock.call_count == 1
-    assert 'trader is not running' in msg_mock.call_args_list[0][0][0]
+    assert 'no active order' in msg_mock.call_args_list[0][0][0]
     msg_mock.reset_mock()
 
     freqtradebot.state = State.RUNNING
@@ -507,7 +511,12 @@ def test_telegram_balance_handle(default_conf, update, mocker) -> None:
             'total': 10.0,
             'free': 10.0,
             'used': 0.0
-        }
+        },
+        'XRP': {
+            'total': 1.0,
+            'free': 1.0,
+            'used': 0.0
+            }
     }
 
     def mock_ticker(symbol, refresh):
@@ -517,7 +526,12 @@ def test_telegram_balance_handle(default_conf, update, mocker) -> None:
                 'ask': 10000.00,
                 'last': 10000.00,
             }
-
+        elif symbol == 'XRP/BTC':
+            return {
+                'bid': 0.00001,
+                'ask': 0.00001,
+                'last': 0.00001,
+            }
         return {
             'bid': 0.1,
             'ask': 0.1,
@@ -548,7 +562,8 @@ def test_telegram_balance_handle(default_conf, update, mocker) -> None:
     assert '*USDT:*' in result
     assert 'Balance:' in result
     assert 'Est. BTC:' in result
-    assert 'BTC:  14.00000000' in result
+    assert 'BTC:  12.00000000' in result
+    assert '*XRP:* not showing <1$ amount' in result
 
 
 def test_balance_handle_empty_response(default_conf, update, mocker) -> None:
@@ -712,16 +727,18 @@ def test_forcesell_handle(default_conf, update, ticker, fee,
         'open_rate': 1.099e-05,
         'current_rate': 1.172e-05,
         'profit_amount': 6.126e-05,
-        'profit_percent': 0.06110514,
+        'profit_percent': 0.0611052,
         'stake_currency': 'BTC',
         'fiat_currency': 'USD',
+        'sell_reason': SellType.FORCE_SELL.value
     } == last_msg
 
 
 def test_forcesell_down_handle(default_conf, update, ticker, fee,
                                ticker_sell_down, markets, mocker) -> None:
     patch_coinmarketcap(mocker, value={'price_usd': 15000.0})
-    mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
+    mocker.patch('freqtrade.rpc.fiat_convert.CryptoToFiatConverter._find_price',
+                 return_value=15000.0)
     rpc_mock = mocker.patch('freqtrade.rpc.telegram.Telegram.send_msg', MagicMock())
     mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock())
     mocker.patch.multiple(
@@ -765,16 +782,18 @@ def test_forcesell_down_handle(default_conf, update, ticker, fee,
         'open_rate': 1.099e-05,
         'current_rate': 1.044e-05,
         'profit_amount': -5.492e-05,
-        'profit_percent': -0.05478343,
+        'profit_percent': -0.05478342,
         'stake_currency': 'BTC',
         'fiat_currency': 'USD',
+        'sell_reason': SellType.FORCE_SELL.value
     } == last_msg
 
 
 def test_forcesell_all_handle(default_conf, update, ticker, fee, markets, mocker) -> None:
     patch_coinmarketcap(mocker, value={'price_usd': 15000.0})
     patch_exchange(mocker)
-    mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
+    mocker.patch('freqtrade.rpc.fiat_convert.CryptoToFiatConverter._find_price',
+                 return_value=15000.0)
     rpc_mock = mocker.patch('freqtrade.rpc.telegram.Telegram.send_msg', MagicMock())
     mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock())
     mocker.patch('freqtrade.exchange.Exchange.get_pair_detail_url', MagicMock())
@@ -810,15 +829,17 @@ def test_forcesell_all_handle(default_conf, update, ticker, fee, markets, mocker
         'open_rate': 1.099e-05,
         'current_rate': 1.098e-05,
         'profit_amount': -5.91e-06,
-        'profit_percent': -0.00589292,
+        'profit_percent': -0.00589291,
         'stake_currency': 'BTC',
         'fiat_currency': 'USD',
+        'sell_reason': SellType.FORCE_SELL.value
     } == msg
 
 
 def test_forcesell_handle_invalid(default_conf, update, mocker) -> None:
     patch_coinmarketcap(mocker, value={'price_usd': 15000.0})
-    mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
+    mocker.patch('freqtrade.rpc.fiat_convert.CryptoToFiatConverter._find_price',
+                 return_value=15000.0)
     msg_mock = MagicMock()
     mocker.patch.multiple(
         'freqtrade.rpc.telegram.Telegram',
@@ -855,6 +876,63 @@ def test_forcesell_handle_invalid(default_conf, update, mocker) -> None:
     assert 'invalid argument' in msg_mock.call_args_list[0][0][0]
 
 
+def test_forcebuy_handle(default_conf, update, markets, mocker) -> None:
+    patch_coinmarketcap(mocker, value={'price_usd': 15000.0})
+    mocker.patch('freqtrade.rpc.rpc.CryptoToFiatConverter._find_price', return_value=15000.0)
+    mocker.patch('freqtrade.rpc.telegram.Telegram._send_msg', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock())
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        _load_markets=MagicMock(return_value={}),
+        get_markets=markets
+        )
+    fbuy_mock = MagicMock(return_value=None)
+    mocker.patch('freqtrade.rpc.RPC._rpc_forcebuy', fbuy_mock)
+
+    freqtradebot = FreqtradeBot(default_conf)
+    patch_get_signal(freqtradebot, (True, False))
+    telegram = Telegram(freqtradebot)
+
+    update.message.text = '/forcebuy ETH/BTC'
+    telegram._forcebuy(bot=MagicMock(), update=update)
+
+    assert fbuy_mock.call_count == 1
+    assert fbuy_mock.call_args_list[0][0][0] == 'ETH/BTC'
+    assert fbuy_mock.call_args_list[0][0][1] is None
+
+    # Reset and retry with specified price
+    fbuy_mock = MagicMock(return_value=None)
+    mocker.patch('freqtrade.rpc.RPC._rpc_forcebuy', fbuy_mock)
+    update.message.text = '/forcebuy ETH/BTC 0.055'
+    telegram._forcebuy(bot=MagicMock(), update=update)
+
+    assert fbuy_mock.call_count == 1
+    assert fbuy_mock.call_args_list[0][0][0] == 'ETH/BTC'
+    assert isinstance(fbuy_mock.call_args_list[0][0][1], float)
+    assert fbuy_mock.call_args_list[0][0][1] == 0.055
+
+
+def test_forcebuy_handle_exception(default_conf, update, markets, mocker) -> None:
+    patch_coinmarketcap(mocker, value={'price_usd': 15000.0})
+    mocker.patch('freqtrade.rpc.rpc.CryptoToFiatConverter._find_price', return_value=15000.0)
+    rpc_mock = mocker.patch('freqtrade.rpc.telegram.Telegram._send_msg', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock())
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        _load_markets=MagicMock(return_value={}),
+        get_markets=markets
+    )
+    freqtradebot = FreqtradeBot(default_conf)
+    patch_get_signal(freqtradebot, (True, False))
+    telegram = Telegram(freqtradebot)
+
+    update.message.text = '/forcebuy ETH/Nonepair'
+    telegram._forcebuy(bot=MagicMock(), update=update)
+
+    assert rpc_mock.call_count == 1
+    assert rpc_mock.call_args_list[0][0][0] == 'Forcebuy not enabled.'
+
+
 def test_performance_handle(default_conf, update, ticker, fee,
                             limit_buy_order, limit_sell_order, markets, mocker) -> None:
     patch_coinmarketcap(mocker)
@@ -895,26 +973,6 @@ def test_performance_handle(default_conf, update, ticker, fee,
     assert '<code>ETH/BTC\t6.20% (1)</code>' in msg_mock.call_args_list[0][0][0]
 
 
-def test_performance_handle_invalid(default_conf, update, mocker) -> None:
-    patch_coinmarketcap(mocker)
-    patch_exchange(mocker)
-    msg_mock = MagicMock()
-    mocker.patch.multiple(
-        'freqtrade.rpc.telegram.Telegram',
-        _init=MagicMock(),
-        _send_msg=msg_mock
-    )
-    freqtradebot = FreqtradeBot(default_conf)
-    patch_get_signal(freqtradebot, (True, False))
-    telegram = Telegram(freqtradebot)
-
-    # Trader is not running
-    freqtradebot.state = State.STOPPED
-    telegram._performance(bot=MagicMock(), update=update)
-    assert msg_mock.call_count == 1
-    assert 'not running' in msg_mock.call_args_list[0][0][0]
-
-
 def test_count_handle(default_conf, update, ticker, fee, markets, mocker) -> None:
     patch_coinmarketcap(mocker)
     patch_exchange(mocker)
@@ -956,6 +1014,46 @@ def test_count_handle(default_conf, update, ticker, fee, markets, mocker) -> Non
     assert msg in msg_mock.call_args_list[0][0][0]
 
 
+def test_whitelist_static(default_conf, update, mocker) -> None:
+    patch_coinmarketcap(mocker)
+    msg_mock = MagicMock()
+    mocker.patch.multiple(
+        'freqtrade.rpc.telegram.Telegram',
+        _init=MagicMock(),
+        _send_msg=msg_mock
+    )
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
+
+    telegram = Telegram(freqtradebot)
+
+    telegram._whitelist(bot=MagicMock(), update=update)
+    assert msg_mock.call_count == 1
+    assert ('Using whitelist `StaticPairList` with 4 pairs\n`ETH/BTC, LTC/BTC, XRP/BTC, NEO/BTC`'
+            in msg_mock.call_args_list[0][0][0])
+
+
+def test_whitelist_dynamic(default_conf, update, mocker) -> None:
+    patch_coinmarketcap(mocker)
+    msg_mock = MagicMock()
+    mocker.patch.multiple(
+        'freqtrade.rpc.telegram.Telegram',
+        _init=MagicMock(),
+        _send_msg=msg_mock
+    )
+    mocker.patch('freqtrade.exchange.Exchange.exchange_has', MagicMock(return_value=True))
+    default_conf['pairlist'] = {'method': 'VolumePairList',
+                                'config': {'number_assets': 4}
+                                }
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
+
+    telegram = Telegram(freqtradebot)
+
+    telegram._whitelist(bot=MagicMock(), update=update)
+    assert msg_mock.call_count == 1
+    assert ('Using whitelist `VolumePairList` with 4 pairs\n`ETH/BTC, LTC/BTC, XRP/BTC, NEO/BTC`'
+            in msg_mock.call_args_list[0][0][0])
+
+
 def test_help_handle(default_conf, update, mocker) -> None:
     patch_coinmarketcap(mocker)
     msg_mock = MagicMock()
@@ -1039,16 +1137,18 @@ def test_send_msg_sell_notification(default_conf, mocker) -> None:
         'profit_amount': -0.05746268,
         'profit_percent': -0.57405275,
         'stake_currency': 'ETH',
-        'fiat_currency': 'USD'
+        'fiat_currency': 'USD',
+        'sell_reason': SellType.STOP_LOSS.value
     })
     assert msg_mock.call_args[0][0] \
-        == '*Binance:* Selling [KEY/ETH]' \
-           '(https://www.binance.com/tradeDetail.html?symbol=KEY_ETH)\n' \
-           '*Limit:* `0.00003201`\n' \
-           '*Amount:* `1333.33333333`\n' \
-           '*Open Rate:* `0.00007500`\n' \
-           '*Current Rate:* `0.00003201`\n' \
-           '*Profit:* `-57.41%`` (loss: -0.05746268 ETH`` / -24.812 USD)`'
+        == ('*Binance:* Selling [KEY/ETH]'
+            '(https://www.binance.com/tradeDetail.html?symbol=KEY_ETH)\n'
+            '*Limit:* `0.00003201`\n'
+            '*Amount:* `1333.33333333`\n'
+            '*Open Rate:* `0.00007500`\n'
+            '*Current Rate:* `0.00003201`\n'
+            '*Sell Reason:* `stop_loss`\n'
+            '*Profit:* `-57.41%`` (loss: -0.05746268 ETH`` / -24.812 USD)`')
 
     msg_mock.reset_mock()
     telegram.send_msg({
@@ -1064,15 +1164,17 @@ def test_send_msg_sell_notification(default_conf, mocker) -> None:
         'profit_amount': -0.05746268,
         'profit_percent': -0.57405275,
         'stake_currency': 'ETH',
+        'sell_reason': SellType.STOP_LOSS.value
     })
     assert msg_mock.call_args[0][0] \
-        == '*Binance:* Selling [KEY/ETH]' \
-           '(https://www.binance.com/tradeDetail.html?symbol=KEY_ETH)\n' \
-           '*Limit:* `0.00003201`\n' \
-           '*Amount:* `1333.33333333`\n' \
-           '*Open Rate:* `0.00007500`\n' \
-           '*Current Rate:* `0.00003201`\n' \
-           '*Profit:* `-57.41%`'
+        == ('*Binance:* Selling [KEY/ETH]'
+            '(https://www.binance.com/tradeDetail.html?symbol=KEY_ETH)\n'
+            '*Limit:* `0.00003201`\n'
+            '*Amount:* `1333.33333333`\n'
+            '*Open Rate:* `0.00007500`\n'
+            '*Current Rate:* `0.00003201`\n'
+            '*Sell Reason:* `stop_loss`\n'
+            '*Profit:* `-57.41%`')
     # Reset singleton function to avoid random breaks
     telegram._fiat_converter.convert_amount = old_convamount
 
@@ -1190,7 +1292,8 @@ def test_send_msg_sell_notification_no_fiat(default_conf, mocker) -> None:
         'profit_amount': -0.05746268,
         'profit_percent': -0.57405275,
         'stake_currency': 'ETH',
-        'fiat_currency': 'USD'
+        'fiat_currency': 'USD',
+        'sell_reason': SellType.STOP_LOSS.value
     })
     assert msg_mock.call_args[0][0] \
         == '*Binance:* Selling [KEY/ETH]' \
@@ -1199,6 +1302,7 @@ def test_send_msg_sell_notification_no_fiat(default_conf, mocker) -> None:
            '*Amount:* `1333.33333333`\n' \
            '*Open Rate:* `0.00007500`\n' \
            '*Current Rate:* `0.00003201`\n' \
+           '*Sell Reason:* `stop_loss`\n' \
            '*Profit:* `-57.41%`'
 
 

freqtrade/tests/rpc/test_rpc_webhook.py

@@ -7,6 +7,7 @@ from requests import RequestException
 
 from freqtrade.rpc import RPCMessageType
 from freqtrade.rpc.webhook import Webhook
+from freqtrade.strategy.interface import SellType
 from freqtrade.tests.conftest import get_patched_freqtradebot, log_has
 
 
@@ -80,6 +81,7 @@ def test_send_msg(default_conf, mocker):
         'profit_amount': 0.001,
         'profit_percent': 0.20,
         'stake_currency': 'BTC',
+        'sell_reason': SellType.STOP_LOSS.value
     }
     webhook.send_msg(msg=msg)
     assert msg_mock.call_count == 1

freqtrade/tests/strategy/test_default_strategy.py

@@ -3,14 +3,14 @@ import json
 import pytest
 from pandas import DataFrame
 
-from freqtrade.exchange.exchange_helpers import parse_ticker_dataframe
+from freqtrade.data.converter import parse_ticker_dataframe
 from freqtrade.strategy.default_strategy import DefaultStrategy
 
 
 @pytest.fixture
 def result():
     with open('freqtrade/tests/testdata/ETH_BTC-1m.json') as data_file:
-        return parse_ticker_dataframe(json.load(data_file))
+        return parse_ticker_dataframe(json.load(data_file), '1m', fill_missing=True)
 
 
 def test_default_strategy_structure():

freqtrade/tests/strategy/test_interface.py

@@ -7,7 +7,8 @@ import arrow
 from pandas import DataFrame
 
 from freqtrade.arguments import TimeRange
-from freqtrade.optimize.__init__ import load_tickerdata_file
+from freqtrade.data.converter import parse_ticker_dataframe
+from freqtrade.data.history import load_tickerdata_file
 from freqtrade.persistence import Trade
 from freqtrade.tests.conftest import get_patched_exchange, log_has
 from freqtrade.strategy.default_strategy import DefaultStrategy
@@ -16,62 +17,69 @@ from freqtrade.strategy.default_strategy import DefaultStrategy
 _STRATEGY = DefaultStrategy(config={})
 
 
-def test_returns_latest_buy_signal(mocker, default_conf):
+def test_returns_latest_buy_signal(mocker, default_conf, ticker_history):
     mocker.patch.object(
         _STRATEGY, 'analyze_ticker',
         return_value=DataFrame([{'buy': 1, 'sell': 0, 'date': arrow.utcnow()}])
     )
-    assert _STRATEGY.get_signal('ETH/BTC', '5m', MagicMock()) == (True, False)
+    assert _STRATEGY.get_signal('ETH/BTC', '5m', ticker_history) == (True, False)
 
     mocker.patch.object(
         _STRATEGY, 'analyze_ticker',
         return_value=DataFrame([{'buy': 0, 'sell': 1, 'date': arrow.utcnow()}])
     )
-    assert _STRATEGY.get_signal('ETH/BTC', '5m', MagicMock()) == (False, True)
+    assert _STRATEGY.get_signal('ETH/BTC', '5m', ticker_history) == (False, True)
 
 
-def test_returns_latest_sell_signal(mocker, default_conf):
+def test_returns_latest_sell_signal(mocker, default_conf, ticker_history):
     mocker.patch.object(
         _STRATEGY, 'analyze_ticker',
         return_value=DataFrame([{'sell': 1, 'buy': 0, 'date': arrow.utcnow()}])
     )
 
-    assert _STRATEGY.get_signal('ETH/BTC', '5m', MagicMock()) == (False, True)
+    assert _STRATEGY.get_signal('ETH/BTC', '5m', ticker_history) == (False, True)
 
     mocker.patch.object(
         _STRATEGY, 'analyze_ticker',
         return_value=DataFrame([{'sell': 0, 'buy': 1, 'date': arrow.utcnow()}])
     )
-    assert _STRATEGY.get_signal('ETH/BTC', '5m', MagicMock()) == (True, False)
+    assert _STRATEGY.get_signal('ETH/BTC', '5m', ticker_history) == (True, False)
 
 
 def test_get_signal_empty(default_conf, mocker, caplog):
     assert (False, False) == _STRATEGY.get_signal('foo', default_conf['ticker_interval'],
-                                                  None)
+                                                  DataFrame())
     assert log_has('Empty ticker history for pair foo', caplog.record_tuples)
+    caplog.clear()
+
+    assert (False, False) == _STRATEGY.get_signal('bar', default_conf['ticker_interval'],
+                                                  [])
+    assert log_has('Empty ticker history for pair bar', caplog.record_tuples)
 
 
-def test_get_signal_exception_valueerror(default_conf, mocker, caplog):
+def test_get_signal_exception_valueerror(default_conf, mocker, caplog, ticker_history):
     caplog.set_level(logging.INFO)
     mocker.patch.object(
         _STRATEGY, 'analyze_ticker',
         side_effect=ValueError('xyz')
     )
-    assert (False, False) == _STRATEGY.get_signal('foo', default_conf['ticker_interval'], 1)
+    assert (False, False) == _STRATEGY.get_signal('foo', default_conf['ticker_interval'],
+                                                  ticker_history)
     assert log_has('Unable to analyze ticker for pair foo: xyz', caplog.record_tuples)
 
 
-def test_get_signal_empty_dataframe(default_conf, mocker, caplog):
+def test_get_signal_empty_dataframe(default_conf, mocker, caplog, ticker_history):
     caplog.set_level(logging.INFO)
     mocker.patch.object(
         _STRATEGY, 'analyze_ticker',
         return_value=DataFrame([])
     )
-    assert (False, False) == _STRATEGY.get_signal('xyz', default_conf['ticker_interval'], 1)
+    assert (False, False) == _STRATEGY.get_signal('xyz', default_conf['ticker_interval'],
+                                                  ticker_history)
     assert log_has('Empty dataframe for pair xyz', caplog.record_tuples)
 
 
-def test_get_signal_old_dataframe(default_conf, mocker, caplog):
+def test_get_signal_old_dataframe(default_conf, mocker, caplog, ticker_history):
     caplog.set_level(logging.INFO)
     # default_conf defines a 5m interval. we check interval * 2 + 5m
     # this is necessary as the last candle is removed (partial candles) by default
@@ -81,7 +89,8 @@ def test_get_signal_old_dataframe(default_conf, mocker, caplog):
         _STRATEGY, 'analyze_ticker',
         return_value=DataFrame(ticks)
     )
-    assert (False, False) == _STRATEGY.get_signal('xyz', default_conf['ticker_interval'], 1)
+    assert (False, False) == _STRATEGY.get_signal('xyz', default_conf['ticker_interval'],
+                                                  ticker_history)
     assert log_has(
         'Outdated history for pair xyz. Last tick is 16 minutes old',
         caplog.record_tuples
@@ -102,32 +111,78 @@ def test_tickerdata_to_dataframe(default_conf) -> None:
 
     timerange = TimeRange(None, 'line', 0, -100)
     tick = load_tickerdata_file(None, 'UNITTEST/BTC', '1m', timerange=timerange)
-    tickerlist = {'UNITTEST/BTC': tick}
+    tickerlist = {'UNITTEST/BTC': parse_ticker_dataframe(tick, '1m', True)}
     data = strategy.tickerdata_to_dataframe(tickerlist)
-    assert len(data['UNITTEST/BTC']) == 99       # partial candle was removed
+    assert len(data['UNITTEST/BTC']) == 102       # partial candle was removed
 
 
 def test_min_roi_reached(default_conf, fee) -> None:
-    strategy = DefaultStrategy(default_conf)
-    strategy.minimal_roi = {0: 0.1, 20: 0.05, 55: 0.01}
-    trade = Trade(
-        pair='ETH/BTC',
-        stake_amount=0.001,
-        open_date=arrow.utcnow().shift(hours=-1).datetime,
-        fee_open=fee.return_value,
-        fee_close=fee.return_value,
-        exchange='bittrex',
-        open_rate=1,
-    )
 
-    assert not strategy.min_roi_reached(trade, 0.01, arrow.utcnow().shift(minutes=-55).datetime)
-    assert strategy.min_roi_reached(trade, 0.12, arrow.utcnow().shift(minutes=-55).datetime)
+    # Use list to confirm sequence does not matter
+    min_roi_list = [{20: 0.05, 55: 0.01, 0: 0.1},
+                    {0: 0.1, 20: 0.05, 55: 0.01}]
+    for roi in min_roi_list:
+        strategy = DefaultStrategy(default_conf)
+        strategy.minimal_roi = roi
+        trade = Trade(
+            pair='ETH/BTC',
+            stake_amount=0.001,
+            open_date=arrow.utcnow().shift(hours=-1).datetime,
+            fee_open=fee.return_value,
+            fee_close=fee.return_value,
+            exchange='bittrex',
+            open_rate=1,
+        )
 
-    assert not strategy.min_roi_reached(trade, 0.04, arrow.utcnow().shift(minutes=-39).datetime)
-    assert strategy.min_roi_reached(trade, 0.06, arrow.utcnow().shift(minutes=-39).datetime)
+        assert not strategy.min_roi_reached(trade, 0.02, arrow.utcnow().shift(minutes=-56).datetime)
+        assert strategy.min_roi_reached(trade, 0.12, arrow.utcnow().shift(minutes=-56).datetime)
 
-    assert not strategy.min_roi_reached(trade, -0.01, arrow.utcnow().shift(minutes=-1).datetime)
-    assert strategy.min_roi_reached(trade, 0.02, arrow.utcnow().shift(minutes=-1).datetime)
+        assert not strategy.min_roi_reached(trade, 0.04, arrow.utcnow().shift(minutes=-39).datetime)
+        assert strategy.min_roi_reached(trade, 0.06, arrow.utcnow().shift(minutes=-39).datetime)
+
+        assert not strategy.min_roi_reached(trade, -0.01, arrow.utcnow().shift(minutes=-1).datetime)
+        assert strategy.min_roi_reached(trade, 0.02, arrow.utcnow().shift(minutes=-1).datetime)
+
+
+def test_min_roi_reached2(default_conf, fee) -> None:
+
+    # test with ROI raising after last interval
+    min_roi_list = [{20: 0.07,
+                     30: 0.05,
+                     55: 0.30,
+                     0: 0.1
+                     },
+                    {0: 0.1,
+                     20: 0.07,
+                     30: 0.05,
+                     55: 0.30
+                     },
+                    ]
+    for roi in min_roi_list:
+        strategy = DefaultStrategy(default_conf)
+        strategy.minimal_roi = roi
+        trade = Trade(
+            pair='ETH/BTC',
+            stake_amount=0.001,
+            open_date=arrow.utcnow().shift(hours=-1).datetime,
+            fee_open=fee.return_value,
+            fee_close=fee.return_value,
+            exchange='bittrex',
+            open_rate=1,
+        )
+
+        assert not strategy.min_roi_reached(trade, 0.02, arrow.utcnow().shift(minutes=-56).datetime)
+        assert strategy.min_roi_reached(trade, 0.12, arrow.utcnow().shift(minutes=-56).datetime)
+
+        assert not strategy.min_roi_reached(trade, 0.04, arrow.utcnow().shift(minutes=-39).datetime)
+        assert strategy.min_roi_reached(trade, 0.071, arrow.utcnow().shift(minutes=-39).datetime)
+
+        assert not strategy.min_roi_reached(trade, 0.04, arrow.utcnow().shift(minutes=-26).datetime)
+        assert strategy.min_roi_reached(trade, 0.06, arrow.utcnow().shift(minutes=-26).datetime)
+
+        # Should not trigger with 20% profit since after 55 minutes only 30% is active.
+        assert not strategy.min_roi_reached(trade, 0.20, arrow.utcnow().shift(minutes=-2).datetime)
+        assert strategy.min_roi_reached(trade, 0.31, arrow.utcnow().shift(minutes=-2).datetime)
 
 
 def test_analyze_ticker_default(ticker_history, mocker, caplog) -> None:
@@ -149,7 +204,7 @@ def test_analyze_ticker_default(ticker_history, mocker, caplog) -> None:
     assert buy_mock.call_count == 1
 
     assert log_has('TA Analysis Launched', caplog.record_tuples)
-    assert not log_has('Skippinig TA Analysis for already analyzed candle',
+    assert not log_has('Skipping TA Analysis for already analyzed candle',
                        caplog.record_tuples)
     caplog.clear()
 
@@ -159,7 +214,7 @@ def test_analyze_ticker_default(ticker_history, mocker, caplog) -> None:
     assert buy_mock.call_count == 2
     assert buy_mock.call_count == 2
     assert log_has('TA Analysis Launched', caplog.record_tuples)
-    assert not log_has('Skippinig TA Analysis for already analyzed candle',
+    assert not log_has('Skipping TA Analysis for already analyzed candle',
                        caplog.record_tuples)
 
 
@@ -179,11 +234,15 @@ def test_analyze_ticker_skip_analyze(ticker_history, mocker, caplog) -> None:
     strategy.process_only_new_candles = True
 
     ret = strategy.analyze_ticker(ticker_history, {'pair': 'ETH/BTC'})
+    assert 'high' in ret.columns
+    assert 'low' in ret.columns
+    assert 'close' in ret.columns
+    assert isinstance(ret, DataFrame)
     assert ind_mock.call_count == 1
     assert buy_mock.call_count == 1
     assert buy_mock.call_count == 1
     assert log_has('TA Analysis Launched', caplog.record_tuples)
-    assert not log_has('Skippinig TA Analysis for already analyzed candle',
+    assert not log_has('Skipping TA Analysis for already analyzed candle',
                        caplog.record_tuples)
     caplog.clear()
 
@@ -193,10 +252,10 @@ def test_analyze_ticker_skip_analyze(ticker_history, mocker, caplog) -> None:
     assert buy_mock.call_count == 1
     assert buy_mock.call_count == 1
     # only skipped analyze adds buy and sell columns, otherwise it's all mocked
-    assert 'buy' in ret
-    assert 'sell' in ret
+    assert 'buy' in ret.columns
+    assert 'sell' in ret.columns
     assert ret['buy'].sum() == 0
     assert ret['sell'].sum() == 0
     assert not log_has('TA Analysis Launched', caplog.record_tuples)
-    assert log_has('Skippinig TA Analysis for already analyzed candle',
+    assert log_has('Skipping TA Analysis for already analyzed candle',
                    caplog.record_tuples)

freqtrade/tests/strategy/test_strategy.py

@@ -2,6 +2,7 @@
 import logging
 from base64 import urlsafe_b64encode
 from os import path
+from pathlib import Path
 import warnings
 
 import pytest
@@ -10,7 +11,7 @@ from pandas import DataFrame
 from freqtrade.strategy import import_strategy
 from freqtrade.strategy.default_strategy import DefaultStrategy
 from freqtrade.strategy.interface import IStrategy
-from freqtrade.strategy.resolver import StrategyResolver
+from freqtrade.resolvers import StrategyResolver
 
 
 def test_import_strategy(caplog):
@@ -40,21 +41,21 @@ def test_import_strategy(caplog):
 
 def test_search_strategy():
     default_config = {}
-    default_location = path.join(path.dirname(
-        path.realpath(__file__)), '..', '..', 'strategy'
-    )
+    default_location = Path(__file__).parent.parent.joinpath('strategy').resolve()
     assert isinstance(
-        StrategyResolver._search_strategy(
-            default_location,
-            config=default_config,
-            strategy_name='DefaultStrategy'
+        StrategyResolver._search_object(
+            directory=default_location,
+            object_type=IStrategy,
+            kwargs={'config': default_config},
+            object_name='DefaultStrategy'
         ),
         IStrategy
     )
-    assert StrategyResolver._search_strategy(
-        default_location,
-        config=default_config,
-        strategy_name='NotFoundStrategy'
+    assert StrategyResolver._search_object(
+        directory=default_location,
+        object_type=IStrategy,
+        kwargs={'config': default_config},
+        object_name='NotFoundStrategy'
     ) is None
 
 
@@ -77,7 +78,7 @@ def test_load_strategy_invalid_directory(result, caplog):
     resolver._load_strategy('TestStrategy', config={}, extra_dir=extra_dir)
 
     assert (
-        'freqtrade.strategy.resolver',
+        'freqtrade.resolvers.strategy_resolver',
         logging.WARNING,
         'Path "{}" does not exist'.format(extra_dir),
     ) in caplog.record_tuples
@@ -88,8 +89,8 @@ def test_load_strategy_invalid_directory(result, caplog):
 def test_load_not_found_strategy():
     strategy = StrategyResolver()
     with pytest.raises(ImportError,
-                       match=r'Impossible to load Strategy \'NotFoundStrategy\'.'
-                             r' This class does not exist or contains Python code errors'):
+                       match=r"Impossible to load Strategy 'NotFoundStrategy'."
+                             r" This class does not exist or contains Python code errors"):
         strategy._load_strategy(strategy_name='NotFoundStrategy', config={})
 
 
@@ -128,7 +129,7 @@ def test_strategy_override_minimal_roi(caplog):
     resolver = StrategyResolver(config)
 
     assert resolver.strategy.minimal_roi[0] == 0.5
-    assert ('freqtrade.strategy.resolver',
+    assert ('freqtrade.resolvers.strategy_resolver',
             logging.INFO,
             "Override strategy 'minimal_roi' with value in config file: {'0': 0.5}."
             ) in caplog.record_tuples
@@ -143,12 +144,51 @@ def test_strategy_override_stoploss(caplog):
     resolver = StrategyResolver(config)
 
     assert resolver.strategy.stoploss == -0.5
-    assert ('freqtrade.strategy.resolver',
+    assert ('freqtrade.resolvers.strategy_resolver',
             logging.INFO,
             "Override strategy 'stoploss' with value in config file: -0.5."
             ) in caplog.record_tuples
 
 
+def test_strategy_override_trailing_stop(caplog):
+    caplog.set_level(logging.INFO)
+    config = {
+        'strategy': 'DefaultStrategy',
+        'trailing_stop': True
+    }
+    resolver = StrategyResolver(config)
+
+    assert resolver.strategy.trailing_stop
+    assert isinstance(resolver.strategy.trailing_stop, bool)
+    assert ('freqtrade.resolvers.strategy_resolver',
+            logging.INFO,
+            "Override strategy 'trailing_stop' with value in config file: True."
+            ) in caplog.record_tuples
+
+
+def test_strategy_override_trailing_stop_positive(caplog):
+    caplog.set_level(logging.INFO)
+    config = {
+        'strategy': 'DefaultStrategy',
+        'trailing_stop_positive': -0.1,
+        'trailing_stop_positive_offset': -0.2
+
+    }
+    resolver = StrategyResolver(config)
+
+    assert resolver.strategy.trailing_stop_positive == -0.1
+    assert ('freqtrade.resolvers.strategy_resolver',
+            logging.INFO,
+            "Override strategy 'trailing_stop_positive' with value in config file: -0.1."
+            ) in caplog.record_tuples
+
+    assert resolver.strategy.trailing_stop_positive_offset == -0.2
+    assert ('freqtrade.resolvers.strategy_resolver',
+            logging.INFO,
+            "Override strategy 'trailing_stop_positive' with value in config file: -0.1."
+            ) in caplog.record_tuples
+
+
 def test_strategy_override_ticker_interval(caplog):
     caplog.set_level(logging.INFO)
 
@@ -159,7 +199,7 @@ def test_strategy_override_ticker_interval(caplog):
     resolver = StrategyResolver(config)
 
     assert resolver.strategy.ticker_interval == 60
-    assert ('freqtrade.strategy.resolver',
+    assert ('freqtrade.resolvers.strategy_resolver',
             logging.INFO,
             "Override strategy 'ticker_interval' with value in config file: 60."
             ) in caplog.record_tuples
@@ -175,10 +215,138 @@ def test_strategy_override_process_only_new_candles(caplog):
     resolver = StrategyResolver(config)
 
     assert resolver.strategy.process_only_new_candles
-    assert ('freqtrade.strategy.resolver',
+    assert ('freqtrade.resolvers.strategy_resolver',
             logging.INFO,
-            "Override process_only_new_candles 'process_only_new_candles' "
-            "with value in config file: True."
+            "Override strategy 'process_only_new_candles' with value in config file: True."
+            ) in caplog.record_tuples
+
+
+def test_strategy_override_order_types(caplog):
+    caplog.set_level(logging.INFO)
+
+    order_types = {
+        'buy': 'market',
+        'sell': 'limit',
+        'stoploss': 'limit',
+        'stoploss_on_exchange': True,
+    }
+
+    config = {
+        'strategy': 'DefaultStrategy',
+        'order_types': order_types
+    }
+    resolver = StrategyResolver(config)
+
+    assert resolver.strategy.order_types
+    for method in ['buy', 'sell', 'stoploss', 'stoploss_on_exchange']:
+        assert resolver.strategy.order_types[method] == order_types[method]
+
+    assert ('freqtrade.resolvers.strategy_resolver',
+            logging.INFO,
+            "Override strategy 'order_types' with value in config file:"
+            " {'buy': 'market', 'sell': 'limit', 'stoploss': 'limit',"
+            " 'stoploss_on_exchange': True}."
+            ) in caplog.record_tuples
+
+    config = {
+        'strategy': 'DefaultStrategy',
+        'order_types': {'buy': 'market'}
+    }
+    # Raise error for invalid configuration
+    with pytest.raises(ImportError,
+                       match=r"Impossible to load Strategy 'DefaultStrategy'. "
+                             r"Order-types mapping is incomplete."):
+        StrategyResolver(config)
+
+
+def test_strategy_override_order_tif(caplog):
+    caplog.set_level(logging.INFO)
+
+    order_time_in_force = {
+        'buy': 'fok',
+        'sell': 'gtc',
+    }
+
+    config = {
+        'strategy': 'DefaultStrategy',
+        'order_time_in_force': order_time_in_force
+    }
+    resolver = StrategyResolver(config)
+
+    assert resolver.strategy.order_time_in_force
+    for method in ['buy', 'sell']:
+        assert resolver.strategy.order_time_in_force[method] == order_time_in_force[method]
+
+    assert ('freqtrade.resolvers.strategy_resolver',
+            logging.INFO,
+            "Override strategy 'order_time_in_force' with value in config file:"
+            " {'buy': 'fok', 'sell': 'gtc'}."
+            ) in caplog.record_tuples
+
+    config = {
+        'strategy': 'DefaultStrategy',
+        'order_time_in_force': {'buy': 'fok'}
+    }
+    # Raise error for invalid configuration
+    with pytest.raises(ImportError,
+                       match=r"Impossible to load Strategy 'DefaultStrategy'. "
+                             r"Order-time-in-force mapping is incomplete."):
+        StrategyResolver(config)
+
+
+def test_strategy_override_use_sell_signal(caplog):
+    caplog.set_level(logging.INFO)
+    config = {
+        'strategy': 'DefaultStrategy',
+    }
+    resolver = StrategyResolver(config)
+    assert not resolver.strategy.use_sell_signal
+    assert isinstance(resolver.strategy.use_sell_signal, bool)
+    # must be inserted to configuration
+    assert 'use_sell_signal' in config['experimental']
+    assert not config['experimental']['use_sell_signal']
+
+    config = {
+        'strategy': 'DefaultStrategy',
+        'experimental': {
+            'use_sell_signal': True,
+        },
+    }
+    resolver = StrategyResolver(config)
+
+    assert resolver.strategy.use_sell_signal
+    assert isinstance(resolver.strategy.use_sell_signal, bool)
+    assert ('freqtrade.resolvers.strategy_resolver',
+            logging.INFO,
+            "Override strategy 'use_sell_signal' with value in config file: True."
+            ) in caplog.record_tuples
+
+
+def test_strategy_override_use_sell_profit_only(caplog):
+    caplog.set_level(logging.INFO)
+    config = {
+        'strategy': 'DefaultStrategy',
+    }
+    resolver = StrategyResolver(config)
+    assert not resolver.strategy.sell_profit_only
+    assert isinstance(resolver.strategy.sell_profit_only, bool)
+    # must be inserted to configuration
+    assert 'sell_profit_only' in config['experimental']
+    assert not config['experimental']['sell_profit_only']
+
+    config = {
+        'strategy': 'DefaultStrategy',
+        'experimental': {
+            'sell_profit_only': True,
+        },
+    }
+    resolver = StrategyResolver(config)
+
+    assert resolver.strategy.sell_profit_only
+    assert isinstance(resolver.strategy.sell_profit_only, bool)
+    assert ('freqtrade.resolvers.strategy_resolver',
+            logging.INFO,
+            "Override strategy 'sell_profit_only' with value in config file: True."
             ) in caplog.record_tuples
 
 
@@ -196,7 +364,7 @@ def test_deprecate_populate_indicators(result):
             in str(w[-1].message)
 
     with warnings.catch_warnings(record=True) as w:
-            # Cause all warnings to always be triggered.
+        # Cause all warnings to always be triggered.
         warnings.simplefilter("always")
         resolver.strategy.advise_buy(indicators, 'ETH/BTC')
         assert len(w) == 1
@@ -226,13 +394,13 @@ def test_call_deprecated_function(result, monkeypatch):
     assert resolver.strategy._sell_fun_len == 2
 
     indicator_df = resolver.strategy.advise_indicators(result, metadata=metadata)
-    assert type(indicator_df) is DataFrame
+    assert isinstance(indicator_df, DataFrame)
     assert 'adx' in indicator_df.columns
 
     buydf = resolver.strategy.advise_buy(result, metadata=metadata)
-    assert type(buydf) is DataFrame
+    assert isinstance(buydf, DataFrame)
     assert 'buy' in buydf.columns
 
     selldf = resolver.strategy.advise_sell(result, metadata=metadata)
-    assert type(selldf) is DataFrame
+    assert isinstance(selldf, DataFrame)
     assert 'sell' in selldf

freqtrade/tests/test_acl_pair.py

@@ -1,87 +0,0 @@
-# pragma pylint: disable=missing-docstring,C0103,protected-access
-
-from unittest.mock import MagicMock
-
-from freqtrade.tests.conftest import get_patched_freqtradebot
-
-import pytest
-
-# whitelist, blacklist, filtering, all of that will
-# eventually become some rules to run on a generic ACL engine
-# perhaps try to anticipate that by using some python package
-
-
-@pytest.fixture(scope="function")
-def whitelist_conf(default_conf):
-    default_conf['stake_currency'] = 'BTC'
-    default_conf['exchange']['pair_whitelist'] = [
-        'ETH/BTC',
-        'TKN/BTC',
-        'TRST/BTC',
-        'SWT/BTC',
-        'BCC/BTC'
-    ]
-    default_conf['exchange']['pair_blacklist'] = [
-        'BLK/BTC'
-    ]
-
-    return default_conf
-
-
-def test_refresh_market_pair_not_in_whitelist(mocker, markets, whitelist_conf):
-
-    freqtradebot = get_patched_freqtradebot(mocker, whitelist_conf)
-
-    mocker.patch('freqtrade.exchange.Exchange.get_markets', markets)
-    refreshedwhitelist = freqtradebot._refresh_whitelist(
-        whitelist_conf['exchange']['pair_whitelist'] + ['XXX/BTC']
-    )
-    # List ordered by BaseVolume
-    whitelist = ['ETH/BTC', 'TKN/BTC']
-    # Ensure all except those in whitelist are removed
-    assert whitelist == refreshedwhitelist
-
-
-def test_refresh_whitelist(mocker, markets, whitelist_conf):
-    freqtradebot = get_patched_freqtradebot(mocker, whitelist_conf)
-
-    mocker.patch('freqtrade.exchange.Exchange.get_markets', markets)
-    refreshedwhitelist = freqtradebot._refresh_whitelist(
-        whitelist_conf['exchange']['pair_whitelist'])
-
-    # List ordered by BaseVolume
-    whitelist = ['ETH/BTC', 'TKN/BTC']
-    # Ensure all except those in whitelist are removed
-    assert whitelist == refreshedwhitelist
-
-
-def test_refresh_whitelist_dynamic(mocker, markets, tickers, whitelist_conf):
-    freqtradebot = get_patched_freqtradebot(mocker, whitelist_conf)
-    mocker.patch.multiple(
-        'freqtrade.exchange.Exchange',
-        get_markets=markets,
-        get_tickers=tickers,
-        exchange_has=MagicMock(return_value=True)
-    )
-
-    # argument: use the whitelist dynamically by exchange-volume
-    whitelist = ['ETH/BTC', 'TKN/BTC']
-
-    refreshedwhitelist = freqtradebot._refresh_whitelist(
-        freqtradebot._gen_pair_whitelist(whitelist_conf['stake_currency'])
-    )
-
-    assert whitelist == refreshedwhitelist
-
-
-def test_refresh_whitelist_dynamic_empty(mocker, markets_empty, whitelist_conf):
-    freqtradebot = get_patched_freqtradebot(mocker, whitelist_conf)
-    mocker.patch('freqtrade.exchange.Exchange.get_markets', markets_empty)
-
-    # argument: use the whitelist dynamically by exchange-volume
-    whitelist = []
-    whitelist_conf['exchange']['pair_whitelist'] = []
-    freqtradebot._refresh_whitelist(whitelist)
-    pairslist = whitelist_conf['exchange']['pair_whitelist']
-
-    assert set(whitelist) == set(pairslist)

freqtrade/tests/test_arguments.py

@@ -17,7 +17,8 @@ def test_parse_args_none() -> None:
 def test_parse_args_defaults() -> None:
     args = Arguments([], '').get_parsed_arg()
     assert args.config == 'config.json'
-    assert args.dynamic_whitelist is None
+    assert args.strategy_path is None
+    assert args.datadir is None
     assert args.loglevel == 0
 
 
@@ -46,7 +47,7 @@ def test_scripts_options() -> None:
     arguments = Arguments(['-p', 'ETH/BTC'], '')
     arguments.scripts_options()
     args = arguments.get_parsed_arg()
-    assert args.pair == 'ETH/BTC'
+    assert args.pairs == 'ETH/BTC'
 
 
 def test_parse_args_version() -> None: