master to RELEASE 0.17.1

Scheduled daily dependency update on wednesday

.coveragerc

@@ -3,3 +3,4 @@ omit =
     scripts/*
     freqtrade/tests/*
     freqtrade/vendor/*
+    freqtrade/__main__.py

.github/ISSUE_TEMPLATE.md

@@ -1,15 +1,17 @@
 ## Step 1: Have you search for this issue before posting it?
 
-If you have discovered a bug in the bot, please [search our issue tracker](https://github.com/gcarq/freqtrade/issues?q=is%3Aissue). 
+If you have discovered a bug in the bot, please [search our issue tracker](https://github.com/freqtrade/freqtrade/issues?q=is%3Aissue). 
 If it hasn't been reported, please create a new issue.
 
 ## Step 2: Describe your environment
 
   * Python Version: _____ (`python -V`)
+  * CCXT version: _____ (`pip freeze | grep ccxt`)
   * Branch: Master | Develop
   * Last Commit ID: _____ (`git log --format="%H" -n 1`)
   
 ## Step 3: Describe the problem:
+
 *Explain the problem you have encountered*
 
 ### Steps to reproduce:

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,5 +1,5 @@
 Thank you for sending your pull request. But first, have you included
-unit tests, and is your code PEP8 conformant? [More details](https://github.com/gcarq/freqtrade/blob/develop/CONTRIBUTING.md)
+unit tests, and is your code PEP8 conformant? [More details](https://github.com/freqtrade/freqtrade/blob/develop/CONTRIBUTING.md)
 
 ## Summary
 Explain in one sentence the goal of this PR

.gitignore

@@ -1,13 +1,14 @@
 # Freqtrade rules
 freqtrade/tests/testdata/*.json
 hyperopt_conf.py
-config.json
+config*.json
 *.sqlite
 .hyperopt
 logfile.txt
 hyperopt_trials.pickle
 user_data/
 freqtrade-plot.html
+freqtrade-profit-plot.html
 
 # Byte-compiled / optimized / DLL files
 __pycache__/
@@ -90,3 +91,4 @@ target/
 .vscode
 
 .pytest_cache/
+.mypy_cache/

.pyup.yml

@@ -0,0 +1,4 @@
+# autogenerated pyup.io config file 
+# see https://pyup.io/docs/configuration/ for all available options
+
+schedule: every day

.travis.yml

@@ -13,21 +13,22 @@ addons:
 install:
 - ./install_ta-lib.sh
 - export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH
-- pip install --upgrade flake8 coveralls pytest-random-order
+- pip install --upgrade flake8 coveralls pytest-random-order mypy
 - pip install -r requirements.txt
 - pip install -e .
 jobs:
   include:
-    - script: pytest --cov=freqtrade --cov-config=.coveragerc freqtrade/tests/
+    - script: 
+      - pytest --cov=freqtrade --cov-config=.coveragerc freqtrade/tests/
+      - coveralls
     - script:
       - cp config.json.example config.json
-      - python freqtrade/main.py backtesting
+      - python freqtrade/main.py --datadir freqtrade/tests/testdata backtesting
     - script:
       - cp config.json.example config.json
-      - python freqtrade/main.py hyperopt -e 5
+      - python freqtrade/main.py --datadir freqtrade/tests/testdata hyperopt -e 5
     - script: flake8 freqtrade
-after_success:
-- coveralls
+    - script: mypy freqtrade
 notifications:
   slack:
     secure: bKLXmOrx8e2aPZl7W8DA5BdPAXWGpI5UzST33oc1G/thegXcDVmHBTJrBs4sZak6bgAclQQrdZIsRd2eFYzHLalJEaw6pk7hoAw8SvLnZO0ZurWboz7qg2+aZZXfK4eKl/VUe4sM9M4e/qxjkK+yWG7Marg69c4v1ypF7ezUi1fPYILYw8u0paaiX0N5UX8XNlXy+PBlga2MxDjUY70MuajSZhPsY2pDUvYnMY1D/7XN3cFW0g+3O8zXjF0IF4q1Z/1ASQe+eYjKwPQacE+O8KDD+ZJYoTOFBAPllrtpO1jnOPFjNGf3JIbVMZw4bFjIL0mSQaiSUaUErbU3sFZ5Or79rF93XZ81V7uEZ55vD8KMfR2CB1cQJcZcj0v50BxLo0InkFqa0Y8Nra3sbpV4fV5Oe8pDmomPJrNFJnX6ULQhQ1gTCe0M5beKgVms5SITEpt4/Y0CmLUr6iHDT0CUiyMIRWAXdIgbGh1jfaWOMksybeRevlgDsIsNBjXmYI1Sw2ZZR2Eo2u4R6zyfyjOMLwYJ3vgq9IrACv2w5nmf0+oguMWHf6iWi2hiOqhlAN1W74+3HsYQcqnuM3LGOmuCnPprV1oGBqkPXjIFGpy21gNx4vHfO1noLUyJnMnlu2L7SSuN1CdLsnjJ1hVjpJjPfqB4nn8g12x87TqM1bOm+3Q=

CONTRIBUTING.md

@@ -7,7 +7,7 @@ Feel like our bot is missing a feature? We welcome your pull requests! Few point
 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/gcarq/freqtrade/issues) before a PR.
+or in a [issue](https://github.com/freqtrade/freqtrade/issues) before a PR.
 
 
 **Before sending the PR:**
@@ -42,4 +42,21 @@ pip3.6 install flake8 coveralls
 flake8 freqtrade
 ```
 
+We receive a lot of code that fails the `flake8` checks.
+To help with that, we encourage you to install the git pre-commit 
+hook that will warn you when you try to commit code that fails these checks. 
+Guide for installing them is [here](http://flake8.pycqa.org/en/latest/user/using-hooks.html).
 
+## 3. Test if all type-hints are correct
+
+**Install packages** (If not already installed)
+
+``` bash
+pip3.6 install mypy
+```
+
+**Run mypy**
+
+``` bash
+mypy freqtrade
+```

Dockerfile

@@ -1,10 +1,11 @@
-FROM python:3.6.5-slim-stretch
+FROM python:3.6.6-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
@@ -15,7 +16,8 @@ WORKDIR /freqtrade
 
 # Install dependencies
 COPY requirements.txt /freqtrade/
-RUN pip install -r requirements.txt
+RUN pip install numpy \
+  && pip install -r requirements.txt
 
 # Install and execute
 COPY . /freqtrade/

README.md

@@ -1,16 +1,15 @@
 # freqtrade
 
-[![Build Status](https://travis-ci.org/gcarq/freqtrade.svg?branch=develop)](https://travis-ci.org/gcarq/freqtrade)
-[![Coverage Status](https://coveralls.io/repos/github/gcarq/freqtrade/badge.svg?branch=develop&service=github)](https://coveralls.io/github/gcarq/freqtrade?branch=develop)
-[![Maintainability](https://api.codeclimate.com/v1/badges/5737e6d668200b7518ff/maintainability)](https://codeclimate.com/github/gcarq/freqtrade/maintainability)
+[![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)
 
+Simple High frequency trading bot for crypto currencies designed to support multi exchanges and be controlled via Telegram.
 
-Simple High frequency trading bot for crypto currencies designed to 
-support multi exchanges and be controlled via Telegram.
-
-![freqtrade](https://raw.githubusercontent.com/gcarq/freqtrade/develop/docs/assets/freqtrade-screenshot.png)
+![freqtrade](https://raw.githubusercontent.com/freqtrade/freqtrade/develop/docs/assets/freqtrade-screenshot.png)
 
 ## 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. 
@@ -22,130 +21,85 @@ 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.
 
+## Exchange marketplaces supported
+
+- [X] [Bittrex](https://bittrex.com/)
+- [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)_
+
+## 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] **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] **Blacklist crypto-currencies**: Select which crypto-currency you want to avoid.
+- [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
-- [Features](#features)
+
 - [Quick start](#quick-start)
-- [Documentations](https://github.com/gcarq/freqtrade/blob/develop/docs/index.md)
-   - [Installation](https://github.com/gcarq/freqtrade/blob/develop/docs/installation.md)
-   - [Configuration](https://github.com/gcarq/freqtrade/blob/develop/docs/configuration.md)
-   - [Strategy Optimization](https://github.com/gcarq/freqtrade/blob/develop/docs/bot-optimization.md)
-   - [Backtesting](https://github.com/gcarq/freqtrade/blob/develop/docs/backtesting.md)
-   - [Hyperopt](https://github.com/gcarq/freqtrade/blob/develop/docs/hyperopt.md)
+- [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)
-- [Basic Usage](#basic-usage)
-  - [Bot commands](#bot-commands)
-  - [Telegram RPC commands](#telegram-rpc-commands)
 - [Requirements](#requirements)
   - [Min hardware required](#min-hardware-required)
   - [Software requirements](#software-requirements)
  
-## Branches
-The project is currently setup in two main branches:
-- `develop` - This branch has often new features, but might also cause 
-breaking changes.
-- `master` - This branch contains the latest stable release. The bot 
-'should' be stable on this branch, and is generally well tested. 
-
-## 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] **Dry-run**: Run the bot without playing money.
-- [x] **Backtesting**: Run a simulation of your buy/sell strategy.
-- [x] **Strategy Optimization**: Optimize your buy/sell strategy 
-parameters with Hyperopts.
-- [x] **Whitelist crypto-currencies**: Select which crypto-currency you
-want to trade.
-- [x] **Blacklist crypto-currencies**: Select which crypto-currency you
-want to avoid.
-- [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.
-
-### Exchange supported
-- [x] Bittrex
-- [ ] Binance
-- [ ] Others
 
 ## Quick start
-This quick start section is a very short explanation on how to test the 
-bot in dry-run. We invite you to read the 
-[bot documentation](https://github.com/gcarq/freqtrade/blob/develop/docs/index.md) 
-to ensure you understand how the bot is working.
 
-### Easy installation
-The script below will install all dependencies and help you to configure the bot.
+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
 ```
 
-### Manual installation
-The following steps are made for Linux/MacOS environment
+_Windows installation is explained in [Installation doc](https://github.com/freqtrade/freqtrade/blob/develop/docs/installation.md)_
 
-**1. Clone the repo**
-```bash
-git clone git@github.com:gcarq/freqtrade.git
-git checkout develop
-cd freqtrade
-```
-**2. Create the config file**  
-Switch `"dry_run": true,`
-```bash
-cp config.json.example config.json
-vi config.json
-```
-**3. Build your docker image and run it**
-```bash
-docker build -t freqtrade .
-docker run --rm -v /etc/localtime:/etc/localtime:ro -v `pwd`/config.json:/freqtrade/config.json -it freqtrade
-```
+## Documentation
 
+We invite you to read the bot documentation to ensure you understand how the bot is working.
 
-### 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 to join Slack channel](https://join.slack.com/t/highfrequencybot/shared_invite/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE).
-
-### [Bugs / Issues](https://github.com/gcarq/freqtrade/issues?q=is%3Aissue)
-If you discover a bug in the bot, please 
-[search our issue tracker](https://github.com/gcarq/freqtrade/issues?q=is%3Aissue) 
-first. If it hasn't been reported, please 
-[create a new issue](https://github.com/gcarq/freqtrade/issues/new) and 
-ensure you follow the template guide so that our team can assist you as 
-quickly as possible.
-
-### [Feature Requests](https://github.com/gcarq/freqtrade/labels/enhancement)
-Have you a great idea to improve the bot you want to share? Please,
-first search if this feature was not [already discussed](https://github.com/gcarq/freqtrade/labels/enhancement).
-If it hasn't been requested, please 
-[create a new request](https://github.com/gcarq/freqtrade/issues/new) 
-and ensure you follow the template guide so that it does not get lost 
-in the bug reports.
-
-### [Pull Requests](https://github.com/gcarq/freqtrade/pulls)
-Feel like our bot is missing a feature? We welcome your pull requests! 
-Please read our 
-[Contributing document](https://github.com/gcarq/freqtrade/blob/develop/CONTRIBUTING.md)
-to understand the requirements before sending your pull-requests. 
-
-**Important:** Always create your PR against the `develop` branch, not 
-`master`.
+- [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] [--dry-run-db] [--datadir PATH]
-               [--dynamic-whitelist [INT]]
+usage: main.py [-h] [-v] [--version] [-c PATH] [-d PATH] [-s NAME]
+               [--strategy-path PATH] [--dynamic-whitelist [INT]]
+               [--dry-run-db]
                {backtesting,hyperopt} ...
 
 Simple High Frequency Trading Bot for crypto currencies
@@ -161,44 +115,99 @@ optional arguments:
   --version             show program's version number and exit
   -c PATH, --config PATH
                         specify configuration file (default: config.json)
-  --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.
-  --datadir PATH        path to backtest data (default freqdata/tests/testdata
+  -d PATH, --datadir PATH
+                        path to backtest data (default:
+                        freqtrade/tests/testdata
+  -s NAME, --strategy NAME
+                        specify strategy class name (default: DefaultStrategy)
+  --strategy-path PATH  specify additional strategy lookup path
   --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.
 ```
-More details on:
-- [How to run the bot](https://github.com/gcarq/freqtrade/blob/develop/docs/bot-usage.md#bot-commands)
-- [How to use Backtesting](https://github.com/gcarq/freqtrade/blob/develop/docs/bot-usage.md#backtesting-commands)
-- [How to use Hyperopt](https://github.com/gcarq/freqtrade/blob/develop/docs/bot-usage.md#hyperopt-commands)
 
 ### 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/gcarq/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://github.com/freqtrade/freqtrade/blob/develop/docs/index.md)
 
 - `/start`: Starts the trader
 - `/stop`: Stops the trader
 - `/status [table]`: Lists all open trades
 - `/count`: Displays number of open trades
 - `/profit`: Lists cumulative profit from all finished trades
-- `/forcesell <trade_id>|all`: Instantly sells the given trade 
-(Ignoring `minimum_roi`).
+- `/forcesell <trade_id>|all`: Instantly sells the given trade (Ignoring `minimum_roi`).
 - `/performance`: Show performance of each finished trade grouped by pair
 - `/balance`: Show account balance per currency
 - `/daily <n>`: Shows profit or loss per day, over the last n days
 - `/help`: Show help message
 - `/version`: Show version
 
+
+## Development branches
+
+The project is currently setup in two main branches:
+
+- `develop` - This branch has often new features, but might also cause breaking changes.
+- `master` - This branch contains the latest stable release. The bot 'should' be stable on this branch, and is generally well tested.
+- `feat/*` - These are feature branches, which are beeing worked on heavily. Please don't use these unless you want to test a specific feature.
+
+
+## A note on Binance
+
+For Binance, please add `"BNB/<STAKE>"` to your blacklist to avoid issues.
+Accounts having BNB accounts use this to pay for fees - if your first trade happens to be on `BNB`, further trades will consume this position and make the initial BNB order unsellable as the expected amount is not there anymore.
+
+## 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 to join Slack channel](https://join.slack.com/t/highfrequencybot/shared_invite/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE).
+
+### [Bugs / Issues](https://github.com/freqtrade/freqtrade/issues?q=is%3Aissue)
+
+If you discover a bug in the bot, please 
+[search our issue tracker](https://github.com/freqtrade/freqtrade/issues?q=is%3Aissue) 
+first. If it hasn't been reported, please 
+[create a new issue](https://github.com/freqtrade/freqtrade/issues/new) and 
+ensure you follow the template guide so that our team can assist you as 
+quickly as possible.
+
+### [Feature Requests](https://github.com/freqtrade/freqtrade/labels/enhancement)
+
+Have you a great idea to improve the bot you want to share? Please,
+first search if this feature was not [already discussed](https://github.com/freqtrade/freqtrade/labels/enhancement).
+If it hasn't been requested, please 
+[create a new request](https://github.com/freqtrade/freqtrade/issues/new) 
+and ensure you follow the template guide so that it does not get lost 
+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. 
+
+**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`.
+
 ## Requirements
 
 ### Min hardware required
+
 To run this bot we recommend you a cloud instance with a minimum of:
-* Minimal (advised) system requirements: 2GB RAM, 1GB disk space, 2vCPU
+
+- Minimal (advised) system requirements: 2GB RAM, 1GB disk space, 2vCPU
 
 ### Software requirements
+
 - [Python 3.6.x](http://docs.python-guide.org/en/latest/starting/installation/) 
 - [pip](https://pip.pypa.io/en/stable/installing/)
 - [git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)

config.json.example

@@ -3,8 +3,13 @@
     "stake_currency": "BTC",
     "stake_amount": 0.05,
     "fiat_display_currency": "USD",
+    "ticker_interval" : "5m",
     "dry_run": false,
-    "unfilledtimeout": 600,
+    "trailing_stop": false,
+    "unfilledtimeout": {
+        "buy": 10,
+        "sell": 30
+    },
     "bid_strategy": {
         "ask_last_balance": 0.0
     },
@@ -12,25 +17,27 @@
         "name": "bittrex",
         "key": "your_exchange_key",
         "secret": "your_exchange_secret",
+        "ccxt_rate_limit": true,
         "pair_whitelist": [
-            "BTC_ETH",
-            "BTC_LTC",
-            "BTC_ETC",
-            "BTC_DASH",
-            "BTC_ZEC",
-            "BTC_XLM",
-            "BTC_NXT",
-            "BTC_POWR",
-            "BTC_ADA",
-            "BTC_XMR"
+            "ETH/BTC",
+            "LTC/BTC",
+            "ETC/BTC",
+            "DASH/BTC",
+            "ZEC/BTC",
+            "XLM/BTC",
+            "NXT/BTC",
+            "POWR/BTC",
+            "ADA/BTC",
+            "XMR/BTC"
         ],
         "pair_blacklist": [
-            "BTC_DOGE"
+            "DOGE/BTC"
         ]
     },
     "experimental": {
         "use_sell_signal": false,
-        "sell_profit_only": false
+        "sell_profit_only": false,
+        "ignore_roi_if_buy_signal": false
     },
     "telegram": {
         "enabled": true,

config_full.json.example

@@ -4,7 +4,10 @@
     "stake_amount": 0.05,
     "fiat_display_currency": "USD",
     "dry_run": false,
-    "ticker_interval": 5,
+    "ticker_interval": "5m",
+    "trailing_stop": false,
+    "trailing_stop_positive": 0.005,
+    "trailing_stop_positive_offset": 0.0051,
     "minimal_roi": {
         "40":  0.0,
         "30":  0.01,
@@ -12,7 +15,10 @@
         "0":  0.04
     },
     "stoploss": -0.10,
-    "unfilledtimeout": 600,
+    "unfilledtimeout": {
+        "buy": 10,
+        "sell": 30
+    },
     "bid_strategy": {
         "ask_last_balance": 0.0
     },
@@ -20,31 +26,34 @@
         "name": "bittrex",
         "key": "your_exchange_key",
         "secret": "your_exchange_secret",
+        "ccxt_rate_limit": true,
         "pair_whitelist": [
-            "BTC_ETH",
-            "BTC_LTC",
-            "BTC_ETC",
-            "BTC_DASH",
-            "BTC_ZEC",
-            "BTC_XLM",
-            "BTC_NXT",
-            "BTC_POWR",
-            "BTC_ADA",
-            "BTC_XMR"
+            "ETH/BTC",
+            "LTC/BTC",
+            "ETC/BTC",
+            "DASH/BTC",
+            "ZEC/BTC",
+            "XLM/BTC",
+            "NXT/BTC",
+            "POWR/BTC",
+            "ADA/BTC",
+            "XMR/BTC"
         ],
         "pair_blacklist": [
-            "BTC_DOGE"
+            "DOGE/BTC"
         ]
     },
     "experimental": {
         "use_sell_signal": false,
-        "sell_profit_only": false
+        "sell_profit_only": false,
+        "ignore_roi_if_buy_signal": false
     },
     "telegram": {
         "enabled": true,
         "token": "your_telegram_token",
         "chat_id": "your_telegram_chat_id"
     },
+    "db_url": "sqlite:///tradesv3.sqlite",
     "initial_state": "running",
     "internals": {
         "process_throttle_secs": 5

docs/backtesting.md

@@ -1,137 +1,216 @@
 # Backtesting
+
 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
 real data. This is what we call 
 [backtesting](https://en.wikipedia.org/wiki/Backtesting).
 
-
 Backtesting will use the crypto-currencies (pair) from your config file
 and load static tickers located in 
-[/freqtrade/tests/testdata](https://github.com/gcarq/freqtrade/tree/develop/freqtrade/tests/testdata).  
+[/freqtrade/tests/testdata](https://github.com/freqtrade/freqtrade/tree/develop/freqtrade/tests/testdata).  
 If the 5 min and 1 min ticker for the crypto-currencies to test is not 
 already in the `testdata` folder, backtesting will download them 
 automatically. Testdata files will not be updated until you specify it.
 
-The result of backtesting will confirm you if your bot as more chance to
-make a profit than a loss.
-
+The result of backtesting will confirm you if your bot has better odds of making a profit than a loss.
 
 The backtesting is very easy with freqtrade.
 
 ### Run a backtesting against the currencies listed in your config file
-**With 5 min tickers (Per default)**
+#### With 5 min tickers (Per default)
+
 ```bash
-python3 ./freqtrade/main.py backtesting --realistic-simulation
+python3 ./freqtrade/main.py backtesting
 ```
 
-**With 1 min tickers**
+#### With 1 min tickers
+
 ```bash
-python3 ./freqtrade/main.py backtesting --realistic-simulation --ticker-interval 1
+python3 ./freqtrade/main.py backtesting --ticker-interval 1m
 ```
 
-**Reload your testdata files**
+#### Update cached pairs with the latest data
+
 ```bash
-python3 ./freqtrade/main.py backtesting --realistic-simulation --refresh-pairs-cached
+python3 ./freqtrade/main.py backtesting --refresh-pairs-cached
 ```
 
-**With live data (do not alter your testdata files)**
+#### With live data (do not alter your testdata files)
+
 ```bash
-python3 ./freqtrade/main.py backtesting --realistic-simulation --live
+python3 ./freqtrade/main.py backtesting --live
 ```
 
-**Using a different on-disk ticker-data source**
+#### Using a different on-disk ticker-data source
+
 ```bash
 python3 ./freqtrade/main.py backtesting --datadir freqtrade/tests/testdata-20180101
 ```
 
-**With a (custom) strategy file**
-```bash
-python3 ./freqtrade/main.py -s currentstrategy backtesting
-```
-Where `-s currentstrategy` refers to a filename `currentstrategy.py` in `freqtrade/user_data/strategies`
+#### With a (custom) strategy file
+
+```bash
+python3 ./freqtrade/main.py -s TestStrategy backtesting
+```
+
+Where `-s TestStrategy` refers to the class name within the strategy file `test_strategy.py` found in the `freqtrade/user_data/strategies` directory
+
+#### Exporting trades to file
 
-**Exporting trades to file**
 ```bash
 python3 ./freqtrade/main.py backtesting --export trades
 ```
 
-**Running backtest with smaller testset**  
+The exported trades can be read using the following code for manual analysis, or can be used by the plotting script `plot_dataframe.py` in the scripts folder.
+
+``` python
+import json
+from pathlib import Path
+import pandas as pd
+
+filename=Path('user_data/backtest_data/backtest-result.json')
+
+with filename.open() as file:
+        data = json.load(file)
+
+columns = ["pair", "profit", "opents", "closets", "index", "duration",
+           "open_rate", "close_rate", "open_at_end", "sell_reason"]
+df = pd.DataFrame(data, columns=columns)
+
+df['opents'] = pd.to_datetime(df['opents'],
+                              unit='s',
+                              utc=True,
+                              infer_datetime_format=True
+                             )
+df['closets'] = pd.to_datetime(df['closets'],
+                               unit='s',
+                               utc=True,
+                               infer_datetime_format=True
+                              )
+```
+
+If you have some ideas for interesting / helpful backtest data analysis, feel free to submit a PR so the community can benefit from it.
+
+#### Exporting trades to file specifying a custom filename
+
+```bash
+python3 ./freqtrade/main.py backtesting --export trades --export-filename=backtest_teststrategy.json
+```
+
+#### Running backtest with smaller 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 backtesting --timerange=-200
 ```
 
-***Advanced use of timerange***  
+#### Advanced use of timerange
+
 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`
 
+#### Downloading new set of ticker data
 
-Incoming feature, not implemented yet:
-- `--timerange=-20180131`
--  `--timerange=20180101-`
-- `--timerange=20180101-20181231`
+To download new set of backtesting ticker data, you can use a download script.
 
+If you are using Binance for example:
 
-**Update testdata directory**
-To update your testdata directory, or download into another testdata directory:
-```bash
-mkdir -p user_data/data/testdata-20180113
-cp freqtrade/tests/testdata/pairs.json user_data/data-20180113
-cd user_data/data-20180113
-```
-
-Possibly edit pairs.json file to include/exclude pairs
+- create a folder `user_data/data/binance` and copy `pairs.json` in that folder.
+- update the `pairs.json` to contain the currency pairs you are interested in.
 
 ```bash
-python3 freqtrade/tests/testdata/download_backtest_data.py -p pairs.json
+mkdir -p user_data/data/binance
+cp freqtrade/tests/testdata/pairs.json user_data/data/binance
 ```
 
-The script will read your pairs.json file, and download ticker data
-into the current working directory.
+Then run:
 
+```bash
+python scripts/download_backtest_data.py --exchange binance
+```
 
-For help about backtesting usage, please refer to 
-[Backtesting commands](#backtesting-commands).
+This will download ticker data for all the currency pairs you defined in `pairs.json`.
+
+- To use a different folder than the exchange specific default, use `--export user_data/data/some_directory`.
+- To change the exchange used to download the tickers, use `--exchange`. Default is `bittrex`.
+- To use `pairs.json` from some other folder, use `--pairs-file some_other_dir/pairs.json`.
+- To download ticker data for only 10 days, use `--days 10`.
+- Use `--timeframes` to specify which tickers to download. Default is `--timeframes 1m 5m` which will download 1-minute and 5-minute tickers.
+
+For help about backtesting usage, please refer to [Backtesting commands](#backtesting-commands).
 
 ## Understand the backtesting result
+
 The most important in the backtesting is to understand the result.
 
 A backtesting result will look like that:
+
 ```
-====================== BACKTESTING REPORT ================================
-pair        buy count    avg profit %    total profit BTC    avg duration
---------  -----------  --------------  ------------------  --------------
-BTC_ETH            56           -0.67         -0.00075455            62.3
-BTC_LTC            38           -0.48         -0.00036315            57.9
-BTC_ETC            42           -1.15         -0.00096469            67.0
-BTC_DASH           72           -0.62         -0.00089368            39.9
-BTC_ZEC            45           -0.46         -0.00041387            63.2
-BTC_XLM            24           -0.88         -0.00041846            47.7
-BTC_NXT            24            0.68          0.00031833            40.2
-BTC_POWR           35            0.98          0.00064887            45.3
-BTC_ADA            43           -0.39         -0.00032292            55.0
-BTC_XMR            40           -0.40         -0.00032181            47.4
-TOTAL             419           -0.41         -0.00348593            52.9
+======================================== 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 |
+
 ```
 
+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.
+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
 ```
@@ -147,6 +226,7 @@ strategy, your sell strategy, and also by the `minimal_roi` and
 As for an example if your minimal_roi is only `"0":  0.01`. You cannot
 expect the bot to make more profit than 1% (because it will sell every 
 time a trade will reach 1%).
+
 ```json
 "minimal_roi": {
     "0":  0.01
@@ -158,7 +238,33 @@ On the other hand, if you set a too high `minimal_roi` like `"0":  0.55`
 profit. Hence, keep in mind that your performance is a mix of your 
 strategies, your configuration, and the crypto-currency you have set up.
 
+## Backtesting multiple strategies
+
+To backtest multiple strategies, a list of Strategies can be provided.
+
+This is limited to 1 ticker-interval per run, however, data is only loaded once from disk so if you have multiple 
+strategies you'd like to compare, this should give a nice runtime boost.
+
+All listed Strategies need to be in the same folder.
+
+``` bash
+freqtrade backtesting --timerange 20180401-20180410 --ticker-interval 5m --strategy-list Strategy001 Strategy002 --export trades 
+```
+
+This will save the results to `user_data/backtest_data/backtest-result-<strategy>.json`, injecting the strategy-name into the target filename.
+There will be an additional table comparing win/losses of the different strategies (identical to the "Total" row in the first table).
+Detailed output for all strategies one after the other will be available, so make sure to scroll up.
+
+```
+=================================================== Strategy Summary ====================================================
+| Strategy   |   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 |
+```
+
 ## 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/gcarq/freqtrade/blob/develop/docs/hyperopt.md)
+Your next step is to learn [how to find optimal parameters with Hyperopt](https://github.com/freqtrade/freqtrade/blob/develop/docs/hyperopt.md)

docs/bot-optimization.md

@@ -1,8 +1,10 @@
 # Bot 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)
@@ -11,10 +13,12 @@ indicators.
 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
 `user_data/strategies`.
 
 Let assume you have a class called `AwesomeStrategy` in the file `awesome-strategy.py`:
+
 1. Move your file into `user_data/strategies` (you should have `user_data/strategies/awesome-strategy.py`
 2. Start the bot with the param `--strategy AwesomeStrategy` (the parameter is the class name)
 
@@ -23,51 +27,55 @@ python3 ./freqtrade/main.py --strategy AwesomeStrategy
 ```
 
 ## Change your strategy
+
 The bot includes a default strategy file. However, we recommend you to
 use your own file to not have to lose your parameters every time the default
 strategy file will be updated on Github. Put your custom strategy file
 into the folder `user_data/strategies`.
 
 A strategy file contains all the information needed to build a good strategy:
+
 - Buy strategy rules
 - Sell strategy rules
 - Minimal ROI recommended
 - Stoploss recommended
-- Hyperopt parameter
 
 The bot also include a sample strategy called `TestStrategy` you can update: `user_data/strategies/test_strategy.py`.
 You can test it with the parameter: `--strategy TestStrategy`
 
-```bash
+``` bash
 python3 ./freqtrade/main.py --strategy AwesomeStrategy
 ```
 
 ### 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
 ```
 
-**For the following section we will use the [user_data/strategies/test_strategy.py](https://github.com/gcarq/freqtrade/blob/develop/user_data/strategies/test_strategy.py)
+**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
-Edit the method `populate_buy_trend()` into your strategy file to 
-update your buy strategy.
+
+Edit the method `populate_buy_trend()` into your strategy file to update your buy strategy.
 
 Sample from `user_data/strategies/test_strategy.py`:
+
 ```python
-def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
+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
+    :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['blower']) &
+            (dataframe['tema'] <= dataframe['bb_middleband']) &
             (dataframe['tema'] > dataframe['tema'].shift(1))
         ),
         'buy'] = 1
@@ -76,37 +84,49 @@ def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
 ```
 
 ### Sell strategy
-Edit the method `populate_sell_trend()` into your strategy file to 
-update your 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) -> DataFrame:
+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
+    :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['blower']) &
+            (dataframe['tema'] > dataframe['bb_middleband']) &
             (dataframe['tema'] < dataframe['tema'].shift(1))
         ),
         'sell'] = 1
     return dataframe
 ```
 
-## Add more Indicator
-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.
+## 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.
+
+You should only add the indicators used in either `populate_buy_trend()`, `populate_sell_trend()`, or to populate another indicator, otherwise performance may suffer.
 
 Sample:
+
 ```python
-def populate_indicators(dataframe: DataFrame) -> DataFrame:
+def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
     """
     Adds several different TA indicators to the given DataFrame
+
+    Performance Note: For the best performance be frugal on the number of indicators
+    you are using. Let uncomment only the indicator you are using in your strategies
+    or your hyperopt configuration, otherwise you will waste your memory and CPU usage.
+    :param dataframe: Raw data from the exchange and parsed by parse_ticker_dataframe()
+    :param metadata: Additional information, like the currently traded pair
+    :return: a Dataframe with all mandatory indicators for the strategies
     """
     dataframe['sar'] = ta.SAR(dataframe)
     dataframe['adx'] = ta.ADX(dataframe)
@@ -137,16 +157,30 @@ def populate_indicators(dataframe: DataFrame) -> DataFrame:
     return dataframe
 ```
 
-**Want more indicators example?**  
-Look into the [user_data/strategies/test_strategy.py](https://github.com/gcarq/freqtrade/blob/develop/user_data/strategies/test_strategy.py).  
+### 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
+
+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.
 
-
 ### Where is the default strategy?
-The default buy strategy is located in the file 
-[freqtrade/default_strategy.py](https://github.com/gcarq/freqtrade/blob/develop/freqtrade/strategy/default_strategy.py). 
 
+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).
+
+### 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.
+Feel free to use any of them as inspiration for your own strategies.
+We're happy to accept Pull Requests containing new Strategies to that repo.
+
+We also got a *strategy-sharing* channel in our [Slack community](https://join.slack.com/t/highfrequencybot/shared_invite/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE) which is a great place to get and/or share ideas.
 
 ## Next step
-Now you have a perfect strategy you probably want to backtesting it. 
-Your next step is to learn [How to use the Backtesting](https://github.com/gcarq/freqtrade/blob/develop/docs/backtesting.md).
+
+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).

docs/bot-usage.md

@@ -1,16 +1,19 @@
 # Bot usage
-This page explains the difference parameters of the bot and how to run 
-it.
+
+This page explains the difference 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: main.py [-h] [-c PATH] [-v] [--version] [--dynamic-whitelist [INT]]
-               [--dry-run-db]
+usage: freqtrade [-h] [-v] [--version] [-c PATH] [-d PATH] [-s NAME]
+                 [--strategy-path PATH] [--dynamic-whitelist [INT]]
+                 [--db-url PATH]
                  {backtesting,hyperopt} ...
 
 Simple High Frequency Trading Bot for crypto currencies
@@ -26,20 +29,21 @@ optional arguments:
   --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
   -s NAME, --strategy NAME
                         specify strategy class name (default: DefaultStrategy)
   --strategy-path PATH  specify additional strategy lookup path
-  --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.
-  --datadir PATH
-                        path to backtest data (default freqdata/tests/testdata
   --dynamic-whitelist [INT]
                         dynamically generate and update whitelist based on 24h
-                        BaseVolume (Default 20 currencies)
+                        BaseVolume (default: 20)
+  --db-url PATH         Override trades database URL, this is useful if
+                        dry_run is enabled or in custom deployments (default:
+                        sqlite:///tradesv3.sqlite)
 ```
 
 ### How to use a different config file?
+
 The bot allows you to select which config file you want to use. Per 
 default, the bot will load the file `./config.json`
 
@@ -48,6 +52,7 @@ python3 ./freqtrade/main.py -c path/far/far/away/config.json
 ```
 
 ### 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
 `DefaultStrategy` included with the bot (`freqtrade/strategy/default_strategy.py`).
@@ -59,6 +64,7 @@ To load a strategy, simply pass the class name (e.g.: `CustomStrategy`) in this
 **Example:**  
 In `user_data/strategies` you have a file `my_awesome_strategy.py` which has
 a strategy class called `AwesomeStrategy` to load it:
+
 ```bash
 python3 ./freqtrade/main.py --strategy AwesomeStrategy
 ```
@@ -66,9 +72,10 @@ python3 ./freqtrade/main.py --strategy AwesomeStrategy
 If the bot does not find your strategy file, it will display in an error 
 message the reason (File not found, or errors in your code).
 
-Learn more about strategy file in [optimize your bot](https://github.com/gcarq/freqtrade/blob/develop/docs/bot-optimization.md).
+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?
+
 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!):
 ```bash
@@ -76,21 +83,25 @@ python3 ./freqtrade/main.py --strategy AwesomeStrategy --strategy-path /some/fol
 ```
 
 #### How to install a strategy?
+
 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?
+
 Per default `--dynamic-whitelist` will retrieve the 20 currencies based 
 on BaseVolume. This value can be changed when you run the script.
 
 **By Default**  
 Get the 20 currencies based on BaseVolume.  
+
 ```bash
 python3 ./freqtrade/main.py --dynamic-whitelist
 ```
 
 **Customize the number of currencies to retrieve**  
 Get the 30 currencies based on BaseVolume.  
+
 ```bash
 python3 ./freqtrade/main.py --dynamic-whitelist 30
 ```
@@ -100,40 +111,65 @@ python3 ./freqtrade/main.py --dynamic-whitelist 30
 negative value (e.g -2), `--dynamic-whitelist` will use the default
 value (20).
 
-### How to use --dry-run-db?
+### 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 
-using `--dry-run-db`. This command will use a separate database file 
-`tradesv3.dry_run.sqlite`
+using `--db-url`. This can also be used to specify a custom database
+in production mode. Example command:
 
 ```bash
-python3 ./freqtrade/main.py -c config.json --dry-run-db
+python3 ./freqtrade/main.py -c config.json --db-url sqlite:///tradesv3.dry_run.sqlite
 ```
 
-
 ## Backtesting commands
 
 Backtesting also uses the config specified via `-c/--config`.
 
 ```
-usage: freqtrade backtesting [-h] [-l] [-i INT] [--realistic-simulation]
-                             [-r]
+usage: freqtrade backtesting [-h] [-i TICKER_INTERVAL] [--eps] [--dmmp]
+                             [--timerange TIMERANGE] [-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)
+  --eps, --enable-position-stacking
+                        Allow buying the same pair multiple times (position
+                        stacking)
+  --dmmp, --disable-max-market-positions
+                        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
-  -i INT, --ticker-interval INT
-                        specify ticker interval in minutes (default: 5)
-  --realistic-simulation
-                        uses max_open_trades from config to simulate real
-                        world limitations
   -r, --refresh-pairs-cached
-                        refresh the pairs files in tests/testdata with 
-                        the latest data from Bittrex. Use it if you want
-                        to run your backtesting with up-to-date data.
+                        refresh the pairs files in tests/testdata with the
+                        latest data from the exchange. Use it if you want to
+                        run your backtesting with up-to-date data.
+  --strategy-list STRATEGY_LIST [STRATEGY_LIST ...]
+                        Provide a commaseparated list of strategies to
+                        backtest Please note that ticker-interval needs to be
+                        set either in config or via command line. When using
+                        this together with --export trades, the strategy-name
+                        is injected into the filename (so backtest-data.json
+                        becomes backtest-data-DefaultStrategy.json
+  --export EXPORT       export backtest results, argument are: trades Example
+                        --export=trades
+  --export-filename PATH
+                        Save backtest results to this filename requires
+                        --export to be set as well Example --export-
+                        filename=user_data/backtest_data/backtest_today.json
+                        (default: user_data/backtest_data/backtest-
+                        result.json)
+
 ```
 
 ### 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. 
 
@@ -145,29 +181,42 @@ to come back to the previous version.**
 To test your strategy with latest data, we recommend continuing using 
 the parameter `-l` or `--live`.
 
-
 ## Hyperopt commands
 
-It is possible to use hyperopt for trading strategy optimization.
-Hyperopt uses an internal json config return by `hyperopt_optimize_conf()` 
-located in `freqtrade/optimize/hyperopt_conf.py`.
+To optimize your strategy, you can use hyperopt parameter hyperoptimization
+to find optimal parameter values for your stategy.
 
 ```
-usage: freqtrade hyperopt [-h] [-e INT] [--use-mongodb]
+usage: freqtrade hyperopt [-h] [-i TICKER_INTERVAL] [--eps] [--dmmp]
+                          [--timerange TIMERANGE] [-e INT]
+                          [-s {all,buy,roi,stoploss} [{all,buy,roi,stoploss} ...]]
 
 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)
+  --eps, --enable-position-stacking
+                        Allow buying the same pair multiple times (position
+                        stacking)
+  --dmmp, --disable-max-market-positions
+                        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.
   -e INT, --epochs INT  specify number of epochs (default: 100)
-  --use-mongodb         parallelize evaluations with mongodb (requires mongod
-                        in PATH)
+  -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
+                        list. Default: all
 
 ```
 
 ## A parameter missing in the configuration?
+
 All parameters for `main.py`, `backtesting`, `hyperopt` are referenced
-in [misc.py](https://github.com/gcarq/freqtrade/blob/develop/freqtrade/misc.py#L84)
+in [misc.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/misc.py#L84)
 
 ## Next step
-The optimal strategy of the bot will change with time depending of the
-market trends. The next step is to 
-[optimize your bot](https://github.com/gcarq/freqtrade/blob/develop/docs/bot-optimization.md).
+
+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).

docs/configuration.md

@@ -1,12 +1,15 @@
 # Configure the bot
+
 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
 for your bot configuration.
 
@@ -16,36 +19,56 @@ The table below will list all configuration parameters.
 |----------|---------|----------|-------------|
 | `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.
-| `ticker_interval` | [1, 5, 30, 60, 1440] | No | The ticker interval to use (1min, 5 min, 30 min, 1 hour or 1 day). Defaut is 5 minutes
+| `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. 
 | `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. 
-| `unfilledtimeout` | 0 | No | How long (in minutes) the bot will wait for an unfilled order to complete, after which the order will be cancelled.
+| `trailing_stoploss` | false | No | Enables trailing stop-loss (based on `stoploss` in either configuration or strategy file).
+| `trailing_stoploss_positve` | 0 | No | Changes stop-loss once profit has been reached.
+| `trailing_stoploss_positve_offset` | 0 | No | Offset on when to apply `trailing_stoploss_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.
-| `exchange.name` | bittrex | Yes | Name of the exchange class to use.
+| `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.
 | `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.
 
-The definition of each config parameters is in 
-[misc.py](https://github.com/gcarq/freqtrade/blob/develop/freqtrade/misc.py#L205).
+The definition of each config parameters is in [misc.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/misc.py#L205).
+
+### 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)`.
 
 ### Understand minimal_roi
+
 `minimal_roi` is a JSON object where the key is a duration
 in minutes and the value is the minimum ROI in percent.
 See the example below:
+
 ```
 "minimal_roi": {
     "40": 0.0,    # Sell after 40 minutes if the profit is not negative
@@ -60,6 +83,7 @@ value. This parameter is optional. If you use it, it will take over the
 `minimal_roi` value from the strategy file.
 
 ### Understand stoploss
+
 `stoploss` is loss in percentage that should trigger a sale.
 For example value `-0.10` will cause immediate sell if the
 profit dips below -10% for a given trade. This parameter is optional.
@@ -68,35 +92,70 @@ Most of the strategy files already include the optimal `stoploss`
 value. This parameter is optional. If you use it, it will take over the
 `stoploss` value from the strategy file.
 
+### Understand trailing stoploss
+
+Go to the [trailing stoploss Documentation](stoploss.md) for details on trailing stoploss.
+
 ### Understand initial_state
+
 `initial_state` is an optional field that defines the initial application state.
 Possible values are `running` or `stopped`. (default=`running`)
 If the value is `stopped` the bot has to be started with `/start` first.
 
+### Understand process_throttle_secs
+
+`process_throttle_secs` is an optional field that defines in seconds how long the bot should wait
+before asking the strategy if we should buy or a sell an asset. After each wait period, the strategy is asked again for
+every opened trade wether or not we should sell, and for all the remaining pairs (either the dynamic list of pairs or
+the static list of pairs) if we should buy.
+
 ### Understand ask_last_balance
+
 `ask_last_balance` sets the bidding price. Value `0.0` will use `ask` price, `1.0` will
 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.
 
+### What values for exchange.name?
+
+Freqtrade is based on [CCXT library](https://github.com/ccxt/ccxt) that supports 115 cryptocurrency
+exchange markets and trading APIs. The complete up-to-date list can be found in the
+[CCXT repo homepage](https://github.com/ccxt/ccxt/tree/master/python). However, the bot was tested
+with only Bittrex and Binance.
+
+The bot was tested with the following exchanges:
+
+- [Bittrex](https://bittrex.com/): "bittrex"
+- [Binance](https://www.binance.com/): "binance"
+
+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 fiat to use for the conversion form coin to fiat in Telegram. 
-The valid value 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".
+
+`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".
 
 ## Switch to dry-run mode
+
 We recommend starting the bot in dry-run mode to see how your bot will
 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
+2. Switch dry-run to true and specify db_url for a persistent db
+
 ```json
 "dry_run": true,
+"db_url": "sqlite///tradesv3.dryrun.sqlite",
 ```
 
-3. Remove your Bittrex API key (change them by fake api credentials)
+3. Remove your Exchange API key (change them by fake api credentials)
+
 ```json
 "exchange": {
         "name": "bittrex",
@@ -110,19 +169,23 @@ Once you will be happy with your bot performance, you can switch it to
 production mode.
 
 ## 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:
+
 1. Edit your `config.json`  file
 
-2. Switch dry-run to false
+2. Switch dry-run to false and don't forget to adapt your database URL if set
+
 ```json
 "dry_run": false,
 ```
 
-3. Insert your Bittrex API key (change them by fake api keys)
+3. Insert your Exchange API key (change them by fake api keys)
+
 ```json
 "exchange": {
         "name": "bittrex",
@@ -130,11 +193,37 @@ you run it in production mode.
         "secret": "08a9dc6db3d7b53e1acebd9275677f4b0a04f1a5",
         ...
 }
-```
-If you have not your Bittrex API key yet, 
-[see our tutorial](https://github.com/gcarq/freqtrade/blob/develop/docs/pre-requisite.md).
 
+```
+If you have not your Bittrex API key yet, [see our tutorial](https://github.com/freqtrade/freqtrade/blob/develop/docs/pre-requisite.md).
+
+
+### Embedding Strategies
+
+FreqTrade provides you with with an easy way to embed the strategy into your configuration file. 
+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
+
+This is a quick example, how to generate the BASE64 string in python
+
+```python
+from base64 import urlsafe_b64encode
+
+with open(file, 'r') as f:
+    content = f.read()
+content = urlsafe_b64encode(content.encode('utf-8'))
+```
+
+The variable 'content', will contain the strategy file in a BASE64 encoded form. Which can now be set in your configurations file as following
+
+```json
+"strategy": "NameOfStrategy:BASE64String"
+```
+
+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/gcarq/freqtrade/blob/develop/docs/bot-usage.md).
+
+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).

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/gcarq/freqtrade/blob/develop/docs/bot-usage.md#hyperopt-commands).
+the tutorial [here|Testing-new-strategies-with-Hyperopt](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md#hyperopt-commands).
 
 #### Is there a setting to only SELL the coins being held and not 
 perform anymore BUYS?

docs/hyperopt.md

@@ -1,156 +1,114 @@
 # Hyperopt
 This page explains how to tune your strategy by finding the optimal 
-parameters with Hyperopt.
+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.
 
 ## Table of Contents
 - [Prepare your Hyperopt](#prepare-hyperopt)
-    - [1. Configure your Guards and Triggers](#1-configure-your-guards-and-triggers)
-    - [2. Update the hyperopt config file](#2-update-the-hyperopt-config-file)
-- [Advanced Hyperopt notions](#advanced-notions)
-    - [Understand the Guards and Triggers](#understand-the-guards-and-triggers)
+- [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)
-    - [Hyperopt with MongoDB](#hyperopt-with-mongoDB)
 - [Understand the hyperopts result](#understand-the-backtesting-result)
 
-## Prepare Hyperopt
-Before we start digging in Hyperopt, we recommend you to take a look at 
-your strategy file located into [user_data/strategies/](https://github.com/gcarq/freqtrade/blob/develop/user_data/strategies/test_strategy.py)
+## 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)
  
-### 1. Configure your Guards and Triggers
-There are two places you need to change in your strategy file to add a 
-new buy strategy for testing:
-- Inside [populate_buy_trend()](https://github.com/gcarq/freqtrade/blob/develop/user_data/strategies/test_strategy.py#L278-L294).
-- Inside [hyperopt_space()](https://github.com/gcarq/freqtrade/blob/develop/user_data/strategies/test_strategy.py#L244-L297) known as `SPACE`.
+### 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`.
 
-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.
+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.
+"buy when EMA5 crosses over EMA10" or "buy when close price touches lower 
+bollinger band".
 
-HyperOpt will, for each eval round, pick just ONE trigger, and possibly 
-multiple guards. So that the constructed strategy will be something like 
+Hyperoptimization will, for each eval round, pick one trigger and possibly 
+multiple guards. The constructed strategy will be something like 
 "*buy exactly when close price touches lower bollinger band, BUT only if 
 ADX > 10*".
 
-
-If you have updated the buy strategy, means change the content of
+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 used.
+`triggers` hyperopts must use.
+
+## Solving a Mystery
+
+Let's say you are curious: should you use MACD crossings or lower Bollinger 
+Bands to trigger your buys. And you also wonder should you use RSI or ADX to 
+help with those buy decisions. If you decide to use RSI or ADX, which values 
+should I use for them? So let's use hyperparameter optimization to solve this 
+mystery.
+
+We will start by defining a search space:
+
+```
+    def indicator_space() -> List[Dimension]:
+        """
+        Define your Hyperopt space for searching strategy parameters
+        """
+        return [
+            Integer(20, 40, name='adx-value'),
+            Integer(20, 40, name='rsi-value'),
+            Categorical([True, False], name='adx-enabled'),
+            Categorical([True, False], name='rsi-enabled'),
+            Categorical(['bb_lower', 'macd_cross_signal'], name='trigger')
+        ]
+```
+
+Above definition says: I have five parameters I want you to randomly combine 
+to find the best combination. Two of them are integer values (`adx-value` 
+and `rsi-value`) and I want you test in the range of values 20 to 40.
+Then we have three category variables. First two are either `True` or `False`.
+We use these to either enable or disable the ADX and RSI guards. The last
+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:
+
+```
+        def populate_buy_trend(dataframe: DataFrame) -> DataFrame:
+            conditions = []
+            # GUARDS AND TRENDS
+            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']
+                ))
 
-As for an example if your `populate_buy_trend()` method is:
-```python
-def populate_buy_trend(dataframe: DataFrame) -> DataFrame:
             dataframe.loc[
-        (dataframe['rsi'] < 35) &
-        (dataframe['adx'] > 65),
+                reduce(lambda x, y: x & y, conditions),
                 'buy'] = 1
 
             return dataframe
+
+        return populate_buy_trend
 ```
 
-Your hyperopt file must contain `guards` to find the right value for 
-`(dataframe['adx'] > 65)` & and `(dataframe['plus_di'] > 0.5)`. That 
-means you will need to enable/disable triggers.
+Hyperopting will now call this `populate_buy_trend` as many times you ask it (`epochs`)
+with different value combinations. It will then use the given historical data and make
+buys based on the buy signals generated with the above function and based on the results
+it will end with telling you which paramter combination produced the best profits.
 
-In our case the `SPACE` and `populate_buy_trend` in your strategy file 
-will look like:
-```python
-space = {
-    'rsi': hp.choice('rsi', [
-        {'enabled': False},
-        {'enabled': True, 'value': hp.quniform('rsi-value', 20, 40, 1)}
-    ]),
-    'adx': hp.choice('adx', [
-        {'enabled': False},
-        {'enabled': True, 'value': hp.quniform('adx-value', 15, 50, 1)}
-    ]),
-    'trigger': hp.choice('trigger', [
-        {'type': 'lower_bb'},
-        {'type': 'faststoch10'},
-        {'type': 'ao_cross_zero'},
-        {'type': 'ema5_cross_ema10'},
-        {'type': 'macd_cross_signal'},
-        {'type': 'sar_reversal'},
-        {'type': 'stochf_cross'},
-        {'type': 'ht_sine'},
-    ]),
-}
+The search for best parameters starts with a few random combinations and then uses a 
+regressor algorithm (currently ExtraTreesRegressor) to quickly find a parameter combination
+that minimizes the value of the objective function `calculate_loss` in `hyperopt.py`.
 
-... 
-
-def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
-        conditions = []
-        # GUARDS AND TRENDS
-        if params['adx']['enabled']:
-            conditions.append(dataframe['adx'] > params['adx']['value'])
-        if params['rsi']['enabled']:
-            conditions.append(dataframe['rsi'] < params['rsi']['value'])
-
-        # TRIGGERS
-        triggers = {
-            'lower_bb': dataframe['tema'] <= dataframe['blower'],
-            'faststoch10': (crossed_above(dataframe['fastd'], 10.0)),
-            'ao_cross_zero': (crossed_above(dataframe['ao'], 0.0)),
-            'ema5_cross_ema10': (crossed_above(dataframe['ema5'], dataframe['ema10'])),
-            'macd_cross_signal': (crossed_above(dataframe['macd'], dataframe['macdsignal'])),
-            'sar_reversal': (crossed_above(dataframe['close'], dataframe['sar'])),
-            'stochf_cross': (crossed_above(dataframe['fastk'], dataframe['fastd'])),
-            'ht_sine': (crossed_above(dataframe['htleadsine'], dataframe['htsine'])),
-        }
-        ...
-```
-
-
-### 2. Update the hyperopt config file
-Hyperopt is using a dedicated config file. Currently hyperopt 
-cannot use your config file. It is also made on purpose to allow you
-testing your strategy with different configurations.
-
-The Hyperopt configuration is located in 
-[user_data/hyperopt_conf.py](https://github.com/gcarq/freqtrade/blob/develop/user_data/hyperopt_conf.py).
-
-
-## Advanced notions
-### Understand the Guards and Triggers
-When you need to add the new guards and triggers to be hyperopt 
-parameters, you do this by adding them into the [hyperopt_space()](https://github.com/gcarq/freqtrade/blob/develop/user_data/strategies/test_strategy.py#L244-L297).
-
-If it's a trigger, you add one line to the 'trigger' choice group and that's it.
-
-If it's a guard, you will add a line like this:
-```
-'rsi': hp.choice('rsi', [
-    {'enabled': False},
-    {'enabled': True, 'value': hp.quniform('rsi-value', 20, 40, 1)}
-]),
-```
-This says, "*one of the guards is RSI, it can have two values, enabled or 
-disabled. If it is enabled, try different values for it between 20 and 40*".
-
-So, the part of the strategy builder using the above setting looks like 
-this:
-
-```
-if params['rsi']['enabled']:
-    conditions.append(dataframe['rsi'] < params['rsi']['value'])
-```
-
-It checks if Hyperopt wants the RSI guard to be enabled for this 
-round `params['rsi']['enabled']` and if it is, then it will add a 
-condition that says RSI must be smaller than the value hyperopt picked 
-for this evaluation, which is given in the `params['rsi']['value']`.
-
-That's it. Now you can add new parts of strategies to Hyperopt and it 
-will try all the combinations with all different values in the search 
-for best working algo.
-
-
-### Add a new Indicators
-If you want to test an indicator that isn't used by the bot currently, 
-you need to add it to the `populate_indicators()` method in `hyperopt.py`.
+The above setup expects to find ADX, RSI and Bollinger Bands in the populated indicators.
+When you want to test an indicator that isn't used by the bot currently, remember to 
+add it to the `populate_indicators()` method in `hyperopt.py`.
 
 ## Execute Hyperopt
 Once you have updated your hyperopt configuration you can run it. 
@@ -165,12 +123,12 @@ python3 ./freqtrade/main.py -c config.json hyperopt -e 5000
 The `-e` flag will set how many evaluations hyperopt will do. We recommend
 running at least several thousand evaluations.
 
-### Execute hyperopt with different ticker-data source
+### 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
+### Running Hyperopt with Smaller Testset
 Use the `--timeperiod` argument to change how much of the testset
 you want to use. The last N ticks/timeframes will be used.
 Example:
@@ -179,7 +137,7 @@ Example:
 python3 ./freqtrade/main.py hyperopt --timeperiod -200
 ```
 
-### Running hyperopt with smaller search space
+### 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. 
@@ -194,122 +152,44 @@ Legal values are:
 - `stoploss`: search for the best stoploss value
 - space-separated list of any of the above values for example `--spaces roi stoploss`
 
-### Hyperopt with MongoDB
-Hyperopt with MongoDB, is like Hyperopt under steroids. As you saw by
-executing the previous command is the execution takes a long time. 
-To accelerate it you can use hyperopt with MongoDB.
+## Understand the Hyperopts Result 
+Once Hyperopt is completed you can use the result to create a new strategy.
+Given the following result from hyperopt:
 
-To run hyperopt with MongoDb you will need 3 terminals.
-
-**Terminal 1: Start MongoDB**
-```bash
-cd <freqtrade> 
-source .env/bin/activate
-python3 scripts/start-mongodb.py
 ```
-
-**Terminal 2: Start Hyperopt worker**
-```bash
-cd <freqtrade> 
-source .env/bin/activate
-python3 scripts/start-hyperopt-worker.py
-```
-
-**Terminal 3: Start Hyperopt with MongoDB**
-```bash
-cd <freqtrade> 
-source .env/bin/activate
-python3 ./freqtrade/main.py -c config.json hyperopt --use-mongodb
-```
-
-**Re-run an Hyperopt**
-To re-run Hyperopt you have to delete the existing MongoDB table.
-```bash
-cd <freqtrade> 
-rm -rf .hyperopt/mongodb/
-```
-
-## Understand the hyperopts result 
-Once Hyperopt is completed you can use the result to adding new buy 
-signal. Given following result from hyperopt:
-```
-Best parameters:
-{
-    "adx": {
-        "enabled": true,
-        "value": 15.0
-    },
-    "fastd": {
-        "enabled": true,
-        "value": 40.0
-    },
-    "green_candle": {
-        "enabled": true
-    },
-    "mfi": {
-        "enabled": false
-    },
-    "over_sar": {
-        "enabled": false
-    },
-    "rsi": {
-        "enabled": true,
-        "value": 37.0
-    },
-    "trigger": {
-        "type": "lower_bb"
-    },
-    "uptrend_long_ema": {
-        "enabled": true
-    },
-    "uptrend_short_ema": {
-        "enabled": false
-    },
-    "uptrend_sma": {
-        "enabled": false
-    }
-}
-
-Best Result:
-  2197 trades. Avg profit  1.84%. Total profit  0.79367541 BTC. Avg duration 241.0 mins.
+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'}
 ```
 
 You should understand this result like:
-- You should **consider** the guard "adx" (`"adx"` is `"enabled": true`) 
-and the best value is `15.0` (`"value": 15.0,`)
-- You should **consider** the guard "fastd" (`"fastd"` is `"enabled": 
-true`) and the best value is `40.0` (`"value": 40.0,`)
-- You should **consider** to enable the guard "green_candle" 
-(`"green_candle"` is `"enabled": true`) but this guards as no 
-customizable value.
-- You should **ignore** the guard "mfi" (`"mfi"` is `"enabled": false`)
-- and so on...
+- 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`)
 
 You have to look inside your strategy file into `buy_strategy_generator()` 
 method, what those values match to.   
   
-So for example you had `adx:` with the `value: 15.0` so we would look 
-at `adx`-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['adx'] > 15.0)
+(dataframe['rsi'] < 29.0)
 ```
   
-Translating your whole hyperopt result to as the new buy-signal 
-would be the following:
+Translating your whole hyperopt result as the new buy-signal 
+would then look like:
 ```
 def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
     dataframe.loc[
         (
-            (dataframe['adx'] > 15.0) & # adx-value
-            (dataframe['fastd'] < 40.0) & # fastd-value
-            (dataframe['close'] > dataframe['open']) & # green_candle
-            (dataframe['rsi'] < 37.0) & # rsi-value
-            (dataframe['ema50'] > dataframe['ema100']) # uptrend_long_ema
+            (dataframe['rsi'] < 29.0) &  # rsi-value
+            dataframe['close'] < dataframe['bb_lowerband']  # trigger
         ),
         'buy'] = 1
     return dataframe
 ```
 
-## Next step
+## 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/gcarq/freqtrade/blob/develop/docs/telegram-usage.md).
+next step is to learn the [Telegram usage](https://github.com/freqtrade/freqtrade/blob/develop/docs/telegram-usage.md).

docs/index.md

@@ -1,4 +1,5 @@
 # freqtrade documentation
+
 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 
@@ -6,27 +7,30 @@ Pull-request. Do not hesitate to reach us on
  if you do not find the answer to your questions.
 
 ## Table of Contents
-- [Pre-requisite](https://github.com/gcarq/freqtrade/blob/develop/docs/pre-requisite.md)
-	- [Setup your Bittrex account](https://github.com/gcarq/freqtrade/blob/develop/docs/pre-requisite.md#setup-your-bittrex-account)
-	- [Setup your Telegram bot](https://github.com/gcarq/freqtrade/blob/develop/docs/pre-requisite.md#setup-your-telegram-bot)
-- [Bot Installation](https://github.com/gcarq/freqtrade/blob/develop/docs/installation.md)
-    - [Install with Docker (all platforms)](https://github.com/gcarq/freqtrade/blob/develop/docs/installation.md#docker)
-    - [Install on Linux Ubuntu](https://github.com/gcarq/freqtrade/blob/develop/docs/installation.md#21-linux---ubuntu-1604)
-    - [Install on MacOS](https://github.com/gcarq/freqtrade/blob/develop/docs/installation.md#23-macos-installation)
-    - [Install on Windows](https://github.com/gcarq/freqtrade/blob/develop/docs/installation.md#windows)
-- [Bot Configuration](https://github.com/gcarq/freqtrade/blob/develop/docs/configuration.md)
-- [Bot usage (Start your bot)](https://github.com/gcarq/freqtrade/blob/develop/docs/bot-usage.md)
-    - [Bot commands](https://github.com/gcarq/freqtrade/blob/develop/docs/bot-usage.md#bot-commands)
-    - [Backtesting commands](https://github.com/gcarq/freqtrade/blob/develop/docs/bot-usage.md#backtesting-commands)
-    - [Hyperopt commands](https://github.com/gcarq/freqtrade/blob/develop/docs/bot-usage.md#hyperopt-commands)
-- [Bot Optimization](https://github.com/gcarq/freqtrade/blob/develop/docs/bot-optimization.md)
-	- [Change your strategy](https://github.com/gcarq/freqtrade/blob/develop/docs/bot-optimization.md#change-your-strategy)
-    - [Add more Indicator](https://github.com/gcarq/freqtrade/blob/develop/docs/bot-optimization.md#add-more-indicator)
-    - [Test your strategy with Backtesting](https://github.com/gcarq/freqtrade/blob/develop/docs/backtesting.md)
-    - [Find optimal parameters with Hyperopt](https://github.com/gcarq/freqtrade/blob/develop/docs/hyperopt.md)
-- [Control the bot with telegram](https://github.com/gcarq/freqtrade/blob/develop/docs/telegram-usage.md)
-- [Contribute to the project](https://github.com/gcarq/freqtrade/blob/develop/CONTRIBUTING.md)
-	- [How to contribute](https://github.com/gcarq/freqtrade/blob/develop/CONTRIBUTING.md)
-	- [Run tests & Check PEP8 compliance](https://github.com/gcarq/freqtrade/blob/develop/CONTRIBUTING.md)
-- [FAQ](https://github.com/gcarq/freqtrade/blob/develop/docs/faq.md)
-    - [SQL cheatsheet](https://github.com/gcarq/freqtrade/blob/develop/docs/sql_cheatsheet.md)
+
+- [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))

docs/installation.md

@@ -2,12 +2,13 @@
 
 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/gcarq/freqtrade/blob/develop/docs/configuration.md) page.
+To understand how to set up the bot please read the [Bot Configuration](https://github.com/freqtrade/freqtrade/blob/develop/docs/configuration.md) page.
 
 ## Table of Contents
 
 * [Table of Contents](#table-of-contents)
 * [Easy Installation - Linux Script](#easy-installation---linux-script)
+* [Manual installation](#manual-installation)
 * [Automatic Installation - Docker](#automatic-installation---docker)
 * [Custom Linux MacOS Installation](#custom-installation)
 	- [Requirements](#requirements)
@@ -16,7 +17,6 @@ To understand how to set up the bot please read the [Bot Configuration](https://
 	- [Setup Config and virtual env](#setup-config-and-virtual-env)
 * [Windows](#windows)
 
-
 <!-- /TOC -->
 
 ------
@@ -35,7 +35,9 @@ usage:
 ```
 
 ### --install
+
 This script will install everything you need to run the bot:
+
 * Mandatory software as: `Python3`, `ta-lib`, `wget`
 * Setup your virtualenv
 * Configure your `config.json` file
@@ -43,14 +45,45 @@ This script will install everything you need to run the bot:
 This script is a combination of `install script` `--reset`, `--config`
 
 ### --update
+
 Update parameter will pull the last version of your current branch and update your virtualenv.
 
 ### --reset
+
 Reset parameter will hard reset your branch (only if you are on `master` or `develop`) and recreate your virtualenv.
 
 ### --config
+
 Config parameter is a `config.json` configurator. This script will ask you questions to setup your bot and create your `config.json`.
 
+## Manual installation - Linux/MacOS
+
+The following steps are made for Linux/MacOS environment
+
+### 1. Clone the repo
+
+```bash
+git clone git@github.com:freqtrade/freqtrade.git
+git checkout develop
+cd freqtrade
+```
+
+### 2. Create the config file
+
+Switch `"dry_run": true,`
+
+```bash
+cp config.json.example config.json
+vi config.json
+```
+
+### 3. Build your docker image and run it
+
+```bash
+docker build -t freqtrade .
+docker run --rm -v /etc/localtime:/etc/localtime:ro -v `pwd`/config.json:/freqtrade/config.json -it freqtrade
+```
+
 ------
 
 ## Automatic Installation - Docker
@@ -63,13 +96,12 @@ Start by downloading Docker for your platform:
 
 Once you have Docker installed, simply create the config file (e.g. `config.json`) and then create a Docker image for `freqtrade` using the Dockerfile in this repo.
 
-
 ### 1. Prepare the Bot
 
 #### 1.1. Clone the git repository
 
 ```bash
-git clone https://github.com/gcarq/freqtrade.git
+git clone https://github.com/freqtrade/freqtrade.git
 ```
 
 #### 1.2. (Optional) Checkout the develop branch
@@ -90,21 +122,22 @@ cd freqtrade
 cp -n config.json.example config.json
 ```
 
-> To edit the config please refer to the [Bot Configuration](https://github.com/gcarq/freqtrade/blob/develop/docs/configuration.md) page.
+> To edit the config please refer to the [Bot Configuration](https://github.com/freqtrade/freqtrade/blob/develop/docs/configuration.md) page.
 
 #### 1.5. Create your database file *(optional - the bot will create it if it is missing)*
 
 Production
+
 ```bash
 touch tradesv3.sqlite
 ````
 
 Dry-Run
+
 ```bash
 touch tradesv3.dryrun.sqlite
 ```
 
-
 ### 2. Build the Docker image
 
 ```bash
@@ -114,7 +147,6 @@ docker build -t freqtrade .
 
 For security reasons, your configuration file will not be included in the image, you will need to bind mount it. It is also advised to bind mount an SQLite database file (see the "5. Run a restartable docker image" section) to keep it between  updates.
 
-
 ### 3. Verify the Docker image
 
 After the build process you can verify that the image was created with:
@@ -123,7 +155,6 @@ After the build process you can verify that the image was created with:
 docker images
 ```
 
-
 ### 4. Run the Docker image
 
 You can run a one-off container that is immediately deleted upon exiting with the following command (`config.json` must be in the current working directory):
@@ -132,8 +163,15 @@ You can run a one-off container that is immediately deleted upon exiting with th
 docker run --rm -v /etc/localtime:/etc/localtime:ro -v `pwd`/config.json:/freqtrade/config.json -it freqtrade
 ```
 
-In this example, the database will be created inside the docker instance and will be lost when you will refresh your image.
+There is known issue in OSX Docker versions after 17.09.1, whereby /etc/localtime cannot be shared causing Docker to not start. A work-around for this is to start with the following cmd.
 
+```bash
+docker run --rm -e TZ=`ls -la /etc/localtime | cut -d/ -f8-9` -v `pwd`/config.json:/freqtrade/config.json -it freqtrade
+```
+
+More information on this docker issue and work-around can be read [here](https://github.com/docker/for-mac/issues/2396)
+
+In this example, the database will be created inside the docker instance and will be lost when you will refresh your image.
 
 ### 5. Run a restartable docker image
 
@@ -155,10 +193,11 @@ docker run -d \
   -v /etc/localtime:/etc/localtime:ro \
   -v ~/.freqtrade/config.json:/freqtrade/config.json \
   -v ~/.freqtrade/tradesv3.sqlite:/freqtrade/tradesv3.sqlite \
-  freqtrade
+  freqtrade --db-url sqlite:///tradesv3.sqlite
 ```
 
-If you are using `dry_run=True` it's not necessary to mount `tradesv3.sqlite`, but you can mount `tradesv3.dryrun.sqlite` if you plan to use the dry run mode with the param `--dry-run-db`.
+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
 
@@ -174,6 +213,26 @@ docker start freqtrade
 
 You do not need to rebuild the image for configuration changes, it will suffice to edit `config.json` and restart the container.
 
+### 7. Backtest with docker
+
+The following assumes that the above steps (1-4) have been completed successfully.
+Also, backtest-data should be available at `~/.freqtrade/user_data/`.
+
+
+``` bash
+docker run -d \
+  --name freqtrade \
+  -v /etc/localtime:/etc/localtime:ro \
+  -v ~/.freqtrade/config.json:/freqtrade/config.json \
+  -v ~/.freqtrade/tradesv3.sqlite:/freqtrade/tradesv3.sqlite \
+  -v ~/.freqtrade/user_data/:/freqtrade/user_data/ \
+  freqtrade --strategy AwsomelyProfitableStrategy backtesting
+```
+
+Head over to the [Backtesting Documentation](https://github.com/freqtrade/freqtrade/blob/develop/docs/backtesting.md) for more details.
+
+*Note*: Additional parameters can be appended after the image name (`freqtrade` in the above example).
+
 ------
 
 ## Custom Installation
@@ -183,13 +242,13 @@ We've included/collected install instructions for Ubuntu 16.04, MacOS, and Windo
 ### Requirements
 
 Click each one for install guide:
+
 * [Python 3.6.x](http://docs.python-guide.org/en/latest/starting/installation/), note the bot was not tested on Python >= 3.7.x
 * [pip](https://pip.pypa.io/en/stable/installing/)
 * [git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
 * [virtualenv](https://virtualenv.pypa.io/en/stable/installation/) (Recommended)
 * [TA-Lib](https://mrjbq7.github.io/ta-lib/install.html)
 
-
 ### Linux - Ubuntu 16.04
 
 #### 1. Install Python 3.6, Git, and wget
@@ -208,6 +267,7 @@ Official webpage: https://mrjbq7.github.io/ta-lib/install.html
 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 "s|0.00000001|0.000000000000000001 |g" src/ta_func/ta_utility.h
 ./configure --prefix=/usr
 make
 make install
@@ -215,35 +275,20 @@ cd ..
 rm -rf ./ta-lib*
 ```
 
-#### 3. [Optional] Install MongoDB
-
-Install MongoDB if you plan to optimize your strategy with Hyperopt.
-
-```bash
-sudo apt-get install mongodb-org
-```
-
-> Complete tutorial from Digital Ocean: [How to Install MongoDB on Ubuntu 16.04](https://www.digitalocean.com/community/tutorials/how-to-install-mongodb-on-ubuntu-16-04).
-
-#### 4. Install FreqTrade
+#### 3. Install FreqTrade
 
 Clone the git repository:
 
 ```bash
-git clone https://github.com/gcarq/freqtrade.git
+git clone https://github.com/freqtrade/freqtrade.git
 ```
 
-Optionally checkout the develop branch:
-
-```bash
-git checkout develop
-```
-
-#### 5. Configure `freqtrade` as a `systemd` service
+#### 4. Configure `freqtrade` as a `systemd` service
 
 From the freqtrade repo... copy `freqtrade.service` to your systemd user directory (usually `~/.config/systemd/user`) and update `WorkingDirectory` and `ExecStart` to match your setup.
 
 After that you can start the daemon with:
+
 ```bash
 systemctl --user start freqtrade
 ```
@@ -254,7 +299,6 @@ For this to be persistent (run when user is logged out) you'll need to enable `l
 sudo loginctl enable-linger "$USER"
 ```
 
-
 ### MacOS
 
 #### 1. Install Python 3.6, git, wget and ta-lib
@@ -263,24 +307,12 @@ sudo loginctl enable-linger "$USER"
 brew install python3 git wget ta-lib
 ```
 
-#### 2. [Optional] Install MongoDB
-
-Install MongoDB if you plan to optimize your strategy with Hyperopt.
-
-```bash
-curl -O https://fastdl.mongodb.org/osx/mongodb-osx-ssl-x86_64-3.4.10.tgz
-tar -zxvf mongodb-osx-ssl-x86_64-3.4.10.tgz
-mkdir -p <path_freqtrade>/env/mongodb
-cp -R -n mongodb-osx-x86_64-3.4.10/ <path_freqtrade>/env/mongodb
-export PATH=<path_freqtrade>/env/mongodb/bin:$PATH
-```
-
-#### 3. Install FreqTrade
+#### 2. Install FreqTrade
 
 Clone the git repository:
 
 ```bash
-git clone https://github.com/gcarq/freqtrade.git
+git clone https://github.com/freqtrade/freqtrade.git
 ```
 
 Optionally checkout the develop branch:
@@ -289,7 +321,6 @@ Optionally checkout the develop branch:
 git checkout develop
 ```
 
-
 ### Setup Config and virtual env
 
 #### 1. Initialize the configuration
@@ -299,8 +330,7 @@ cd freqtrade
 cp config.json.example config.json
 ```
 
-> *To edit the config please refer to [Bot Configuration](https://github.com/gcarq/freqtrade/blob/develop/docs/configuration.md).*
-
+> *To edit the config please refer to [Bot Configuration](https://github.com/freqtrade/freqtrade/blob/develop/docs/configuration.md).*
 
 #### 2. Setup your Python virtual environment (virtualenv)
 
@@ -324,27 +354,41 @@ python3.6 ./freqtrade/main.py -c config.json
 
 ## Windows
 
-We recommend that Windows users use [Docker](#docker) as this will work
-much easier and smoother (also more secure).
+We recommend that Windows users use [Docker](#docker) as this will work much easier and smoother (also more secure).
 
-### Install freqtrade
+If that is not possible, try using the Windows Linux subsystem (WSL) - for which the Ubuntu instructions should work.
+If that is not available on your system, feel free to try the instructions below, which led to success for some.
+
+### Install freqtrade manually
+
+#### Clone the git repository
+
+```bash
+git clone https://github.com/freqtrade/freqtrade.git
+```
 
 copy paste `config.json` to ``\path\freqtrade-develop\freqtrade`
 
+#### install ta-lib
+
+Install ta-lib according to the [ta-lib documentation](https://github.com/mrjbq7/ta-lib#windows).
+
+As compiling from source on windows has heavy dependencies (requires a partial visual studio installation), there is also a repository of inofficial precompiled windows Wheels [here](https://www.lfd.uci.edu/~gohlke/pythonlibs/#ta-lib), which needs to be downloaded and installed using `pip install TA_Lib‑0.4.17‑cp36‑cp36m‑win32.whl` (make sure to use the version matching your python version)
+
 ```cmd
 >cd \path\freqtrade-develop
 >python -m venv .env
 >cd .env\Scripts
 >activate.bat
 >cd \path\freqtrade-develop
+REM optionally install ta-lib from wheel
+REM >pip install TA_Lib‑0.4.17‑cp36‑cp36m‑win32.whl
 >pip install -r requirements.txt
 >pip install -e .
->cd freqtrade
->python main.py
+>python freqtrade\main.py
 ```
 
-> Thanks [Owdr](https://github.com/Owdr) for the commands. Source: [Issue #222](https://github.com/gcarq/freqtrade/issues/222)
-
+> Thanks [Owdr](https://github.com/Owdr) for the commands. Source: [Issue #222](https://github.com/freqtrade/freqtrade/issues/222)
 
 Now you have an environment ready, the next step is
-[Bot Configuration](https://github.com/gcarq/freqtrade/blob/develop/docs/configuration.md)...
+[Bot Configuration](https://github.com/freqtrade/freqtrade/blob/develop/docs/configuration.md)...

docs/plotting.md

@@ -24,7 +24,7 @@ script/plot_dataframe.py [-h] [-p pair] [--live]
 
 Example
 ```
-python scripts/plot_dataframe.py -p BTC_ETH
+python scripts/plot_dataframe.py -p BTC/ETH
 ```
 
 The `-p` pair argument, can be used to specify what
@@ -34,15 +34,25 @@ pair you would like to plot.
 
 To plot the current live price use the `--live` flag:
 ```
-python scripts/plot_dataframe.py -p BTC_ETH --live
+python scripts/plot_dataframe.py -p BTC/ETH --live
 ```
 
 To plot a timerange (to zoom in):
 ```
-python scripts/plot_dataframe.py -p BTC_ETH --timerange=100-200
+python scripts/plot_dataframe.py -p BTC/ETH --timerange=100-200
 ```
 Timerange doesn't work with live data.
 
+To plot trades stored in a database use `--db-url` argument:
+```
+python scripts/plot_dataframe.py --db-url sqlite:///tradesv3.dry_run.sqlite -p BTC/ETH
+```
+
+To plot a test strategy the strategy should have first be backtested. 
+The results may then be plotted with the -s argument:
+```
+python scripts/plot_dataframe.py -s Strategy_Name -p BTC/ETH --datadir user_data/data/<exchange_name>/
+```
 
 ## Plot profit
 

docs/sandbox-testing.md

@@ -0,0 +1,151 @@
+# Sandbox API testing
+Where an exchange provides a sandbox for risk-free integration, or end-to-end, testing CCXT provides access to these.
+
+This document is a *light overview of configuring Freqtrade and GDAX sandbox.
+This can be useful to developers and trader alike as Freqtrade is quite customisable.
+
+When testing your API connectivity, make sure to use the following URLs.
+***Website**
+https://public.sandbox.gdax.com
+***REST API**
+https://api-public.sandbox.gdax.com
+
+---
+# Configure a Sandbox account on Gdax
+Aim of this document section
+- An sanbox account
+- create 2FA (needed to create an API)
+- Add test 50BTC to account 
+- Create :
+- - API-KEY
+- - API-Secret
+- - API Password
+
+## Acccount
+
+This link will redirect to the sandbox main page to login / create account dialogues:
+https://public.sandbox.pro.coinbase.com/orders/
+
+After registration and Email confimation you wil be redirected into your sanbox account.  It is easy to verify you're in sandbox by checking the URL bar.
+> https://public.sandbox.pro.coinbase.com/
+
+## Enable 2Fa (a prerequisite to creating sandbox API Keys)
+From within sand box site select your profile, top right.
+>Or as a direct link: https://public.sandbox.pro.coinbase.com/profile
+
+From the menu panel to the left of the screen select 
+> Security: "*View or Update*"
+
+In the new site select "enable authenticator" as typical google Authenticator. 
+- open Google Authenticator on your phone
+- scan barcode 
+- enter your generated 2fa 
+
+## Enable API Access 
+From within sandbox select profile>api>create api-keys
+>or as a direct link: https://public.sandbox.pro.coinbase.com/profile/api
+
+Click on "create one" and ensure  **view** and **trade**  are "checked" and sumbit your 2Fa
+- **Copy and paste the Passphase** into a notepade this will be needed later
+- **Copy and paste the API Secret** popup into a notepad this will needed later
+- **Copy and paste the API Key** into a notepad this will needed later
+
+## Add 50 BTC test funds
+To add funds, use the web interface deposit and withdraw buttons.
+
+
+To begin select 'Wallets' from the top menu.
+> Or as a direct link: https://public.sandbox.pro.coinbase.com/wallets
+
+- Deposits (bottom left of screen)
+- - Deposit Funds Bitcoin 
+- - - Coinbase BTC Wallet 
+- - - - Max (50 BTC) 
+- - - - - Deposit
+
+*This process may be repeated for other currencies, ETH as example*
+---
+# Configure Freqtrade to use Gax Sandbox 
+
+The aim of this document section
+ - Enable sandbox URLs in Freqtrade
+ - Configure API 
+ - - secret
+ - - key
+ - - passphrase
+ 
+## Sandbox URLs
+Freqtrade makes use of CCXT which in turn provides a list of URLs to Freqtrade. 
+These include `['test']` and `['api']`. 
+- `[Test]` if available will point to an Exchanges sandbox. 
+- `[Api]` normally used, and resolves to live API target on the exchange 
+
+To make use of sandbox / test add "sandbox": true, to your config.json
+```
+  "exchange": {
+        "name": "gdax",
+        "sandbox": true,
+        "key": "5wowfxemogxeowo;heiohgmd",
+        "secret": "/ZMH1P62rCVmwefewrgcewX8nh4gob+lywxfwfxwwfxwfNsH1ySgvWCUR/w==",
+        "password": "1bkjfkhfhfu6sr",
+        "pair_whitelist": [
+            "BTC/USD"
+```
+Also insert your 
+- api-key  (noted earlier)
+- api-secret (noted earlier)
+- password (the passphrase - noted earlier)
+
+---
+## You should now be ready to test your sandbox!
+Ensure Freqtrade logs show the sandbox URL, and trades made are shown in sandbox.
+** Typically the  BTC/USD has the most activity in sandbox to test against. 
+
+## GDAX - Old Candles problem
+It is my experience that GDAX sandbox candles may be 20+- minutes out of date. This can cause trades to fail as one of Freqtrades safety checks 
+
+To disable this check, edit: 
+>strategy/interface.py
+Look for the following section:
+```
+      # Check if dataframe is out of date
+        signal_date = arrow.get(latest['date'])
+        interval_minutes = constants.TICKER_INTERVAL_MINUTES[interval]
+        if signal_date < (arrow.utcnow().shift(minutes=-(interval_minutes * 2 + 5))):
+            logger.warning(
+                'Outdated history for pair %s. Last tick is %s minutes old',
+                pair,
+                (arrow.utcnow() - signal_date).seconds // 60
+            )
+            return False, False
+```
+
+You could Hash out the entire check as follows:
+```
+       # # Check if dataframe is out of date
+        # signal_date = arrow.get(latest['date'])
+        # interval_minutes = constants.TICKER_INTERVAL_MINUTES[interval]
+        # if signal_date < (arrow.utcnow().shift(minutes=-(interval_minutes * 2 + 5))):
+        #     logger.warning(
+        #         'Outdated history for pair %s. Last tick is %s minutes old',
+        #         pair,
+        #         (arrow.utcnow() - signal_date).seconds // 60
+        #     )
+        #     return False, False
+ ```
+ 
+ Or inrease the timeout to offer a level of protection/alignment of this test to freqtrade in live.
+ 
+ As example, to allow an additional 30 minutes. "(interval_minutes * 2 + 5 + 30)"
+ ```
+      # Check if dataframe is out of date
+        signal_date = arrow.get(latest['date'])
+        interval_minutes = constants.TICKER_INTERVAL_MINUTES[interval]
+        if signal_date < (arrow.utcnow().shift(minutes=-(interval_minutes * 2 + 5 + 30))):
+            logger.warning(
+                'Outdated history for pair %s. Last tick is %s minutes old',
+                pair,
+                (arrow.utcnow() - signal_date).seconds // 60
+            )
+            return False, False
+```

docs/sql_cheatsheet.md

@@ -32,9 +32,12 @@ CREATE TABLE trades (
 	exchange VARCHAR NOT NULL,
 	pair VARCHAR NOT NULL,
 	is_open BOOLEAN NOT NULL,
-	fee FLOAT NOT NULL,
+	fee_open FLOAT NOT NULL,
+	fee_close FLOAT NOT NULL,
 	open_rate FLOAT,
+	open_rate_requested FLOAT,
 	close_rate FLOAT,
+	close_rate_requested FLOAT,
 	close_profit FLOAT,
 	stake_amount FLOAT NOT NULL,
 	amount FLOAT,
@@ -56,7 +59,7 @@ SELECT * FROM trades;
 
 ```sql
 UPDATE trades
-SET is_open=0, close_date=<close_date>, close_rate=<close_rate>, close_profit=close_rate/open_rate  
+SET is_open=0, close_date=<close_date>, close_rate=<close_rate>, close_profit=close_rate/open_rate-1  
 WHERE id=<trade_ID_to_update>;
 ```
 
@@ -71,18 +74,18 @@ WHERE id=31;
 
 ```sql
 INSERT 
-INTO trades (exchange, pair, is_open, fee, open_rate, stake_amount, amount, open_date) 
-VALUES ('BITTREX', 'BTC_<COIN>', 1, 0.0025, <open_rate>, <stake_amount>, <amount>, '<datetime>')
+INTO trades (exchange, pair, is_open, fee_open, fee_close, open_rate, stake_amount, amount, open_date) 
+VALUES ('BITTREX', 'BTC_<COIN>', 1, 0.0025, 0.0025, <open_rate>, <stake_amount>, <amount>, '<datetime>')
 ```
 
 **Example:**
 ```sql
-INSERT INTO trades (exchange, pair, is_open, fee, open_rate, stake_amount, amount, open_date) VALUES ('BITTREX', 'BTC_ETC', 1, 0.0025, 0.00258580, 0.002, 0.7715262081, '2017-11-28 12:44:24.000000')
+INSERT INTO trades (exchange, pair, is_open, fee_open, fee_close, open_rate, stake_amount, amount, open_date) VALUES ('BITTREX', 'BTC_ETC', 1, 0.0025, 0.0025, 0.00258580, 0.002, 0.7715262081, '2017-11-28 12:44:24.000000')
 ```
 
 ## Fix wrong fees in the table
 If your DB was created before 
-[PR#200](https://github.com/gcarq/freqtrade/pull/200) was merged
+[PR#200](https://github.com/freqtrade/freqtrade/pull/200) was merged
 (before 12/23/17).
 
 ```sql

docs/stoploss.md

@@ -0,0 +1,51 @@
+# Stop Loss support
+
+At this stage the bot contains the following stoploss support modes:
+
+1. static stop loss, defined in either the strategy or configuration
+2. trailing stop loss, defined in the configuration
+3. trailing stop loss, custom positive loss, defined in configuration
+
+## Static Stop Loss
+
+This is very simple, basically you define a stop loss of x in your strategy file or alternative in the configuration, which
+will overwrite the strategy definition. This will basically try to sell your asset, the second the loss exceeds the defined loss.
+
+## Trail Stop Loss
+
+The initial value for this stop loss, is defined in your strategy or configuration. Just as you would define your Stop Loss normally.
+To enable this Feauture all you have to do is to define the configuration element:
+
+``` json
+"trailing_stop" : True
+```
+
+This will now activate an algorithm, which automatically moves your stop loss up every time the price of your asset increases.
+
+For example, simplified math,
+
+* you buy an asset at a price of 100$
+* your stop loss is defined at 2%
+* which means your stop loss, gets triggered once your asset dropped below 98$
+* assuming your asset now increases to 102$
+* your stop loss, will now be 2% of 102$ or 99.96$
+* now your asset drops in value to 101$, your stop loss, will still be 99.96$
+
+basically what this means is that your stop loss will be adjusted to be always be 2% of the highest observed price
+
+### Custom positive loss
+
+Due to demand, it is possible to have a default stop loss, when you are in the red with your buy, but once your profit surpasses a certain percentage,
+the system will utilize a new stop loss, which can be a different value. For example your default stop loss is 5%, but once you have 1.1% profit,
+it will be changed to be only a 1% stop loss, which trails the green candles until it goes below them.
+
+Both values can be configured in the main configuration file and requires `"trailing_stop": true` to be set to true.
+
+``` json
+    "trailing_stop_positive":  0.01,
+    "trailing_stop_positive_offset":  0.011,
+```
+
+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.

docs/telegram-usage.md

@@ -4,7 +4,7 @@ This page explains how to command your bot with Telegram.
 
 ## Pre-requisite
 To control your bot with Telegram, you need first to 
-[set up a Telegram bot](https://github.com/gcarq/freqtrade/blob/develop/docs/pre-requisite.md) 
+[set up a Telegram bot](https://github.com/freqtrade/freqtrade/blob/develop/docs/pre-requisite.md) 
 and add your Telegram API keys into your config file.
 
 ## Telegram commands
@@ -16,6 +16,7 @@ official commands. You can ask at any moment for help with `/help`.
 |----------|---------|-------------|
 | `/start` | | Starts the trader
 | `/stop` | | Stops the trader
+| `/reload_conf` | | Reloads the configuration file
 | `/status` | | Lists all open trades
 | `/status table` | | List all open trades in a table format
 | `/count` | | Displays number of trades used and available
@@ -42,7 +43,7 @@ Below, example of Telegram message you will receive for each command.
 For each open trade, the bot will send you the following message.
 
 > **Trade ID:** `123`  
-> **Current Pair:** BTC_CVC  
+> **Current Pair:** CVC/BTC
 > **Open Since:** `1 days ago`  
 > **Amount:** `26.64180098`  
 > **Open Rate:** `0.00007489`  
@@ -57,8 +58,8 @@ Return the status of all open trades in a table format.
 ```
    ID  Pair      Since    Profit  
 ----  --------  -------  --------  
-  67  BTC_SC    1 d      13.33%  
- 123  BTC_CVC   1 h      12.95%  
+  67  SC/BTC    1 d      13.33%
+ 123  CVC/BTC   1 h      12.95%
 ```
 
 ## /count
@@ -83,7 +84,7 @@ Return a summary of your profit/loss and performance.
 > **First Trade opened:** `3 days ago`  
 > **Latest Trade opened:** `2 minutes ago`  
 > **Avg. Duration:** `2:33:45`  
-> **Best Performing:** `BTC_PAY: 50.23%`
+> **Best Performing:** `PAY/BTC: 50.23%`
 
 ## /forcesell <trade_id>
 
@@ -92,11 +93,11 @@ Return a summary of your profit/loss and performance.
 ## /performance
 Return the performance of each crypto-currency the bot has sold.
 > Performance:  
-> 1. `BTC_RCN 57.77%`  
-> 2. `BTC_PAY 56.91%`  
-> 3. `BTC_VIB 47.07%`  
-> 4. `BTC_SALT 30.24%`  
-> 5. `BTC_STORJ 27.24%`  
+> 1. `RCN/BTC 57.77%`
+> 2. `PAY/BTC 56.91%`
+> 3. `VIB/BTC 47.07%`
+> 4. `SALT/BTC 30.24%`
+> 5. `STORJ/BTC 27.24%`
 > ...
 
 ## /balance
@@ -129,12 +130,8 @@ Day         Profit BTC      Profit USD
 > **Version:** `0.14.3` 
 
 ### using proxy with telegram
-in [freqtrade/freqtrade/rpc/telegram.py](https://github.com/gcarq/freqtrade/blob/develop/freqtrade/rpc/telegram.py) replace
 ```
-self._updater = Updater(token=self._config['telegram']['token'], workers=0)
-```
-
-with
-```
-self._updater = Updater(token=self._config['telegram']['token'], request_kwargs={'proxy_url': 'socks5://127.0.0.1:1080/'}, workers=0)
+$ export HTTP_PROXY="http://addr:port"
+$ export HTTPS_PROXY="http://addr:port"
+$ freqtrade
 ```

docs/webhook-config.md

@@ -0,0 +1,74 @@
+# Webhook usage
+
+This page explains how to configure your bot to talk to webhooks.
+
+## Configuration
+
+Enable webhooks by adding a webhook-section to your configuration file, and setting `webhook.enabled` to `true`.
+
+Sample configuration (tested using IFTTT).
+
+```json
+  "webhook": {
+        "enabled": true,
+        "url": "https://maker.ifttt.com/trigger/<YOUREVENT>/with/key/<YOURKEY>/",
+        "webhookbuy": {
+            "value1": "Buying {pair}",
+            "value2": "limit {limit:8f}",
+            "value3": "{stake_amount:8f} {stake_currency}"
+        },
+        "webhooksell": {
+            "value1": "Selling {pair}",
+            "value2": "limit {limit:8f}",
+            "value3": "profit: {profit_amount:8f} {stake_currency}"
+        },
+        "webhookstatus": {
+            "value1": "Status: {status}",
+            "value2": "",
+            "value3": ""
+        }
+    },
+```
+
+The url in `webhook.url` should point to the correct url for your webhook. If you're using [IFTTT](https://ifttt.com) (as shown in the sample above) please insert our event and key to the url.
+
+Different payloads can be configured for different events. Not all fields are necessary, but you should configure at least one of the dicts, otherwise the webhook will never be called.
+
+### Webhookbuy
+
+The fields in `webhook.webhookbuy` are filled when the bot executes a buy. Parameters are filled using string.format.
+Possible parameters are:
+
+* exchange
+* pair
+* market_url
+* limit
+* stake_amount
+* stake_amount_fiat
+* stake_currency
+* fiat_currency
+
+### Webhooksell
+
+The fields in `webhook.webhooksell` are filled when the bot sells a trade. Parameters are filled using string.format.
+Possible parameters are:
+
+* exchange
+* pair
+* gain
+* market_url
+* limit
+* amount
+* open_rate
+* current_rate
+* profit_amount
+* profit_percent
+* profit_fiat
+* stake_currency
+* fiat_currency
+
+### Webhookstatus
+
+The fields in `webhook.webhookstatus` are used for regular status messages (Started / Stopped / ...). Parameters are filled using string.format.
+
+The only possible value here is `{status}`.

freqtrade/__init__.py

@@ -1,5 +1,5 @@
 """ FreqTrade bot """
-__version__ = '0.16.1'
+__version__ = '0.17.1'
 
 
 class DependencyException(BaseException):
@@ -12,5 +12,14 @@ class DependencyException(BaseException):
 class OperationalException(BaseException):
     """
     Requires manual intervention.
-    This happens when an exchange returns an unexpected error during runtime.
+    This happens when an exchange returns an unexpected error during runtime
+    or given configuration is invalid.
+    """
+
+
+class TemporaryError(BaseException):
+    """
+    Temporary network or exchange related error.
+    This could happen when an exchange is congested, unavailable, or the user
+    has networking problems. Usually resolves itself after a time.
     """

freqtrade/__main__.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+"""
+__main__.py for Freqtrade
+To launch Freqtrade as a module
+
+> python -m freqtrade (with Python >= 3.6)
+"""
+
+import sys
+
+from freqtrade import main
+
+if __name__ == '__main__':
+    main.set_loggers()
+    main.main(sys.argv[1:])

freqtrade/analyze.py

@@ -1,214 +0,0 @@
-"""
-Functions to analyze ticker data with indicators and produce buy and sell signals
-"""
-import logging
-from datetime import datetime, timedelta
-from enum import Enum
-from typing import Dict, List, Tuple
-
-import arrow
-from pandas import DataFrame, to_datetime
-
-from freqtrade.exchange import get_ticker_history
-from freqtrade.persistence import Trade
-from freqtrade.strategy.resolver import StrategyResolver
-
-
-logger = logging.getLogger(__name__)
-
-
-class SignalType(Enum):
-    """
-    Enum to distinguish between buy and sell signals
-    """
-    BUY = "buy"
-    SELL = "sell"
-
-
-class Analyze(object):
-    """
-    Analyze class contains everything the bot need to determine if the situation is good for
-    buying or selling.
-    """
-    def __init__(self, config: dict) -> None:
-        """
-        Init Analyze
-        :param config: Bot configuration (use the one from Configuration())
-        """
-        self.config = config
-        self.strategy = StrategyResolver(self.config).strategy
-
-    @staticmethod
-    def parse_ticker_dataframe(ticker: list) -> DataFrame:
-        """
-        Analyses the trend for the given ticker history
-        :param ticker: See exchange.get_ticker_history
-        :return: DataFrame
-        """
-        columns = {'C': 'close', 'V': 'volume', 'O': 'open', 'H': 'high', 'L': 'low', 'T': 'date'}
-        frame = DataFrame(ticker).rename(columns=columns)
-        if 'BV' in frame:
-            frame.drop('BV', axis=1, inplace=True)
-
-        frame['date'] = to_datetime(frame['date'], 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({
-            'close': 'last',
-            'high': 'max',
-            'low': 'min',
-            'open': 'first',
-            'volume': 'max',
-        })
-        return frame
-
-    def populate_indicators(self, dataframe: DataFrame) -> DataFrame:
-        """
-        Adds several different TA indicators to the given DataFrame
-
-        Performance Note: For the best performance be frugal on the number of indicators
-        you are using. Let uncomment only the indicator you are using in your strategies
-        or your hyperopt configuration, otherwise you will waste your memory and CPU usage.
-        """
-        return self.strategy.populate_indicators(dataframe=dataframe)
-
-    def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
-        """
-        Based on TA indicators, populates the buy signal for the given dataframe
-        :param dataframe: DataFrame
-        :return: DataFrame with buy column
-        """
-        return self.strategy.populate_buy_trend(dataframe=dataframe)
-
-    def populate_sell_trend(self, dataframe: DataFrame) -> DataFrame:
-        """
-        Based on TA indicators, populates the sell signal for the given dataframe
-        :param dataframe: DataFrame
-        :return: DataFrame with buy column
-        """
-        return self.strategy.populate_sell_trend(dataframe=dataframe)
-
-    def get_ticker_interval(self) -> int:
-        """
-        Return ticker interval to use
-        :return: Ticker interval value to use
-        """
-        return self.strategy.ticker_interval
-
-    def analyze_ticker(self, ticker_history: List[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 = self.parse_ticker_dataframe(ticker_history)
-        dataframe = self.populate_indicators(dataframe)
-        dataframe = self.populate_buy_trend(dataframe)
-        dataframe = self.populate_sell_trend(dataframe)
-        return dataframe
-
-    def get_signal(self, pair: str, interval: int) -> Tuple[bool, bool]:
-        """
-        Calculates current signal based several technical analysis indicators
-        :param pair: pair in format BTC_ANT or BTC-ANT
-        :param interval: Interval to use (in min)
-        :return: (Buy, Sell) A bool-tuple indicating buy/sell signal
-        """
-        ticker_hist = get_ticker_history(pair, interval)
-        if not ticker_hist:
-            logger.warning('Empty ticker history for pair %s', pair)
-            return False, False
-
-        try:
-            dataframe = self.analyze_ticker(ticker_hist)
-        except ValueError as error:
-            logger.warning(
-                'Unable to analyze ticker for pair %s: %s',
-                pair,
-                str(error)
-            )
-            return False, False
-        except Exception as error:
-            logger.exception(
-                'Unexpected error when analyzing ticker for pair %s: %s',
-                pair,
-                str(error)
-            )
-            return False, False
-
-        if dataframe.empty:
-            logger.warning('Empty dataframe for pair %s', pair)
-            return False, False
-
-        latest = dataframe.iloc[-1]
-
-        # Check if dataframe is out of date
-        signal_date = arrow.get(latest['date'])
-        if signal_date < arrow.utcnow() - timedelta(minutes=(interval + 5)):
-            logger.warning(
-                'Outdated history for pair %s. Last tick is %s minutes old',
-                pair,
-                (arrow.utcnow() - signal_date).seconds // 60
-            )
-            return False, False
-
-        (buy, sell) = latest[SignalType.BUY.value] == 1, latest[SignalType.SELL.value] == 1
-        logger.debug(
-            'trigger: %s (pair=%s) buy=%s sell=%s',
-            latest['date'],
-            pair,
-            str(buy),
-            str(sell)
-        )
-        return buy, sell
-
-    def should_sell(self, trade: Trade, rate: float, date: datetime, buy: bool, sell: bool) -> bool:
-        """
-        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
-        """
-        # Check if minimal roi has been reached and no longer in buy conditions (avoiding a fee)
-        if self.min_roi_reached(trade=trade, current_rate=rate, current_time=date):
-            logger.debug('Required profit reached. Selling..')
-            return True
-
-        # Experimental: Check if the trade is profitable before selling it (avoid selling at loss)
-        if self.config.get('experimental', {}).get('sell_profit_only', False):
-            logger.debug('Checking if trade is profitable..')
-            if trade.calc_profit(rate=rate) <= 0:
-                return False
-
-        if sell and not buy and self.config.get('experimental', {}).get('use_sell_signal', False):
-            logger.debug('Sell signal received. Selling..')
-            return True
-
-        return False
-
-    def min_roi_reached(self, trade: Trade, current_rate: float, current_time: datetime) -> bool:
-        """
-        Based an earlier trade and current price and ROI configuration, decides whether bot should
-        sell
-        :return True if bot should sell at current rate
-        """
-        current_profit = trade.calc_profit_percent(current_rate)
-        if self.strategy.stoploss is not None and current_profit < self.strategy.stoploss:
-            logger.debug('Stop loss hit.')
-            return True
-
-        # 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.strategy.minimal_roi.items():
-            if time_diff <= duration:
-                return False
-            if current_profit > threshold:
-                return True
-
-        return False
-
-    def tickerdata_to_dataframe(self, tickerdata: Dict[str, List]) -> Dict[str, DataFrame]:
-        """
-        Creates a dataframe and populates indicators for given ticker data
-        """
-        return {pair: self.populate_indicators(self.parse_ticker_dataframe(pair_data))
-                for pair, pair_data in tickerdata.items()}

freqtrade/arguments.py

@@ -3,22 +3,35 @@ This module contains the argument manager class
 """
 
 import argparse
-import logging
 import os
 import re
-from typing import List, Tuple, Optional
+from typing import List, NamedTuple, Optional
+
+import arrow
 
 from freqtrade import __version__, constants
 
 
+class TimeRange(NamedTuple):
+    """
+    NamedTuple Defining timerange inputs.
+    [start/stop]type defines if [start/stop]ts shall be used.
+    if *type is none, don't use corresponding startvalue.
+    """
+    starttype: Optional[str] = None
+    stoptype: Optional[str] = None
+    startts: int = 0
+    stopts: int = 0
+
+
 class Arguments(object):
     """
     Arguments Class. Manage the arguments received by the cli
     """
 
-    def __init__(self, args: List[str], description: str):
+    def __init__(self, args: List[str], description: str) -> None:
         self.args = args
-        self.parsed_arg = None
+        self.parsed_arg: Optional[argparse.Namespace] = None
         self.parser = argparse.ArgumentParser(description=description)
 
     def _load_args(self) -> None:
@@ -50,16 +63,15 @@ class Arguments(object):
         """
         self.parser.add_argument(
             '-v', '--verbose',
-            help='be verbose',
-            action='store_const',
+            help='verbose mode (-vv for more, -vvv to get all messages)',
+            action='count',
             dest='loglevel',
-            const=logging.DEBUG,
-            default=logging.INFO,
+            default=0,
         )
         self.parser.add_argument(
             '--version',
             action='version',
-            version='%(prog)s {}'.format(__version__),
+            version=f'%(prog)s {__version__}'
         )
         self.parser.add_argument(
             '-c', '--config',
@@ -71,9 +83,9 @@ class Arguments(object):
         )
         self.parser.add_argument(
             '-d', '--datadir',
-            help='path to backtest data (default: %(default)s',
+            help='path to backtest data',
             dest='datadir',
-            default=os.path.join('freqtrade', 'tests', 'testdata'),
+            default=None,
             type=str,
             metavar='PATH',
         )
@@ -94,8 +106,8 @@ class Arguments(object):
         )
         self.parser.add_argument(
             '--dynamic-whitelist',
-            help='dynamically generate and update whitelist \
-                                  based on 24h BaseVolume (Default 20 currencies)',  # noqa
+            help='dynamically generate and update whitelist'
+                 ' based on 24h BaseVolume (default: %(const)s)',
             dest='dynamic_whitelist',
             const=constants.DYNAMIC_WHITELIST,
             type=int,
@@ -103,11 +115,13 @@ class Arguments(object):
             nargs='?',
         )
         self.parser.add_argument(
-            '--dry-run-db',
-            help='Force dry run to use a local DB "tradesv3.dry_run.sqlite" \
-                                  instead of memory DB. Work only if dry_run is enabled.',
-            action='store_true',
-            dest='dry_run_db',
+            '--db-url',
+            help='Override trades database URL, this is useful if dry_run is enabled'
+                 ' or in custom deployments (default: %(default)s)',
+            dest='db_url',
+            default=constants.DEFAULT_DB_PROD_URL,
+            type=str,
+            metavar='PATH',
         )
 
     @staticmethod
@@ -123,11 +137,21 @@ class Arguments(object):
         )
         parser.add_argument(
             '-r', '--refresh-pairs-cached',
-            help='refresh the pairs files in tests/testdata with the latest data from Bittrex. \
-                  Use it if you want to run your backtesting with up-to-date data.',
+            help='refresh the pairs files in tests/testdata with the latest data from the '
+                 'exchange. Use it if you want to run your backtesting with up-to-date data.',
             action='store_true',
             dest='refresh_pairs',
         )
+        parser.add_argument(
+            '--strategy-list',
+            help='Provide a commaseparated list of strategies to backtest '
+                 'Please note that ticker-interval needs to be set either in config '
+                 'or via command line. When using this together with --export trades, '
+                 'the strategy-name is injected into the filename '
+                 '(so backtest-data.json becomes backtest-data-DefaultStrategy.json',
+            nargs='+',
+            dest='strategy_list',
+        )
         parser.add_argument(
             '--export',
             help='export backtest results, argument are: trades\
@@ -136,22 +160,48 @@ class Arguments(object):
             default=None,
             dest='export',
         )
+        parser.add_argument(
+            '--export-filename',
+            help='Save backtest results to this filename \
+                  requires --export to be set as well\
+                  Example --export-filename=user_data/backtest_data/backtest_today.json\
+                  (default: %(default)s)',
+            type=str,
+            default=os.path.join('user_data', 'backtest_data', 'backtest-result.json'),
+            dest='exportfilename',
+            metavar='PATH',
+        )
 
     @staticmethod
     def optimizer_shared_options(parser: argparse.ArgumentParser) -> None:
+        """
+        Parses given common arguments for Backtesting and Hyperopt scripts.
+        :param parser:
+        :return:
+        """
         parser.add_argument(
             '-i', '--ticker-interval',
-            help='specify ticker interval in minutes (1, 5, 30, 60, 1440)',
+            help='specify ticker interval (1m, 5m, 30m, 1h, 1d)',
             dest='ticker_interval',
-            type=int,
-            metavar='INT',
+            type=str,
         )
         parser.add_argument(
-            '--realistic-simulation',
-            help='uses max_open_trades from config to simulate real world limitations',
+            '--eps', '--enable-position-stacking',
+            help='Allow buying the same pair multiple times (position stacking)',
             action='store_true',
-            dest='realistic_simulation',
+            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',
             help='specify what timerange of data to use.',
@@ -173,12 +223,6 @@ class Arguments(object):
             type=int,
             metavar='INT',
         )
-        parser.add_argument(
-            '--use-mongodb',
-            help='parallelize evaluations with mongodb (requires mongod in PATH)',
-            dest='mongodb',
-            action='store_true',
-        )
         parser.add_argument(
             '-s', '--spaces',
             help='Specify which parameters to hyperopt. Space separate list. \
@@ -211,17 +255,20 @@ class Arguments(object):
         self.hyperopt_options(hyperopt_cmd)
 
     @staticmethod
-    def parse_timerange(text: str) -> Optional[Tuple[List, int, int]]:
+    def parse_timerange(text: Optional[str]) -> TimeRange:
         """
         Parse the value of the argument --timerange to determine what is the range desired
         :param text: value from --timerange
         :return: Start and End range period
         """
         if text is None:
-            return None
+            return TimeRange(None, None, 0, 0)
         syntax = [(r'^-(\d{8})$', (None, 'date')),
                   (r'^(\d{8})-$', ('date', None)),
                   (r'^(\d{8})-(\d{8})$', ('date', 'date')),
+                  (r'^-(\d{10})$', (None, 'date')),
+                  (r'^(\d{10})-$', ('date', None)),
+                  (r'^(\d{10})-(\d{10})$', ('date', 'date')),
                   (r'^(-\d+)$', (None, 'line')),
                   (r'^(\d+)-$', ('line', None)),
                   (r'^(\d+)-(\d+)$', ('index', 'index'))]
@@ -231,23 +278,27 @@ class Arguments(object):
             if match:  # Regex has matched
                 rvals = match.groups()
                 index = 0
-                start = None
-                stop = None
+                start: int = 0
+                stop: int = 0
                 if stype[0]:
-                    start = rvals[index]
-                    if stype[0] != 'date':
-                        start = int(start)
+                    starts = rvals[index]
+                    if stype[0] == 'date' and len(starts) == 8:
+                        start = arrow.get(starts, 'YYYYMMDD').timestamp
+                    else:
+                        start = int(starts)
                     index += 1
                 if stype[1]:
-                    stop = rvals[index]
-                    if stype[1] != 'date':
-                        stop = int(stop)
-                return stype, start, stop
+                    stops = rvals[index]
+                    if stype[1] == 'date' and len(stops) == 8:
+                        stop = arrow.get(stops, 'YYYYMMDD').timestamp
+                    else:
+                        stop = int(stops)
+                return TimeRange(stype[0], stype[1], start, stop)
         raise Exception('Incorrect syntax for timerange "%s"' % text)
 
     def scripts_options(self) -> None:
         """
-        Parses given arguments for plot scripts.
+        Parses given arguments for scripts.
         """
         self.parser.add_argument(
             '-p', '--pair',
@@ -255,3 +306,58 @@ class Arguments(object):
             dest='pair',
             default=None
         )
+
+    def testdata_dl_options(self) -> None:
+        """
+        Parses given arguments for testdata download
+        """
+        self.parser.add_argument(
+            '--pairs-file',
+            help='File containing a list of pairs to download',
+            dest='pairs_file',
+            default=None,
+            metavar='PATH',
+        )
+
+        self.parser.add_argument(
+            '--export',
+            help='Export files to given dir',
+            dest='export',
+            default=None,
+            metavar='PATH',
+        )
+
+        self.parser.add_argument(
+            '--days',
+            help='Download data for number of days',
+            dest='days',
+            type=int,
+            metavar='INT',
+            default=None
+        )
+
+        self.parser.add_argument(
+            '--exchange',
+            help='Exchange name (default: %(default)s)',
+            dest='exchange',
+            type=str,
+            default='bittrex'
+        )
+
+        self.parser.add_argument(
+            '-t', '--timeframes',
+            help='Specify which tickers to download. Space separated list. \
+                  Default: %(default)s',
+            choices=['1m', '3m', '5m', '15m', '30m', '1h', '2h', '4h',
+                     '6h', '8h', '12h', '1d', '3d', '1w'],
+            default=['1m', '5m'],
+            nargs='+',
+            dest='timeframes',
+        )
+
+        self.parser.add_argument(
+            '--erase',
+            help='Clean all existing data for the selected exchange/pairs/timeframes',
+            dest='erase',
+            action='store_true'
+        )

freqtrade/configuration.py

@@ -1,21 +1,33 @@
 """
 This module contains the configuration class
 """
-
 import json
 import logging
+import os
 from argparse import Namespace
-from typing import Dict, Any
+from typing import Any, Dict, Optional
 
+import ccxt
 from jsonschema import Draft4Validator, validate
 from jsonschema.exceptions import ValidationError, best_match
 
-from freqtrade import constants
-
-
+from freqtrade import OperationalException, constants
 logger = logging.getLogger(__name__)
 
 
+def set_loggers(log_level: int = 0) -> None:
+    """
+    Set the logger level for Third party libs
+    :return: None
+    """
+
+    logging.getLogger('requests').setLevel(logging.INFO if log_level <= 1 else logging.DEBUG)
+    logging.getLogger("urllib3").setLevel(logging.INFO if log_level <= 1 else logging.DEBUG)
+    logging.getLogger('ccxt.base.exchange').setLevel(
+        logging.INFO if log_level <= 2 else logging.DEBUG)
+    logging.getLogger('telegram').setLevel(logging.INFO)
+
+
 class Configuration(object):
     """
     Class to read and init the bot configuration
@@ -23,7 +35,7 @@ class Configuration(object):
     """
     def __init__(self, args: Namespace) -> None:
         self.args = args
-        self.config = None
+        self.config: Optional[Dict[str, Any]] = None
 
     def load_config(self) -> Dict[str, Any]:
         """
@@ -61,11 +73,9 @@ class Configuration(object):
             with open(path) as file:
                 conf = json.load(file)
         except FileNotFoundError:
-            logger.critical(
-                'Config file "%s" not found. Please create your config file',
-                path
-            )
-            exit(0)
+            raise OperationalException(
+                f'Config file "{path}" not found!'
+                ' Please create a config file or check whether it exists.')
 
         if 'internals' not in conf:
             conf['internals'] = {}
@@ -81,12 +91,15 @@ class Configuration(object):
 
         # Log level
         if 'loglevel' in self.args and self.args.loglevel:
-            config.update({'loglevel': self.args.loglevel})
+            config.update({'verbosity': self.args.loglevel})
+        else:
+            config.update({'verbosity': 0})
         logging.basicConfig(
-                level=config['loglevel'],
+            level=logging.INFO if config['verbosity'] < 1 else logging.DEBUG,
             format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
         )
-            logger.info('Log level set to %s', logging.getLevelName(config['loglevel']))
+        set_loggers(config['verbosity'])
+        logger.info('Verbosity set to %s', config['verbosity'])
 
         # Add dynamic_whitelist if found
         if 'dynamic_whitelist' in self.args and self.args.dynamic_whitelist:
@@ -97,19 +110,35 @@ class Configuration(object):
                 '(not applicable with Backtesting and Hyperopt)'
             )
 
-        # Add dry_run_db if found and the bot in dry run
-        if self.args.dry_run_db and config.get('dry_run', False):
-            config.update({'dry_run_db': True})
-            logger.info('Parameter --dry-run-db detected ...')
+        if self.args.db_url != constants.DEFAULT_DB_PROD_URL:
+            config.update({'db_url': self.args.db_url})
+            logger.info('Parameter --db-url detected ...')
 
-        if config.get('dry_run_db', False):
         if config.get('dry_run', False):
-                logger.info('Dry_run will use the DB file: "tradesv3.dry_run.sqlite"')
+            logger.info('Dry run is enabled')
+            if config.get('db_url') in [None, constants.DEFAULT_DB_PROD_URL]:
+                # Default to in-memory db for dry_run if not specified
+                config['db_url'] = constants.DEFAULT_DB_DRYRUN_URL
         else:
-                logger.info('Dry run is disabled. (--dry_run_db ignored)')
+            if not config.get('db_url', None):
+                config['db_url'] = constants.DEFAULT_DB_PROD_URL
+            logger.info('Dry run is disabled')
+
+        logger.info(f'Using DB: "{config["db_url"]}"')
+
+        # Check if the exchange set by the user is supported
+        self.check_exchange(config)
 
         return config
 
+    def _create_default_datadir(self, config: Dict[str, Any]) -> str:
+        exchange_name = config.get('exchange', {}).get('name').lower()
+        default_path = os.path.join('user_data', 'data', exchange_name)
+        if not os.path.isdir(default_path):
+            os.makedirs(default_path)
+            logger.info(f'Created data directory: {default_path}')
+        return default_path
+
     def _load_backtesting_config(self, config: Dict[str, Any]) -> Dict[str, Any]:
         """
         Extract information for sys.argv and load Backtesting configuration
@@ -121,17 +150,24 @@ class Configuration(object):
         if 'ticker_interval' in self.args and self.args.ticker_interval:
             config.update({'ticker_interval': self.args.ticker_interval})
             logger.info('Parameter -i/--ticker-interval detected ...')
-            logger.info('Using ticker_interval: %d ...', config.get('ticker_interval'))
+            logger.info('Using ticker_interval: %s ...', config.get('ticker_interval'))
 
         # If -l/--live is used we add it to the configuration
         if 'live' in self.args and self.args.live:
             config.update({'live': True})
             logger.info('Parameter -l/--live detected ...')
 
-        # If --realistic-simulation is used we add it to the configuration
-        if 'realistic_simulation' in self.args and self.args.realistic_simulation:
-            config.update({'realistic_simulation': True})
-            logger.info('Parameter --realistic-simulation detected ...')
+        # If --enable-position-stacking is used we add it to the configuration
+        if 'position_stacking' in self.args and self.args.position_stacking:
+            config.update({'position_stacking': True})
+            logger.info('Parameter --enable-position-stacking detected ...')
+
+        # If --disable-max-market-positions is used we add it to the configuration
+        if 'use_max_market_positions' in self.args and not self.args.use_max_market_positions:
+            config.update({'use_max_market_positions': False})
+            logger.info('Parameter --disable-max-market-positions detected ...')
+            logger.info('max_open_trades set to unlimited ...')
+        else:
             logger.info('Using max_open_trades: %s ...', config.get('max_open_trades'))
 
         # If --timerange is used we add it to the configuration
@@ -142,18 +178,33 @@ 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})
-            logger.info('Parameter --datadir detected: %s ...', self.args.datadir)
+        else:
+            config.update({'datadir': self._create_default_datadir(config)})
+        logger.info('Using data folder: %s ...', config.get('datadir'))
 
         # If -r/--refresh-pairs-cached is used we add it to the configuration
         if 'refresh_pairs' in self.args and self.args.refresh_pairs:
             config.update({'refresh_pairs': True})
             logger.info('Parameter -r/--refresh-pairs-cached detected ...')
 
+        if 'strategy_list' in self.args and self.args.strategy_list:
+            config.update({'strategy_list': self.args.strategy_list})
+            logger.info('Using strategy list of %s Strategies', len(self.args.strategy_list))
+
+        if 'ticker_interval' in self.args and self.args.ticker_interval:
+            config.update({'ticker_interval': self.args.ticker_interval})
+            logger.info('Overriding ticker interval with Command line argument')
+
         # If --export is used we add it to the configuration
         if 'export' in self.args and self.args.export:
             config.update({'export': self.args.export})
             logger.info('Parameter --export detected: %s ...', self.args.export)
 
+        # If --export-filename is used we add it to the configuration
+        if 'export' in config and 'exportfilename' in self.args and self.args.exportfilename:
+            config.update({'exportfilename': self.args.exportfilename})
+            logger.info('Storing backtest results to %s ...', self.args.exportfilename)
+
         return config
 
     def _load_hyperopt_config(self, config: Dict[str, Any]) -> Dict[str, Any]:
@@ -161,17 +212,12 @@ class Configuration(object):
         Extract information for sys.argv and load Hyperopt configuration
         :return: configuration as dictionary
         """
-        # If --realistic-simulation is used we add it to the configuration
+        # If --epochs is used we add it to the configuration
         if 'epochs' in self.args and self.args.epochs:
             config.update({'epochs': self.args.epochs})
             logger.info('Parameter --epochs detected ...')
             logger.info('Will run Hyperopt with for %s epochs ...', config.get('epochs'))
 
-        # If --mongodb is used we add it to the configuration
-        if 'mongodb' in self.args and self.args.mongodb:
-            config.update({'mongodb': self.args.mongodb})
-            logger.info('Parameter --use-mongodb detected ...')
-
         # If --spaces is used we add it to the configuration
         if 'spaces' in self.args and self.args.spaces:
             config.update({'spaces': self.args.spaces})
@@ -189,7 +235,7 @@ class Configuration(object):
             validate(conf, constants.CONF_SCHEMA)
             return conf
         except ValidationError as exception:
-            logger.fatal(
+            logger.critical(
                 'Invalid configuration. See config.json.example. Reason: %s',
                 exception
             )
@@ -206,3 +252,22 @@ class Configuration(object):
             self.config = self.load_config()
 
         return self.config
+
+    def check_exchange(self, config: Dict[str, Any]) -> bool:
+        """
+        Check if the exchange name in the config file is supported by Freqtrade
+        :return: True or raised an exception if the exchange if not supported
+        """
+        exchange = config.get('exchange', {}).get('name').lower()
+        if exchange not in ccxt.exchanges:
+
+            exception_msg = f'Exchange "{exchange}" not supported.\n' \
+                            f'The following exchanges are supported: {", ".join(ccxt.exchanges)}'
+
+            logger.critical(exception_msg)
+            raise OperationalException(
+                exception_msg
+            )
+
+        logger.debug('Exchange "%s" supported', exchange)
+        return True

freqtrade/constants.py

@@ -9,23 +9,49 @@ TICKER_INTERVAL = 5  # min
 HYPEROPT_EPOCH = 100  # epochs
 RETRY_TIMEOUT = 30  # sec
 DEFAULT_STRATEGY = 'DefaultStrategy'
+DEFAULT_DB_PROD_URL = 'sqlite:///tradesv3.sqlite'
+DEFAULT_DB_DRYRUN_URL = 'sqlite://'
+UNLIMITED_STAKE_AMOUNT = 'unlimited'
+
+
+TICKER_INTERVAL_MINUTES = {
+    '1m': 1,
+    '3m': 3,
+    '5m': 5,
+    '15m': 15,
+    '30m': 30,
+    '1h': 60,
+    '2h': 120,
+    '4h': 240,
+    '6h': 360,
+    '8h': 480,
+    '12h': 720,
+    '1d': 1440,
+    '3d': 4320,
+    '1w': 10080,
+}
+
+SUPPORTED_FIAT = [
+    "AUD", "BRL", "CAD", "CHF", "CLP", "CNY", "CZK", "DKK",
+    "EUR", "GBP", "HKD", "HUF", "IDR", "ILS", "INR", "JPY",
+    "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': 1},
-        'ticker_interval': {'type': 'integer', 'enum': [1, 5, 30, 60, 1440]},
-        'stake_currency': {'type': 'string', 'enum': ['BTC', 'ETH', 'USDT']},
-        'stake_amount': {'type': 'number', 'minimum': 0.0005},
-        'fiat_display_currency': {'type': 'string', 'enum': ['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']},
+        'max_open_trades': {'type': 'integer', 'minimum': 0},
+        'ticker_interval': {'type': 'string', 'enum': list(TICKER_INTERVAL_MINUTES.keys())},
+        'stake_currency': {'type': 'string', 'enum': ['BTC', 'XBT', 'ETH', 'USDT', 'EUR', 'USD']},
+        'stake_amount': {
+            "type": ["number", "string"],
+            "minimum": 0.0005,
+            "pattern": UNLIMITED_STAKE_AMOUNT
+        },
+        'fiat_display_currency': {'type': 'string', 'enum': SUPPORTED_FIAT},
         'dry_run': {'type': 'boolean'},
         'minimal_roi': {
             'type': 'object',
@@ -35,7 +61,16 @@ CONF_SCHEMA = {
             'minProperties': 1
         },
         'stoploss': {'type': 'number', 'maximum': 0, 'exclusiveMaximum': True},
-        'unfilledtimeout': {'type': 'integer', 'minimum': 0},
+        'trailing_stop': {'type': 'boolean'},
+        'trailing_stop_positive': {'type': 'number', 'minimum': 0, 'maximum': 1},
+        'trailing_stop_positive_offset': {'type': 'number', 'minimum': 0, 'maximum': 1},
+        'unfilledtimeout': {
+            'type': 'object',
+            'properties': {
+                'buy': {'type': 'number', 'minimum': 3},
+                'sell': {'type': 'number', 'minimum': 10}
+            }
+        },
         'bid_strategy': {
             'type': 'object',
             'properties': {
@@ -53,7 +88,8 @@ CONF_SCHEMA = {
             'type': 'object',
             'properties': {
                 'use_sell_signal': {'type': 'boolean'},
-                'sell_profit_only': {'type': 'boolean'}
+                'sell_profit_only': {'type': 'boolean'},
+                "ignore_roi_if_buy_signal_true": {'type': 'boolean'}
             }
         },
         'telegram': {
@@ -65,6 +101,16 @@ CONF_SCHEMA = {
             },
             'required': ['enabled', 'token', 'chat_id']
         },
+        'webhook': {
+            'type': 'object',
+            'properties': {
+                'enabled': {'type': 'boolean'},
+                'webhookbuy': {'type': 'object'},
+                'webhooksell': {'type': 'object'},
+                'webhookstatus': {'type': 'object'},
+            },
+        },
+        'db_url': {'type': 'string'},
         'initial_state': {'type': 'string', 'enum': ['running', 'stopped']},
         'internals': {
             'type': 'object',
@@ -79,13 +125,16 @@ CONF_SCHEMA = {
             'type': 'object',
             'properties': {
                 'name': {'type': 'string'},
+                'sandbox': {'type': 'boolean'},
                 'key': {'type': 'string'},
                 'secret': {'type': 'string'},
+                'password': {'type': 'string'},
+                'uid': {'type': 'string'},
                 'pair_whitelist': {
                     'type': 'array',
                     'items': {
                         'type': 'string',
-                        'pattern': '^[0-9A-Z]+_[0-9A-Z]+$'
+                        'pattern': '^[0-9A-Z]+/[0-9A-Z]+$'
                     },
                     'uniqueItems': True
                 },
@@ -93,7 +142,7 @@ CONF_SCHEMA = {
                     'type': 'array',
                     'items': {
                         'type': 'string',
-                        'pattern': '^[0-9A-Z]+_[0-9A-Z]+$'
+                        'pattern': '^[0-9A-Z]+/[0-9A-Z]+$'
                     },
                     'uniqueItems': True
                 }
@@ -108,7 +157,6 @@ CONF_SCHEMA = {
         'max_open_trades',
         'stake_currency',
         'stake_amount',
-        'fiat_display_currency',
         'dry_run',
         'bid_strategy',
         'telegram'

freqtrade/exchange/__init__.py

@@ -1,185 +1,473 @@
 # pragma pylint: disable=W0603
 """ Cryptocurrency Exchanges support """
-import enum
 import logging
 from random import randint
 from typing import List, Dict, Any, Optional
+from datetime import datetime
+from math import floor, ceil
 
+import ccxt
 import arrow
-import requests
-from cachetools import cached, TTLCache
 
-from freqtrade import OperationalException
-from freqtrade.exchange.bittrex import Bittrex
-from freqtrade.exchange.interface import Exchange
+from freqtrade import constants, OperationalException, DependencyException, TemporaryError
 
 logger = logging.getLogger(__name__)
 
-# Current selected exchange
-_API: Exchange = None
-_CONF: dict = {}
-
-# Holds all open sell orders for dry_run
-_DRY_RUN_OPEN_ORDERS: Dict[str, Any] = {}
+API_RETRY_COUNT = 4
 
 
-class Exchanges(enum.Enum):
-    """
-    Maps supported exchange names to correspondent classes.
-    """
-    BITTREX = Bittrex
+# Urls to exchange markets, insert quote and base with .format()
+_EXCHANGE_URLS = {
+    ccxt.bittrex.__name__: '/Market/Index?MarketName={quote}-{base}',
+    ccxt.binance.__name__: '/tradeDetail.html?symbol={base}_{quote}'
+}
 
 
-def init(config: dict) -> None:
+def retrier(f):
+    def wrapper(*args, **kwargs):
+        count = kwargs.pop('count', API_RETRY_COUNT)
+        try:
+            return f(*args, **kwargs)
+        except (TemporaryError, DependencyException) as ex:
+            logger.warning('%s() returned exception: "%s"', f.__name__, ex)
+            if count > 0:
+                count -= 1
+                kwargs.update({'count': count})
+                logger.warning('retrying %s() still for %s times', f.__name__, count)
+                return wrapper(*args, **kwargs)
+            else:
+                logger.warning('Giving up retrying: %s()', f.__name__)
+                raise ex
+    return wrapper
+
+
+class Exchange(object):
+
+    # Current selected exchange
+    _api: ccxt.Exchange = None
+    _conf: Dict = {}
+    _cached_ticker: Dict[str, Any] = {}
+
+    # 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,
         it does basic validation whether the specified
         exchange and pairs are valid.
-    :param config: config to use
         :return: None
         """
-    global _CONF, _API
-
-    _CONF.update(config)
+        self._conf.update(config)
 
         if config['dry_run']:
             logger.info('Instance is running with dry_run enabled')
 
         exchange_config = config['exchange']
+        self._api = self._init_ccxt(exchange_config)
 
-    # Find matching class for the given exchange name
-    name = exchange_config['name']
-    try:
-        exchange_class = Exchanges[name.upper()].value
-    except KeyError:
-        raise OperationalException('Exchange {} is not supported'.format(name))
-
-    _API = exchange_class(exchange_config)
+        logger.info('Using Exchange "%s"', self.name)
 
         # Check if all pairs are available
-    validate_pairs(config['exchange']['pair_whitelist'])
+        self.validate_pairs(config['exchange']['pair_whitelist'])
 
+        if config.get('ticker_interval'):
+            # Check if timeframe is available
+            self.validate_timeframes(config['ticker_interval'])
 
-def validate_pairs(pairs: List[str]) -> None:
+    def _init_ccxt(self, exchange_config: dict) -> ccxt.Exchange:
+        """
+        Initialize ccxt with given config and return valid
+        ccxt instance.
+        """
+        # Find matching class for the given exchange name
+        name = exchange_config['name']
+
+        if name not in ccxt.exchanges:
+            raise OperationalException(f'Exchange {name} is not supported')
+        try:
+            api = getattr(ccxt, 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),
+            })
+        except (KeyError, AttributeError):
+            raise OperationalException(f'Exchange {name} is not supported')
+
+        self.set_sandbox(api, exchange_config, name)
+
+        return api
+
+    @property
+    def name(self) -> str:
+        """exchange Name (from ccxt)"""
+        return self._api.name
+
+    @property
+    def id(self) -> str:
+        """exchange ccxt id"""
+        return self._api.id
+
+    def set_sandbox(self, api, exchange_config: dict, name: str):
+        if exchange_config.get('sandbox'):
+            if api.urls.get('test'):
+                api.urls['api'] = api.urls['test']
+                logger.info("Enabled Sandbox API on %s", name)
+            else:
+                logger.warning(self._api.name, "No Sandbox URL in CCXT, exiting. "
+                                               "Please check your config.json")
+                raise OperationalException(f'Exchange {name} does not provide a sandbox api')
+
+    def validate_pairs(self, pairs: List[str]) -> None:
         """
         Checks if all given pairs are tradable on the current exchange.
         Raises OperationalException if one pair is not available.
         :param pairs: list of pairs
         :return: None
         """
+
         try:
-        markets = _API.get_markets()
-    except requests.exceptions.RequestException as e:
+            markets = self._api.load_markets()
+        except ccxt.BaseError as e:
             logger.warning('Unable to validate pairs (assuming they are correct). Reason: %s', e)
             return
 
-    stake_cur = _CONF['stake_currency']
+        stake_cur = self._conf['stake_currency']
         for pair in pairs:
-        if not pair.startswith(stake_cur):
+            # Note: ccxt has BaseCurrency/QuoteCurrency format for pairs
+            # TODO: add a support for having coins in BTC/USDT format
+            if not pair.endswith(stake_cur):
                 raise OperationalException(
-                'Pair {} not compatible with stake_currency: {}'.format(pair, stake_cur)
-            )
+                    f'Pair {pair} not compatible with stake_currency: {stake_cur}')
             if pair not in markets:
                 raise OperationalException(
-                'Pair {} is not available at {}'.format(pair, _API.name.lower()))
+                    f'Pair {pair} is not available at {self.name}')
 
+    def validate_timeframes(self, timeframe: List[str]) -> None:
+        """
+        Checks if ticker interval from config is a supported timeframe on the exchange
+        """
+        timeframes = self._api.timeframes
+        if timeframe not in timeframes:
+            raise OperationalException(
+                f'Invalid ticker {timeframe}, this Exchange supports {timeframes}')
 
-def buy(pair: str, rate: float, amount: float) -> str:
-    if _CONF['dry_run']:
-        global _DRY_RUN_OPEN_ORDERS
-        order_id = 'dry_run_buy_{}'.format(randint(0, 10**6))
-        _DRY_RUN_OPEN_ORDERS[order_id] = {
+    def exchange_has(self, endpoint: str) -> bool:
+        """
+        Checks if exchange implements a specific API endpoint.
+        Wrapper around ccxt 'has' attribute
+        :param endpoint: Name of endpoint (e.g. 'fetchOHLCV', 'fetchTickers')
+        :return: bool
+        """
+        return endpoint in self._api.has and self._api.has[endpoint]
+
+    def symbol_amount_prec(self, pair, amount: float):
+        '''
+        Returns the amount to buy or sell to a precision the Exchange accepts
+        Rounded down
+        '''
+        if self._api.markets[pair]['precision']['amount']:
+            symbol_prec = self._api.markets[pair]['precision']['amount']
+            big_amount = amount * pow(10, symbol_prec)
+            amount = floor(big_amount) / pow(10, symbol_prec)
+        return amount
+
+    def symbol_price_prec(self, pair, price: float):
+        '''
+        Returns the price buying or selling with to the precision the Exchange accepts
+        Rounds up
+        '''
+        if self._api.markets[pair]['precision']['price']:
+            symbol_prec = self._api.markets[pair]['precision']['price']
+            big_price = price * pow(10, symbol_prec)
+            price = ceil(big_price) / pow(10, symbol_prec)
+        return price
+
+    def buy(self, pair: str, rate: float, amount: float) -> 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,
-            'rate': rate,
+                'price': rate,
                 'amount': amount,
-            'type': 'LIMIT_BUY',
+                'type': 'limit',
+                'side': 'buy',
                 'remaining': 0.0,
-            'opened': arrow.utcnow().datetime,
-            'closed': arrow.utcnow().datetime,
+                'datetime': arrow.utcnow().isoformat(),
+                'status': 'closed',
+                'fee': None
             }
-        return order_id
+            return {'id': order_id}
 
-    return _API.buy(pair, rate, amount)
+        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)
 
+            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}.'
+                f'Tried to buy amount {amount} at rate {rate} (total {rate*amount}).'
+                f'Message: {e}')
+        except ccxt.InvalidOrder as e:
+            raise DependencyException(
+                f'Could not create limit buy order on market {pair}.'
+                f'Tried to buy amount {amount} at rate {rate} (total {rate*amount}).'
+                f'Message: {e}')
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not place buy order due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
 
-def sell(pair: str, rate: float, amount: float) -> str:
-    if _CONF['dry_run']:
-        global _DRY_RUN_OPEN_ORDERS
-        order_id = 'dry_run_sell_{}'.format(randint(0, 10**6))
-        _DRY_RUN_OPEN_ORDERS[order_id] = {
+    def sell(self, pair: str, rate: float, amount: float) -> 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,
-            'rate': rate,
+                'price': rate,
                 'amount': amount,
-            'type': 'LIMIT_SELL',
+                'type': 'limit',
+                'side': 'sell',
                 'remaining': 0.0,
-            'opened': arrow.utcnow().datetime,
-            'closed': arrow.utcnow().datetime,
+                'datetime': arrow.utcnow().isoformat(),
+                'status': 'closed'
             }
-        return order_id
+            return {'id': order_id}
 
-    return _API.sell(pair, rate, amount)
+        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)
 
+            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}.'
+                f'Tried to sell amount {amount} at rate {rate} (total {rate*amount}).'
+                f'Message: {e}')
+        except ccxt.InvalidOrder as e:
+            raise DependencyException(
+                f'Could not create limit sell order on market {pair}.'
+                f'Tried to sell amount {amount} at rate {rate} (total {rate*amount}).'
+                f'Message: {e}')
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not place sell order due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
 
-def get_balance(currency: str) -> float:
-    if _CONF['dry_run']:
+    @retrier
+    def get_balance(self, currency: str) -> float:
+        if self._conf['dry_run']:
             return 999.9
 
-    return _API.get_balance(currency)
+        # ccxt exception is already handled by get_balances
+        balances = self.get_balances()
+        balance = balances.get(currency)
+        if balance is None:
+            raise TemporaryError(
+                f'Could not get {currency} balance due to malformed exchange response: {balances}')
+        return balance['free']
 
+    @retrier
+    def get_balances(self) -> dict:
+        if self._conf['dry_run']:
+            return {}
 
-def get_balances():
-    if _CONF['dry_run']:
-        return []
+        try:
+            balances = self._api.fetch_balance()
+            # Remove additional info from ccxt results
+            balances.pop("info", None)
+            balances.pop("free", None)
+            balances.pop("total", None)
+            balances.pop("used", None)
 
-    return _API.get_balances()
+            return balances
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not get balance due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
 
+    @retrier
+    def get_tickers(self) -> Dict:
+        try:
+            return self._api.fetch_tickers()
+        except ccxt.NotSupported as e:
+            raise OperationalException(
+                f'Exchange {self._api.name} does not support fetching tickers in batch.'
+                f'Message: {e}')
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not load tickers due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
 
-def get_ticker(pair: str, refresh: Optional[bool] = True) -> dict:
-    return _API.get_ticker(pair, refresh)
+    @retrier
+    def get_ticker(self, pair: str, refresh: Optional[bool] = True) -> dict:
+        if refresh or pair not in self._cached_ticker.keys():
+            try:
+                data = self._api.fetch_ticker(pair)
+                try:
+                    self._cached_ticker[pair] = {
+                        'bid': float(data['bid']),
+                        'ask': float(data['ask']),
+                    }
+                except KeyError:
+                    logger.debug("Could not cache ticker data for %s", pair)
+                return data
+            except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+                raise TemporaryError(
+                    f'Could not load ticker history due to {e.__class__.__name__}. Message: {e}')
+            except ccxt.BaseError as e:
+                raise OperationalException(e)
+        else:
+            logger.info("returning cached ticker-data for %s", pair)
+            return self._cached_ticker[pair]
 
+    @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)
 
-@cached(TTLCache(maxsize=100, ttl=30))
-def get_ticker_history(pair: str, tick_interval) -> List[Dict]:
-    return _API.get_ticker_history(pair, tick_interval)
+            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])
 
-def cancel_order(order_id: str) -> None:
-    if _CONF['dry_run']:
+                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.'
+                f'Message: {e}')
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not load ticker history due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(f'Could not fetch ticker data. Msg: {e}')
+
+    @retrier
+    def cancel_order(self, order_id: str, pair: str) -> None:
+        if self._conf['dry_run']:
             return
 
-    return _API.cancel_order(order_id)
+        try:
+            return self._api.cancel_order(order_id, pair)
+        except ccxt.InvalidOrder as e:
+            raise DependencyException(
+                f'Could not cancel order. Message: {e}')
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not cancel order due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
 
-
-def get_order(order_id: str) -> Dict:
-    if _CONF['dry_run']:
-        order = _DRY_RUN_OPEN_ORDERS[order_id]
+    @retrier
+    def get_order(self, order_id: str, pair: str) -> Dict:
+        if self._conf['dry_run']:
+            order = self._dry_run_open_orders[order_id]
             order.update({
                 'id': order_id
             })
             return order
+        try:
+            return self._api.fetch_order(order_id, pair)
+        except ccxt.InvalidOrder as e:
+            raise DependencyException(
+                f'Could not get order. Message: {e}')
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not get order due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
 
-    return _API.get_order(order_id)
+    @retrier
+    def get_trades_for_order(self, order_id: str, pair: str, since: datetime) -> List:
+        if self._conf['dry_run']:
+            return []
+        if not self.exchange_has('fetchMyTrades'):
+            return []
+        try:
+            my_trades = self._api.fetch_my_trades(pair, since.timestamp())
+            matched_trades = [trade for trade in my_trades if trade['order'] == order_id]
 
+            return matched_trades
 
-def get_pair_detail_url(pair: str) -> str:
-    return _API.get_pair_detail_url(pair)
+        except ccxt.NetworkError as e:
+            raise TemporaryError(
+                f'Could not get trades due to networking error. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
 
+    def get_pair_detail_url(self, pair: str) -> str:
+        try:
+            url_base = self._api.urls.get('www')
+            base, quote = pair.split('/')
 
-def get_markets() -> List[str]:
-    return _API.get_markets()
+            return url_base + _EXCHANGE_URLS[self._api.id].format(base=base, quote=quote)
+        except KeyError:
+            logger.warning('Could not get exchange url for %s', self.name)
+            return ""
 
+    @retrier
+    def get_markets(self) -> List[dict]:
+        try:
+            return self._api.fetch_markets()
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not load markets due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
 
-def get_market_summaries() -> List[Dict]:
-    return _API.get_market_summaries()
+    @retrier
+    def get_fee(self, symbol='ETH/BTC', type='', side='', amount=1,
+                price=1, taker_or_maker='maker') -> float:
+        try:
+            # validate that markets are loaded before trying to get fee
+            if self._api.markets is None or len(self._api.markets) == 0:
+                self._api.load_markets()
 
+            return self._api.calculate_fee(symbol=symbol, type=type, side=side, amount=amount,
+                                           price=price, takerOrMaker=taker_or_maker)['rate']
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not get fee info due to {e.__class__.__name__}. Message: {e}')
+        except ccxt.BaseError as e:
+            raise OperationalException(e)
 
-def get_name() -> str:
-    return _API.name
-
-
-def get_fee() -> float:
-    return _API.fee
-
-
-def get_wallet_health() -> List[Dict]:
-    return _API.get_wallet_health()
+    def get_amount_lots(self, pair: str, amount: float) -> float:
+        """
+        get buyable amount rounding, ..
+        """
+        # validate that markets are loaded before trying to get fee
+        if not self._api.markets:
+            self._api.load_markets()
+        return self._api.amount_to_lots(pair, amount)

freqtrade/exchange/bittrex.py

@@ -1,211 +0,0 @@
-import logging
-from typing import Dict, List, Optional
-
-from bittrex.bittrex import API_V1_1, API_V2_0
-from bittrex.bittrex import Bittrex as _Bittrex
-from requests.exceptions import ContentDecodingError
-
-from freqtrade import OperationalException
-from freqtrade.exchange.interface import Exchange
-
-logger = logging.getLogger(__name__)
-
-_API: _Bittrex = None
-_API_V2: _Bittrex = None
-_EXCHANGE_CONF: dict = {}
-
-
-class Bittrex(Exchange):
-    """
-    Bittrex API wrapper.
-    """
-    # Base URL and API endpoints
-    BASE_URL: str = 'https://www.bittrex.com'
-    PAIR_DETAIL_METHOD: str = BASE_URL + '/Market/Index'
-
-    def __init__(self, config: dict) -> None:
-        global _API, _API_V2, _EXCHANGE_CONF
-
-        _EXCHANGE_CONF.update(config)
-        _API = _Bittrex(
-            api_key=_EXCHANGE_CONF['key'],
-            api_secret=_EXCHANGE_CONF['secret'],
-            calls_per_second=1,
-            api_version=API_V1_1,
-        )
-        _API_V2 = _Bittrex(
-            api_key=_EXCHANGE_CONF['key'],
-            api_secret=_EXCHANGE_CONF['secret'],
-            calls_per_second=1,
-            api_version=API_V2_0,
-        )
-        self.cached_ticker = {}
-
-    @staticmethod
-    def _validate_response(response) -> None:
-        """
-        Validates the given bittrex response
-        and raises a ContentDecodingError if a non-fatal issue happened.
-        """
-        temp_error_messages = [
-            'NO_API_RESPONSE',
-            'MIN_TRADE_REQUIREMENT_NOT_MET',
-        ]
-        if response['message'] in temp_error_messages:
-            raise ContentDecodingError(response['message'])
-
-    @property
-    def fee(self) -> float:
-        # 0.25 %: See https://bittrex.com/fees
-        return 0.0025
-
-    def buy(self, pair: str, rate: float, amount: float) -> str:
-        data = _API.buy_limit(pair.replace('_', '-'), amount, rate)
-        if not data['success']:
-            Bittrex._validate_response(data)
-            raise OperationalException('{message} params=({pair}, {rate}, {amount})'.format(
-                message=data['message'],
-                pair=pair,
-                rate=rate,
-                amount=amount))
-        return data['result']['uuid']
-
-    def sell(self, pair: str, rate: float, amount: float) -> str:
-        data = _API.sell_limit(pair.replace('_', '-'), amount, rate)
-        if not data['success']:
-            Bittrex._validate_response(data)
-            raise OperationalException('{message} params=({pair}, {rate}, {amount})'.format(
-                message=data['message'],
-                pair=pair,
-                rate=rate,
-                amount=amount))
-        return data['result']['uuid']
-
-    def get_balance(self, currency: str) -> float:
-        data = _API.get_balance(currency)
-        if not data['success']:
-            Bittrex._validate_response(data)
-            raise OperationalException('{message} params=({currency})'.format(
-                message=data['message'],
-                currency=currency))
-        return float(data['result']['Balance'] or 0.0)
-
-    def get_balances(self):
-        data = _API.get_balances()
-        if not data['success']:
-            Bittrex._validate_response(data)
-            raise OperationalException('{message}'.format(message=data['message']))
-        return data['result']
-
-    def get_ticker(self, pair: str, refresh: Optional[bool] = True) -> dict:
-        if refresh or pair not in self.cached_ticker.keys():
-            data = _API.get_ticker(pair.replace('_', '-'))
-            if not data['success']:
-                Bittrex._validate_response(data)
-                raise OperationalException('{message} params=({pair})'.format(
-                    message=data['message'],
-                    pair=pair))
-            keys = ['Bid', 'Ask', 'Last']
-            if not data.get('result') or\
-                    not all(key in data.get('result', {}) for key in keys) or\
-                    not all(data.get('result', {})[key] is not None for key in keys):
-                raise ContentDecodingError('Invalid response from Bittrex params=({pair})'.format(
-                    pair=pair))
-            # Update the pair
-            self.cached_ticker[pair] = {
-                'bid': float(data['result']['Bid']),
-                'ask': float(data['result']['Ask']),
-                'last': float(data['result']['Last']),
-            }
-        return self.cached_ticker[pair]
-
-    def get_ticker_history(self, pair: str, tick_interval: int) -> List[Dict]:
-        if tick_interval == 1:
-            interval = 'oneMin'
-        elif tick_interval == 5:
-            interval = 'fiveMin'
-        elif tick_interval == 30:
-            interval = 'thirtyMin'
-        elif tick_interval == 60:
-            interval = 'hour'
-        elif tick_interval == 1440:
-            interval = 'Day'
-        else:
-            raise ValueError('Unknown tick_interval: {}'.format(tick_interval))
-
-        data = _API_V2.get_candles(pair.replace('_', '-'), interval)
-
-        # These sanity check are necessary because bittrex cannot keep their API stable.
-        if not data.get('result'):
-            raise ContentDecodingError('Invalid response from Bittrex params=({pair})'.format(
-                pair=pair))
-
-        for prop in ['C', 'V', 'O', 'H', 'L', 'T']:
-            for tick in data['result']:
-                if prop not in tick.keys():
-                    raise ContentDecodingError('Required property {} not present '
-                                               'in response params=({})'.format(prop, pair))
-
-        if not data['success']:
-            Bittrex._validate_response(data)
-            raise OperationalException('{message} params=({pair})'.format(
-                message=data['message'],
-                pair=pair))
-
-        return data['result']
-
-    def get_order(self, order_id: str) -> Dict:
-        data = _API.get_order(order_id)
-        if not data['success']:
-            Bittrex._validate_response(data)
-            raise OperationalException('{message} params=({order_id})'.format(
-                message=data['message'],
-                order_id=order_id))
-        data = data['result']
-        return {
-            'id': data['OrderUuid'],
-            'type': data['Type'],
-            'pair': data['Exchange'].replace('-', '_'),
-            'opened': data['Opened'],
-            'rate': data['PricePerUnit'],
-            'amount': data['Quantity'],
-            'remaining': data['QuantityRemaining'],
-            'closed': data['Closed'],
-        }
-
-    def cancel_order(self, order_id: str) -> None:
-        data = _API.cancel(order_id)
-        if not data['success']:
-            Bittrex._validate_response(data)
-            raise OperationalException('{message} params=({order_id})'.format(
-                message=data['message'],
-                order_id=order_id))
-
-    def get_pair_detail_url(self, pair: str) -> str:
-        return self.PAIR_DETAIL_METHOD + '?MarketName={}'.format(pair.replace('_', '-'))
-
-    def get_markets(self) -> List[str]:
-        data = _API.get_markets()
-        if not data['success']:
-            Bittrex._validate_response(data)
-            raise OperationalException(data['message'])
-        return [m['MarketName'].replace('-', '_') for m in data['result']]
-
-    def get_market_summaries(self) -> List[Dict]:
-        data = _API.get_market_summaries()
-        if not data['success']:
-            Bittrex._validate_response(data)
-            raise OperationalException(data['message'])
-        return data['result']
-
-    def get_wallet_health(self) -> List[Dict]:
-        data = _API_V2.get_wallet_health()
-        if not data['success']:
-            Bittrex._validate_response(data)
-            raise OperationalException(data['message'])
-        return [{
-            'Currency': entry['Health']['Currency'],
-            'IsActive': entry['Health']['IsActive'],
-            'LastChecked': entry['Health']['LastChecked'],
-            'Notice': entry['Currency'].get('Notice'),
-        } for entry in data['result']]

freqtrade/exchange/exchange_helpers.py

@@ -0,0 +1,33 @@
+"""
+Functions to analyze ticker data with indicators and produce buy and sell signals
+"""
+import logging
+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

freqtrade/exchange/interface.py

@@ -1,172 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Dict, List, Optional
-
-
-class Exchange(ABC):
-    @property
-    def name(self) -> str:
-        """
-        Name of the exchange.
-        :return: str representation of the class name
-        """
-        return self.__class__.__name__
-
-    @property
-    def fee(self) -> float:
-        """
-        Fee for placing an order
-        :return: percentage in float
-        """
-
-    @abstractmethod
-    def buy(self, pair: str, rate: float, amount: float) -> str:
-        """
-        Places a limit buy order.
-        :param pair: Pair as str, format: BTC_ETH
-        :param rate: Rate limit for order
-        :param amount: The amount to purchase
-        :return: order_id of the placed buy order
-        """
-
-    @abstractmethod
-    def sell(self, pair: str, rate: float, amount: float) -> str:
-        """
-        Places a limit sell order.
-        :param pair: Pair as str, format: BTC_ETH
-        :param rate: Rate limit for order
-        :param amount: The amount to sell
-        :return: order_id of the placed sell order
-        """
-
-    @abstractmethod
-    def get_balance(self, currency: str) -> float:
-        """
-        Gets account balance.
-        :param currency: Currency as str, format: BTC
-        :return: float
-        """
-
-    @abstractmethod
-    def get_balances(self) -> List[dict]:
-        """
-        Gets account balances across currencies
-        :return: List of dicts, format: [
-          {
-            'Currency': str,
-            'Balance': float,
-            'Available': float,
-            'Pending': float,
-          }
-          ...
-        ]
-        """
-
-    @abstractmethod
-    def get_ticker(self, pair: str, refresh: Optional[bool] = True) -> dict:
-        """
-        Gets ticker for given pair.
-        :param pair: Pair as str, format: BTC_ETC
-        :param refresh: Shall we query a new value or a cached value is enough
-        :return: dict, format: {
-            'bid': float,
-            'ask': float,
-            'last': float
-        }
-        """
-
-    @abstractmethod
-    def get_ticker_history(self, pair: str, tick_interval: int) -> List[Dict]:
-        """
-        Gets ticker history for given pair.
-        :param pair: Pair as str, format: BTC_ETC
-        :param tick_interval: ticker interval in minutes
-        :return: list, format: [
-            {
-                'O': float,       (Open)
-                'H': float,       (High)
-                'L': float,       (Low)
-                'C': float,       (Close)
-                'V': float,       (Volume)
-                'T': datetime,    (Time)
-                'BV': float,      (Base Volume)
-            },
-            ...
-        ]
-        """
-
-    def get_order(self, order_id: str) -> Dict:
-        """
-        Get order details for the given order_id.
-        :param order_id: ID as str
-        :return: dict, format: {
-            'id': str,
-            'type': str,
-            'pair': str,
-            'opened': str ISO 8601 datetime,
-            'closed': str ISO 8601 datetime,
-            'rate': float,
-            'amount': float,
-            'remaining': int
-        }
-        """
-
-    @abstractmethod
-    def cancel_order(self, order_id: str) -> None:
-        """
-        Cancels order for given order_id.
-        :param order_id: ID as str
-        :return: None
-        """
-
-    @abstractmethod
-    def get_pair_detail_url(self, pair: str) -> str:
-        """
-        Returns the market detail url for the given pair.
-        :param pair: Pair as str, format: BTC_ETC
-        :return: URL as str
-        """
-
-    @abstractmethod
-    def get_markets(self) -> List[str]:
-        """
-        Returns all available markets.
-        :return: List of all available pairs
-        """
-
-    @abstractmethod
-    def get_market_summaries(self) -> List[Dict]:
-        """
-        Returns a 24h market summary for all available markets
-        :return: list, format: [
-            {
-                'MarketName': str,
-                'High': float,
-                'Low': float,
-                'Volume': float,
-                'Last': float,
-                'TimeStamp': datetime,
-                'BaseVolume': float,
-                'Bid': float,
-                'Ask': float,
-                'OpenBuyOrders': int,
-                'OpenSellOrders': int,
-                'PrevDay': float,
-                'Created': datetime
-            },
-            ...
-        ]
-        """
-
-    @abstractmethod
-    def get_wallet_health(self) -> List[Dict]:
-        """
-        Returns a list of all wallet health information
-        :return: list, format: [
-            {
-                'Currency': str,
-                'IsActive': bool,
-                'LastChecked': str,
-                'Notice': str
-            },
-            ...
-        """

freqtrade/fiat_convert.py

@@ -5,9 +5,13 @@ e.g BTC to USD
 
 import logging
 import time
+from typing import Dict, List
 
 from coinmarketcap import Market
 
+from freqtrade.constants import SUPPORTED_FIAT
+
+
 logger = logging.getLogger(__name__)
 
 
@@ -32,7 +36,7 @@ class CryptoFiat(object):
         self.price = 0.0
 
         # Private attributes
-        self._expiration = 0
+        self._expiration = 0.0
 
         self.crypto_symbol = crypto_symbol.upper()
         self.fiat_symbol = fiat_symbol.upper()
@@ -63,21 +67,9 @@ class CryptoToFiatConverter(object):
     This object is also a Singleton
     """
     __instance = None
-    _coinmarketcap = None
+    _coinmarketcap: Market = None
 
-    # Constants
-    SUPPORTED_FIAT = [
-        "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"
-    ]
-
-    CRYPTOMAP = {
-        'BTC': 'bitcoin',
-        'ETH': 'ethereum',
-        'USDT': 'thether'
-    }
+    _cryptomap: Dict = {}
 
     def __new__(cls):
         if CryptoToFiatConverter.__instance is None:
@@ -89,7 +81,19 @@ class CryptoToFiatConverter(object):
         return CryptoToFiatConverter.__instance
 
     def __init__(self) -> None:
-        self._pairs = []
+        self._pairs: List[CryptoFiat] = []
+        self._load_cryptomap()
+
+    def _load_cryptomap(self) -> None:
+        try:
+            coinlistings = self._coinmarketcap.listings()
+            self._cryptomap = dict(map(lambda coin: (coin["symbol"], str(coin["id"])),
+                                       coinlistings["data"]))
+        except (BaseException) as exception:
+            logger.error(
+                "Could not load FIAT Cryptocurrency map for the following problem: %s",
+                type(exception).__name__
+            )
 
     def convert_amount(self, crypto_amount: float, crypto_symbol: str, fiat_symbol: str) -> float:
         """
@@ -99,6 +103,8 @@ class CryptoToFiatConverter(object):
         :param fiat_symbol: fiat to convert to
         :return: float, value in fiat of the crypto-currency amount
         """
+        if crypto_symbol == fiat_symbol:
+            return crypto_amount
         price = self.get_price(crypto_symbol=crypto_symbol, fiat_symbol=fiat_symbol)
         return float(crypto_amount) * float(price)
 
@@ -114,7 +120,7 @@ class CryptoToFiatConverter(object):
 
         # Check if the fiat convertion you want is supported
         if not self._is_supported_fiat(fiat=fiat_symbol):
-            raise ValueError('The fiat {} is not supported.'.format(fiat_symbol))
+            raise ValueError(f'The fiat {fiat_symbol} is not supported.')
 
         # Get the pair that interest us and return the price in fiat
         for pair in self._pairs:
@@ -166,7 +172,7 @@ class CryptoToFiatConverter(object):
 
         fiat = fiat.upper()
 
-        return fiat in self.SUPPORTED_FIAT
+        return fiat in SUPPORTED_FIAT
 
     def _find_price(self, crypto_symbol: str, fiat_symbol: str) -> float:
         """
@@ -177,17 +183,24 @@ class CryptoToFiatConverter(object):
         """
         # Check if the fiat convertion you want is supported
         if not self._is_supported_fiat(fiat=fiat_symbol):
-            raise ValueError('The fiat {} is not supported.'.format(fiat_symbol))
+            raise ValueError(f'The fiat {fiat_symbol} is not supported.')
+
+        # No need to convert if both crypto and fiat are the same
+        if crypto_symbol == fiat_symbol:
+            return 1.0
+
+        if crypto_symbol not in self._cryptomap:
+            # return 0 for unsupported stake currencies (fiat-convert should not break the bot)
+            logger.warning("unsupported crypto-symbol %s - returning 0.0", crypto_symbol)
+            return 0.0
 
-        if crypto_symbol not in self.CRYPTOMAP:
-            raise ValueError(
-                'The crypto symbol {} is not supported.'.format(crypto_symbol))
         try:
             return float(
                 self._coinmarketcap.ticker(
-                    currency=self.CRYPTOMAP[crypto_symbol],
+                    currency=self._cryptomap[crypto_symbol],
                     convert=fiat_symbol
-                )[0]['price_' + fiat_symbol.lower()]
+                )['data']['quotes'][fiat_symbol.upper()]['price']
             )
-        except BaseException:
+        except BaseException as exception:
+            logger.error("Error in _find_price: %s", exception)
             return 0.0

freqtrade/freqtradebot.py

@@ -3,27 +3,24 @@ Freqtrade is the main module of this bot. It contains the class Freqtrade()
 """
 
 import copy
-import json
 import logging
 import time
 import traceback
 from datetime import datetime
-from typing import Dict, List, Optional, Any, Callable
+from typing import Any, Callable, Dict, List, Optional
 
 import arrow
 import requests
-from cachetools import cached, TTLCache
+from cachetools import TTLCache, cached
 
-from freqtrade import (
-    DependencyException, OperationalException, exchange, persistence, __version__
-)
-from freqtrade.analyze import Analyze
-from freqtrade import constants
-from freqtrade.fiat_convert import CryptoToFiatConverter
+from freqtrade import (DependencyException, OperationalException,
+                       TemporaryError, __version__, constants, persistence)
+from freqtrade.exchange import Exchange
 from freqtrade.persistence import Trade
-from freqtrade.rpc.rpc_manager import RPCManager
+from freqtrade.rpc import RPCManager, RPCMessageType
 from freqtrade.state import State
-
+from freqtrade.strategy.interface import SellType
+from freqtrade.strategy.resolver import IStrategy, StrategyResolver
 
 logger = logging.getLogger(__name__)
 
@@ -34,12 +31,11 @@ class FreqtradeBot(object):
     This is from here the bot start its logic.
     """
 
-    def __init__(self, config: Dict[str, Any], db_url: Optional[str] = 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.
-        :param db_url: database connector string for sqlalchemy (Optional)
         """
 
         logger.info(
@@ -52,27 +48,20 @@ class FreqtradeBot(object):
 
         # Init objects
         self.config = config
-        self.analyze = None
-        self.fiat_converter = None
-        self.rpc = None
+        self.strategy: IStrategy = StrategyResolver(self.config).strategy
+        self.rpc: RPCManager = RPCManager(self)
         self.persistence = None
-        self.exchange = None
+        self.exchange = Exchange(self.config)
+        self._init_modules()
 
-        self._init_modules(db_url=db_url)
-
-    def _init_modules(self, db_url: Optional[str] = None) -> None:
+    def _init_modules(self) -> None:
         """
         Initializes all modules and updates the config
-        :param db_url: database connector string for sqlalchemy (Optional)
         :return: None
         """
         # Initialize all modules
-        self.analyze = Analyze(self.config)
-        self.fiat_converter = CryptoToFiatConverter()
-        self.rpc = RPCManager(self)
 
-        persistence.init(self.config, db_url)
-        exchange.init(self.config)
+        persistence.init(self.config)
 
         # Set initial application state
         initial_state = self.config.get('initial_state')
@@ -82,19 +71,16 @@ class FreqtradeBot(object):
         else:
             self.state = State.STOPPED
 
-    def clean(self) -> bool:
+    def cleanup(self) -> None:
         """
-        Cleanup the application state und finish all pending tasks
+        Cleanup pending resources on an already stopped bot
         :return: None
         """
-        self.rpc.send_msg('*Status:* `Stopping trader...`')
-        logger.info('Stopping trader and cleaning up modules...')
-        self.state = State.STOPPED
+        logger.info('Cleaning up modules ...')
         self.rpc.cleanup()
         persistence.cleanup()
-        return True
 
-    def worker(self, old_state: None) -> State:
+    def worker(self, old_state: State = None) -> State:
         """
         Trading routine that must be run at each loop
         :param old_state: the previous service state from the previous call
@@ -103,8 +89,13 @@ class FreqtradeBot(object):
         # Log state transition
         state = self.state
         if state != old_state:
-            self.rpc.send_msg('*Status:* `{}`'.format(state.name.lower()))
+            self.rpc.send_msg({
+                'type': RPCMessageType.STATUS_NOTIFICATION,
+                'status': f'{state.name.lower()}'
+            })
             logger.info('Changing state to: %s', state.name)
+            if state == State.RUNNING:
+                self._startup_messages()
 
         if state == State.STOPPED:
             time.sleep(1)
@@ -121,6 +112,38 @@ class FreqtradeBot(object):
                            nb_assets=nb_assets)
         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
@@ -170,69 +193,78 @@ class FreqtradeBot(object):
 
             if 'unfilledtimeout' in self.config:
                 # Check and handle any timed out open orders
-                self.check_handle_timedout(self.config['unfilledtimeout'])
+                self.check_handle_timedout()
                 Trade.session.flush()
 
-        except (requests.exceptions.RequestException, json.JSONDecodeError) as error:
+        except TemporaryError as error:
             logger.warning('%s, retrying in 30 seconds...', error)
             time.sleep(constants.RETRY_TIMEOUT)
         except OperationalException:
-            self.rpc.send_msg(
-                '*Status:* OperationalException:\n```\n{traceback}```{hint}'
-                .format(
-                    traceback=traceback.format_exc(),
-                    hint='Issue `/start` if you think it is safe to restart.'
-                )
-            )
+            tb = traceback.format_exc()
+            hint = 'Issue `/start` if you think it is safe to restart.'
+            self.rpc.send_msg({
+                'type': RPCMessageType.STATUS_NOTIFICATION,
+                'status': f'OperationalException:\n```\n{tb}```{hint}'
+            })
             logger.exception('OperationalException. Stopping trader ...')
             self.state = State.STOPPED
         return state_changed
 
     @cached(TTLCache(maxsize=1, ttl=1800))
-    def _gen_pair_whitelist(self, base_currency: str, key: str = 'BaseVolume') -> List[str]:
+    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 'BaseVolume')
+        :param key: sort key (defaults to 'quoteVolume')
         :return: List of pairs
         """
-        summaries = sorted(
-            (s for s in exchange.get_market_summaries() if
-             s['MarketName'].startswith(base_currency)),
-            key=lambda s: s.get(key) or 0.0,
-            reverse=True
+
+        if not self.exchange.exchange_has('fetchTickers'):
+            raise OperationalException(
+                'Exchange does not support dynamic whitelist.'
+                'Please edit your config and restart the bot'
             )
 
-        return [s['MarketName'].replace('-', '_') for s in summaries]
+        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 wallet health and remove pair from whitelist if necessary
+        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
-        health = exchange.get_wallet_health()
+        markets = self.exchange.get_markets()
+
+        markets = [m for m in markets if m['quote'] == self.config['stake_currency']]
         known_pairs = set()
-        for status in health:
-            pair = '{}_{}'.format(self.config['stake_currency'], status['Currency'])
+        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 status['IsActive']:
+            if not market['active']:
                 sanitized_whitelist.remove(pair)
                 logger.info(
-                    'Ignoring %s from whitelist (reason: %s).',
-                    pair, status.get('Notice') or 'wallet is not active'
+                    '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, ticker: Dict[str, float]) -> float:
@@ -246,27 +278,80 @@ class FreqtradeBot(object):
         balance = self.config['bid_strategy']['ask_last_balance']
         return ticker['ask'] + balance * (ticker['last'] - ticker['ask'])
 
+    def _get_trade_stake_amount(self) -> 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 stake_amount == constants.UNLIMITED_STAKE_AMOUNT:
+            open_trades = len(Trade.query.filter(Trade.is_open.is_(True)).all())
+            if open_trades >= self.config['max_open_trades']:
+                logger.warning('Can\'t open a new trade: max number of trades is reached')
+                return None
+            return avaliable_amount / (self.config['max_open_trades'] - open_trades)
+
+        # 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'])
+            )
+
+        return stake_amount
+
+    def _get_min_pair_stake_amount(self, pair: str, price: float) -> Optional[float]:
+        markets = self.exchange.get_markets()
+        markets = [m for m in markets if m['symbol'] == pair]
+        if not markets:
+            raise ValueError(f'Can\'t get market information for symbol {pair}')
+
+        market = markets[0]
+
+        if 'limits' not in market:
+            return None
+
+        min_stake_amounts = []
+        limits = market['limits']
+        if ('cost' in limits and 'min' in limits['cost']
+                and limits['cost']['min'] is not None):
+            min_stake_amounts.append(limits['cost']['min'])
+
+        if ('amount' in limits and 'min' in limits['amount']
+                and limits['amount']['min'] is not None):
+            min_stake_amounts.append(limits['amount']['min'] * price)
+
+        if not min_stake_amounts:
+            return None
+
+        amount_reserve_percent = 1 - 0.05  # reserve 5% + stoploss
+        if self.strategy.stoploss is not None:
+            amount_reserve_percent += self.strategy.stoploss
+        # it should not be more than 50%
+        amount_reserve_percent = max(amount_reserve_percent, 0.5)
+        return min(min_stake_amounts)/amount_reserve_percent
+
     def create_trade(self) -> bool:
         """
         Checks the implemented trading indicator(s) for a randomly picked pair,
         if one pair triggers the buy_signal a new trade record gets created
-        :param stake_amount: amount of btc to spend
-        :param interval: Ticker interval used for Analyze
         :return: True if a trade object has been created and persisted, False otherwise
         """
-        stake_amount = self.config['stake_amount']
-        interval = self.analyze.get_ticker_interval()
+        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'])
-        # Check if stake_amount is fulfilled
-        if exchange.get_balance(self.config['stake_currency']) < stake_amount:
-            raise DependencyException(
-                'stake amount is not fulfilled (currency={})'.format(self.config['stake_currency'])
-            )
 
         # Remove currently opened and latest pairs from whitelist
         for trade in Trade.query.filter(Trade.is_open.is_(True)).all():
@@ -277,51 +362,66 @@ class FreqtradeBot(object):
         if not whitelist:
             raise DependencyException('No currency pairs in whitelist')
 
-        # Pick pair based on StochRSI buy signals
+        # Pick pair based on buy signals
         for _pair in whitelist:
-            (buy, sell) = self.analyze.get_signal(_pair, interval)
+            thistory = self.exchange.get_candle_history(_pair, interval)
+            (buy, sell) = self.strategy.get_signal(_pair, interval, thistory)
+
             if buy and not sell:
-                pair = _pair
-                break
-        else:
+                return self.execute_buy(_pair, stake_amount)
         return False
 
+    def execute_buy(self, pair: str, stake_amount: float) -> bool:
+        """
+        Executes a limit buy for the given pair
+        :param pair: pair for which we want to create a LIMIT_BUY
+        :return: None
+        """
+        pair_s = pair.replace('_', '/')
+        pair_url = self.exchange.get_pair_detail_url(pair)
+        stake_currency = self.config['stake_currency']
+        fiat_currency = self.config.get('fiat_display_currency', None)
+
         # Calculate amount
-        buy_limit = self.get_target_bid(exchange.get_ticker(pair))
+        buy_limit = self.get_target_bid(self.exchange.get_ticker(pair))
+
+        min_stake_amount = self._get_min_pair_stake_amount(pair_s, buy_limit)
+        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})'
+            )
+            return False
+
         amount = stake_amount / buy_limit
 
-        order_id = exchange.buy(pair, buy_limit, amount)
+        order_id = self.exchange.buy(pair, buy_limit, amount)['id']
 
-        stake_amount_fiat = self.fiat_converter.convert_amount(
-            stake_amount,
-            self.config['stake_currency'],
-            self.config['fiat_display_currency']
-        )
-
-        # Create trade entity and return
-        self.rpc.send_msg(
-            '*{}:* Buying [{}]({}) with limit `{:.8f} ({:.6f} {}, {:.3f} {})` '
-            .format(
-                exchange.get_name().upper(),
-                pair.replace('_', '/'),
-                exchange.get_pair_detail_url(pair),
-                buy_limit,
-                stake_amount,
-                self.config['stake_currency'],
-                stake_amount_fiat,
-                self.config['fiat_display_currency']
-            )
-        )
+        self.rpc.send_msg({
+            'type': RPCMessageType.BUY_NOTIFICATION,
+            'exchange': self.exchange.name.capitalize(),
+            'pair': pair_s,
+            'market_url': pair_url,
+            'limit': buy_limit,
+            '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(
             pair=pair,
             stake_amount=stake_amount,
             amount=amount,
-            fee=exchange.get_fee(),
+            fee_open=fee,
+            fee_close=fee,
             open_rate=buy_limit,
+            open_rate_requested=buy_limit,
             open_date=datetime.utcnow(),
-            exchange=exchange.get_name().upper(),
-            open_order_id=order_id
+            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()
@@ -348,65 +448,137 @@ class FreqtradeBot(object):
         Tries to execute a sell trade
         :return: True if executed
         """
+        try:
             # Get order details for actual price per unit
             if trade.open_order_id:
                 # Update trade with order values
                 logger.info('Found open order for %s', trade)
-            trade.update(exchange.get_order(trade.open_order_id))
+                order = self.exchange.get_order(trade.open_order_id, trade.pair)
+                # Try update amount (binance-fix)
+                try:
+                    new_amount = self.get_real_amount(trade, order)
+                    if order['amount'] != new_amount:
+                        order['amount'] = new_amount
+                        # Fee was applied, so set to 0
+                        trade.fee_open = 0
+
+                except OperationalException as exception:
+                    logger.warning("could not update trade amount: %s", exception)
+
+                trade.update(order)
 
             if trade.is_open and trade.open_order_id is None:
                 # Check if we can sell our current pair
                 return self.handle_trade(trade)
+        except DependencyException as exception:
+            logger.warning('Unable to sell trade: %s', exception)
         return False
 
+    def get_real_amount(self, trade: Trade, order: Dict) -> float:
+        """
+        Get real amount for the trade
+        Necessary for self.exchanges which charge fees in base currency (e.g. binance)
+        """
+        order_amount = order['amount']
+        # Only run for closed orders
+        if trade.fee_open == 0 or order['status'] == 'open':
+            return order_amount
+
+        # use fee from order-dict if possible
+        if 'fee' in order and order['fee'] and (order['fee'].keys() >= {'currency', 'cost'}):
+            if trade.pair.startswith(order['fee']['currency']):
+                new_amount = order_amount - order['fee']['cost']
+                logger.info("Applying fee on amount for %s (from %s to %s) from Order",
+                            trade, order['amount'], new_amount)
+                return new_amount
+
+        # Fallback to Trades
+        trades = self.exchange.get_trades_for_order(trade.open_order_id, trade.pair,
+                                                    trade.open_date)
+
+        if len(trades) == 0:
+            logger.info("Applying fee on amount for %s failed: myTrade-Dict empty found", trade)
+            return order_amount
+        amount = 0
+        fee_abs = 0
+        for exectrade in trades:
+            amount += exectrade['amount']
+            if "fee" in exectrade and (exectrade['fee'].keys() >= {'currency', 'cost'}):
+                # only applies if fee is in quote currency!
+                if trade.pair.startswith(exectrade['fee']['currency']):
+                    fee_abs += exectrade['fee']['cost']
+
+        if amount != order_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""")
+        return real_amount
+
     def handle_trade(self, trade: Trade) -> bool:
         """
         Sells the current pair if the threshold is reached and updates the trade record.
         :return: True if trade has been sold, False otherwise
         """
         if not trade.is_open:
-            raise ValueError('attempt to handle closed trade: {}'.format(trade))
+            raise ValueError(f'attempt to handle closed trade: {trade}')
 
         logger.debug('Handling %s ...', trade)
-        current_rate = exchange.get_ticker(trade.pair)['bid']
+        current_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.get_candle_history(trade.pair, self.strategy.ticker_interval)
+            (buy, sell) = self.strategy.get_signal(trade.pair, self.strategy.ticker_interval,
+                                                   ticker)
 
-        if self.config.get('experimental', {}).get('use_sell_signal'):
-            (buy, sell) = self.analyze.get_signal(trade.pair, self.analyze.get_ticker_interval())
-
-        if self.analyze.should_sell(trade, current_rate, datetime.utcnow(), buy, sell):
-            self.execute_sell(trade, current_rate)
+        should_sell = self.strategy.should_sell(trade, current_rate, datetime.utcnow(), buy, sell)
+        if should_sell.sell_flag:
+            self.execute_sell(trade, current_rate, should_sell.sell_type)
             return True
         logger.info('Found no sell signals for whitelisted currencies. Trying again..')
         return False
 
-    def check_handle_timedout(self, timeoutvalue: int) -> None:
+    def check_handle_timedout(self) -> None:
         """
         Check if any orders are timed out and cancel if neccessary
         :param timeoutvalue: Number of minutes until order is considered timed out
         :return: None
         """
-        timeoutthreashold = arrow.utcnow().shift(minutes=-timeoutvalue).datetime
+        buy_timeout = self.config['unfilledtimeout']['buy']
+        sell_timeout = self.config['unfilledtimeout']['sell']
+        buy_timeoutthreashold = arrow.utcnow().shift(minutes=-buy_timeout).datetime
+        sell_timeoutthreashold = arrow.utcnow().shift(minutes=-sell_timeout).datetime
 
         for trade in Trade.query.filter(Trade.open_order_id.isnot(None)).all():
             try:
-                order = exchange.get_order(trade.open_order_id)
+                # FIXME: Somehow the query above returns results
+                # where the open_order_id is in fact None.
+                # This is probably because the record got
+                # updated via /forcesell in a different thread.
+                if not trade.open_order_id:
+                    continue
+                order = self.exchange.get_order(trade.open_order_id, trade.pair)
             except requests.exceptions.RequestException:
                 logger.info(
                     'Cannot query order for %s due to %s',
                     trade,
                     traceback.format_exc())
                 continue
-            ordertime = arrow.get(order['opened'])
+            ordertime = arrow.get(order['datetime']).datetime
 
             # Check if trade is still actually open
             if int(order['remaining']) == 0:
                 continue
 
-            if order['type'] == "LIMIT_BUY" and ordertime < timeoutthreashold:
+            # Check if trade is still actually open
+            if order['status'] == 'open':
+                if order['side'] == 'buy' and ordertime < buy_timeoutthreashold:
                     self.handle_timedout_limit_buy(trade, order)
-            elif order['type'] == "LIMIT_SELL" and ordertime < timeoutthreashold:
+                elif order['side'] == 'sell' and ordertime < sell_timeoutthreashold:
                     self.handle_timedout_limit_sell(trade, order)
 
     # FIX: 20180110, why is cancel.order unconditionally here, whereas
@@ -416,16 +588,17 @@ class FreqtradeBot(object):
         """Buy timeout - cancel order
         :return: True if order was fully cancelled
         """
-        exchange.cancel_order(trade.open_order_id)
+        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)
-            # FIX? do we really need to flush, caller of
-            #      check_handle_timedout will flush afterwards
             Trade.session.flush()
             logger.info('Buy order timeout for %s.', trade)
-            self.rpc.send_msg('*Timeout:* Unfilled buy order for {} cancelled'.format(
-                trade.pair.replace('_', '/')))
+            self.rpc.send_msg({
+                'type': RPCMessageType.STATUS_NOTIFICATION,
+                'status': f'Unfilled buy order for {pair_s} cancelled due to timeout'
+            })
             return True
 
         # if trade is partially complete, edit the stake details for the trade
@@ -434,8 +607,10 @@ class FreqtradeBot(object):
         trade.stake_amount = trade.amount * trade.open_rate
         trade.open_order_id = None
         logger.info('Partial buy order timeout for %s.', trade)
-        self.rpc.send_msg('*Timeout:* Remaining buy order for {} cancelled'.format(
-            trade.pair.replace('_', '/')))
+        self.rpc.send_msg({
+            'type': RPCMessageType.STATUS_NOTIFICATION,
+            'status': f'Remaining buy order for {pair_s} cancelled due to timeout'
+        })
         return False
 
     # FIX: 20180110, should cancel_order() be cond. or unconditionally called?
@@ -444,83 +619,68 @@ class FreqtradeBot(object):
         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
-            exchange.cancel_order(trade.open_order_id)
+            self.exchange.cancel_order(trade.open_order_id, trade.pair)
             trade.close_rate = None
             trade.close_profit = None
             trade.close_date = None
             trade.is_open = True
             trade.open_order_id = None
-            self.rpc.send_msg('*Timeout:* Unfilled sell order for {} cancelled'.format(
-                trade.pair.replace('_', '/')))
+            self.rpc.send_msg({
+                'type': RPCMessageType.STATUS_NOTIFICATION,
+                'status': f'Unfilled sell order for {pair_s} cancelled due to timeout'
+            })
             logger.info('Sell order timeout for %s.', trade)
             return True
 
         # TODO: figure out how to handle partially complete sell orders
         return False
 
-    def execute_sell(self, trade: Trade, limit: float) -> None:
+    def execute_sell(self, trade: Trade, limit: float, sell_reason: SellType) -> None:
         """
         Executes a limit sell for the given trade and limit
         :param trade: Trade instance
         :param limit: limit rate for the sell order
+        :param sellreason: Reason the sell was triggered
         :return: None
         """
         # Execute sell and update trade record
-        order_id = exchange.sell(str(trade.pair), limit, trade.amount)
+        order_id = self.exchange.sell(str(trade.pair), limit, trade.amount)['id']
         trade.open_order_id = order_id
+        trade.close_rate_requested = limit
+        trade.sell_reason = sell_reason.value
 
-        fmt_exp_profit = round(trade.calc_profit_percent(rate=limit) * 100, 2)
         profit_trade = trade.calc_profit(rate=limit)
-        current_rate = exchange.get_ticker(trade.pair, False)['bid']
-        profit = trade.calc_profit_percent(current_rate)
+        current_rate = self.exchange.get_ticker(trade.pair)['bid']
+        profit_percent = trade.calc_profit_percent(limit)
+        pair_url = self.exchange.get_pair_detail_url(trade.pair)
+        gain = "profit" if profit_percent > 0 else "loss"
 
-        message = "*{exchange}:* Selling\n" \
-                  "*Current Pair:* [{pair}]({pair_url})\n" \
-                  "*Limit:* `{limit}`\n" \
-                  "*Amount:* `{amount}`\n" \
-                  "*Open Rate:* `{open_rate:.8f}`\n" \
-                  "*Current Rate:* `{current_rate:.8f}`\n" \
-                  "*Profit:* `{profit:.2f}%`" \
-                  "".format(
-                      exchange=trade.exchange,
-                      pair=trade.pair,
-                      pair_url=exchange.get_pair_detail_url(trade.pair),
-                      limit=limit,
-                      open_rate=trade.open_rate,
-                      current_rate=current_rate,
-                      amount=round(trade.amount, 8),
-                      profit=round(profit * 100, 2),
-                  )
+        msg = {
+            'type': RPCMessageType.SELL_NOTIFICATION,
+            'exchange': trade.exchange.capitalize(),
+            'pair': trade.pair,
+            'gain': gain,
+            'market_url': pair_url,
+            'limit': limit,
+            'amount': trade.amount,
+            'open_rate': trade.open_rate,
+            'current_rate': current_rate,
+            'profit_amount': profit_trade,
+            'profit_percent': profit_percent,
+        }
 
         # For regular case, when the configuration exists
         if 'stake_currency' in self.config and 'fiat_display_currency' in self.config:
-            fiat_converter = CryptoToFiatConverter()
-            profit_fiat = fiat_converter.convert_amount(
-                profit_trade,
-                self.config['stake_currency'],
-                self.config['fiat_display_currency']
-            )
-            message += '` ({gain}: {profit_percent:.2f}%, {profit_coin:.8f} {coin}`' \
-                       '` / {profit_fiat:.3f} {fiat})`' \
-                       ''.format(
-                           gain="profit" if fmt_exp_profit > 0 else "loss",
-                           profit_percent=fmt_exp_profit,
-                           profit_coin=profit_trade,
-                           coin=self.config['stake_currency'],
-                           profit_fiat=profit_fiat,
-                           fiat=self.config['fiat_display_currency'],
-                       )
-        # Because telegram._forcesell does not have the configuration
-        # Ignore the FIAT value and does not show the stake_currency as well
-        else:
-            message += '` ({gain}: {profit_percent:.2f}%, {profit_coin:.8f})`'.format(
-                gain="profit" if fmt_exp_profit > 0 else "loss",
-                profit_percent=fmt_exp_profit,
-                profit_coin=profit_trade
-            )
+            stake_currency = self.config['stake_currency']
+            fiat_currency = self.config['fiat_display_currency']
+            msg.update({
+                'stake_currency': stake_currency,
+                'fiat_currency': fiat_currency,
+            })
 
         # Send the message
-        self.rpc.send_msg(message)
+        self.rpc.send_msg(msg)
         Trade.session.flush()

freqtrade/indicator_helpers.py

@@ -1,4 +1,4 @@
-from math import exp, pi, sqrt, cos
+from math import cos, exp, pi, sqrt
 
 import numpy as np
 import talib as ta
@@ -13,7 +13,7 @@ def went_down(series: Series) -> bool:
     return series < series.shift(1)
 
 
-def ehlers_super_smoother(series: Series, smoothing: float = 6) -> type(Series):
+def ehlers_super_smoother(series: Series, smoothing: float = 6) -> Series:
     magic = pi * sqrt(2) / smoothing
     a1 = exp(-magic)
     coeff2 = 2 * a1 * cos(magic)

freqtrade/main.py

@@ -5,11 +5,15 @@ Read the documentation to know what cli arguments you need.
 """
 import logging
 import sys
+from argparse import Namespace
 from typing import List
 
+from freqtrade import OperationalException
 from freqtrade.arguments import Arguments
-from freqtrade.configuration import Configuration
+from freqtrade.configuration import Configuration, set_loggers
 from freqtrade.freqtradebot import FreqtradeBot
+from freqtrade.state import State
+from freqtrade.rpc import RPCMessageType
 
 logger = logging.getLogger('freqtrade')
 
@@ -43,25 +47,41 @@ def main(sysargv: List[str]) -> None:
         state = None
         while 1:
             state = freqtrade.worker(old_state=state)
+            if state == State.RELOAD_CONF:
+                freqtrade = reconfigure(freqtrade, args)
 
     except KeyboardInterrupt:
         logger.info('SIGINT received, aborting ...')
         return_code = 0
+    except OperationalException as e:
+        logger.error(str(e))
+        return_code = 2
     except BaseException:
         logger.exception('Fatal exception!')
     finally:
         if freqtrade:
-            freqtrade.clean()
+            freqtrade.rpc.send_msg({
+                'type': RPCMessageType.STATUS_NOTIFICATION,
+                'status': 'process died'
+            })
+            freqtrade.cleanup()
         sys.exit(return_code)
 
 
-def set_loggers() -> None:
+def reconfigure(freqtrade: FreqtradeBot, args: Namespace) -> FreqtradeBot:
     """
-    Set the logger level for Third party libs
-    :return: None
+    Cleans up current instance, reloads the configuration and returns the new instance
     """
-    logging.getLogger('requests.packages.urllib3').setLevel(logging.INFO)
-    logging.getLogger('telegram').setLevel(logging.INFO)
+    # Clean up current modules
+    freqtrade.cleanup()
+
+    # Create new instance
+    freqtrade = FreqtradeBot(Configuration(args).get_config())
+    freqtrade.rpc.send_msg({
+        'type': RPCMessageType.STATUS_NOTIFICATION,
+        'status': 'config reloaded'
+    })
+    return freqtrade
 
 
 if __name__ == '__main__':

freqtrade/misc.py

@@ -2,6 +2,7 @@
 Various tool function for Freqtrade and scripts
 """
 
+import gzip
 import json
 import logging
 import re
@@ -63,12 +64,28 @@ def common_datearray(dfs: Dict[str, DataFrame]) -> np.ndarray:
     return np.sort(arr, axis=0)
 
 
-def file_dump_json(filename, data) -> None:
+def file_dump_json(filename, data, is_zip=False) -> None:
     """
     Dump JSON data into a file
     :param filename: file to create
     :param data: JSON Data to save
     :return:
     """
+    print(f'dumping json to "{filename}"')
+
+    if is_zip:
+        if not filename.endswith('.gz'):
+            filename = filename + '.gz'
+        with gzip.open(filename, 'w') as fp:
+            json.dump(data, fp, default=str)
+    else:
         with open(filename, 'w') as fp:
             json.dump(data, fp, default=str)
+
+
+def format_ms_time(date: int) -> str:
+    """
+    convert MS date to readable format.
+    : epoch-string in ms
+    """
+    return datetime.fromtimestamp(date/1000.0).strftime('%Y-%m-%dT%H:%M:%S')

freqtrade/optimize/__init__.py

@@ -4,40 +4,58 @@ import gzip
 import json
 import logging
 import os
-from typing import Optional, List, Dict, Tuple
+from typing import Optional, List, Dict, Tuple, Any
+import arrow
 
-from freqtrade import misc
-from freqtrade.exchange import get_ticker_history
-from user_data.hyperopt_conf import hyperopt_optimize_conf
+from freqtrade import misc, constants, OperationalException
+from freqtrade.exchange import Exchange
+from freqtrade.arguments import TimeRange
 
 logger = logging.getLogger(__name__)
 
 
-def trim_tickerlist(tickerlist: List[Dict], timerange: Tuple[Tuple, int, int]) -> List[Dict]:
-    stype, start, stop = timerange
-    if stype == (None, 'line'):
-        return tickerlist[stop:]
-    elif stype == ('line', None):
-        return tickerlist[0:start]
-    elif stype == ('index', 'index'):
-        return tickerlist[start:stop]
-
+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: int,
-        timerange: Optional[Tuple[Tuple, int, int]] = None) -> Optional[List[Dict]]:
+        ticker_interval: str,
+        timerange: Optional[TimeRange] = None) -> Optional[List[Dict]]:
     """
     Load a pair from file,
     :return dict OR empty if unsuccesful
     """
     path = make_testdata_path(datadir)
-    file = os.path.join(path, '{pair}-{ticker_interval}.json'.format(
-        pair=pair,
-        ticker_interval=ticker_interval,
-    ))
+    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.
@@ -58,31 +76,38 @@ def load_tickerdata_file(
     return pairdata
 
 
-def load_data(datadir: str, ticker_interval: int,
-              pairs: Optional[List[str]] = None,
+def load_data(datadir: str,
+              ticker_interval: str,
+              pairs: List[str],
               refresh_pairs: Optional[bool] = False,
-              timerange: Optional[Tuple[Tuple, int, int]] = None) -> Dict[str, List]:
+              exchange: Optional[Exchange] = None,
+              timerange: TimeRange = TimeRange(None, None, 0, 0)) -> Dict[str, List]:
     """
     Loads ticker history data for the given parameters
     :return: dict
     """
     result = {}
 
-    _pairs = pairs or hyperopt_optimize_conf()['exchange']['pair_whitelist']
-
     # If the user force the refresh of pairs
     if refresh_pairs:
         logger.info('Download data for all pairs and store them in %s', datadir)
-        download_pairs(datadir, _pairs, ticker_interval)
+        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 not pairdata:
-            # download the tickerdata from exchange
-            download_backtesting_testdata(datadir, pair=pair, interval=ticker_interval)
-            # and retry reading the pair
+    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
 
 
@@ -95,14 +120,20 @@ def make_testdata_path(datadir: str) -> str:
     )
 
 
-def download_pairs(datadir, pairs: List[str], ticker_interval: int) -> bool:
+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, pair=pair, interval=ticker_interval)
+            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 min',
+                'Failed to download the pair: "%s", Interval: %s',
                 pair,
                 ticker_interval
             )
@@ -110,39 +141,89 @@ def download_pairs(datadir, pairs: List[str], ticker_interval: int) -> bool:
     return True
 
 
-# FIX: 20180110, suggest rename interval to tick_interval
-def download_backtesting_testdata(datadir: str, pair: str, interval: int = 5) -> None:
+def load_cached_data_for_updating(filename: str,
+                                  tick_interval: str,
+                                  timerange: Optional[TimeRange]) -> Tuple[
+                                                                                  List[Any],
+                                                                                  Optional[int]]:
     """
-    Download the latest 1 and 5 ticker intervals from Bittrex for the pairs passed in parameters
-    Based on @Rybolov work: https://github.com/rybolov/freqtrade-data
+    Load cached data and choose what part of the data should be updated
     """
 
-    path = make_testdata_path(datadir)
-    logger.info(
-        'Download the pair: "%s", Interval: %s min', pair, interval
-    )
+    since_ms = None
 
-    filename = os.path.join(path, '{pair}-{interval}.json'.format(
-        pair=pair.replace("-", "_"),
-        interval=interval,
-    ))
+    # 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 = []
 
-    logger.debug('Current Start: %s', data[1]['T'] if data else None)
-    logger.debug('Current End: %s', data[-1:][0]['T'] if data else None)
+    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
 
-    # Extend data with new ticker history
-    data.extend([
-        row for row in get_ticker_history(pair=pair, tick_interval=int(interval))
-        if row not in data
-    ])
+    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 pairs passed in parameters
+    The data is downloaded starting from the last correct ticker interval data that
+    esists 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 pairs: list of pairs 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')
+
+    new_data = exchange.get_candle_history(pair=pair, tick_interval=tick_interval,
+                                           since_ms=since_ms)
+    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]))
 
-    data = sorted(data, key=lambda _data: _data['T'])
-    logger.debug('New Start: %s', data[1]['T'])
-    logger.debug('New End: %s', data[-1:][0]['T'])
     misc.file_dump_json(filename, data)

freqtrade/optimize/backtesting.py

@@ -6,25 +6,46 @@ This module contains the backtesting logic
 import logging
 import operator
 from argparse import Namespace
-from typing import Dict, Tuple, Any, List, Optional
+from copy import deepcopy
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any, Dict, List, NamedTuple, Optional, Tuple
 
 import arrow
 from pandas import DataFrame
 from tabulate import tabulate
 
 import freqtrade.optimize as optimize
-from freqtrade import exchange
-from freqtrade.analyze import Analyze
+from freqtrade import DependencyException, constants
 from freqtrade.arguments import Arguments
 from freqtrade.configuration import Configuration
-from freqtrade.exchange import Bittrex
+from freqtrade.exchange import Exchange
 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
 
 logger = logging.getLogger(__name__)
 
 
+class BacktestResult(NamedTuple):
+    """
+    NamedTuple Defining BacktestResults inputs.
+    """
+    pair: str
+    profit_percent: float
+    profit_abs: float
+    open_time: datetime
+    close_time: datetime
+    open_index: int
+    close_index: int
+    trade_duration: float
+    open_at_end: bool
+    open_rate: float
+    close_rate: float
+    sell_reason: SellType
+
+
 class Backtesting(object):
     """
     Backtesting class, this class contains all the logic to run a backtest
@@ -33,26 +54,45 @@ class Backtesting(object):
     backtesting = Backtesting(config)
     backtesting.start()
     """
+
     def __init__(self, config: Dict[str, Any]) -> None:
         self.config = config
-        self.analyze = None
-        self.ticker_interval = None
-        self.tickerdata_to_dataframe = None
-        self.populate_buy_trend = None
-        self.populate_sell_trend = None
-        self._init()
 
-    def _init(self) -> None:
+        # Reset keys for backtesting
+        self.config['exchange']['key'] = ''
+        self.config['exchange']['secret'] = ''
+        self.config['exchange']['password'] = ''
+        self.config['exchange']['uid'] = ''
+        self.config['dry_run'] = True
+        self.strategylist: List[IStrategy] = []
+        if self.config.get('strategy_list', None):
+            # Force one interval
+            self.ticker_interval = str(self.config.get('ticker_interval'))
+            for strat in list(self.config['strategy_list']):
+                stratconf = deepcopy(self.config)
+                stratconf['strategy'] = strat
+                self.strategylist.append(StrategyResolver(stratconf).strategy)
+
+        else:
+            # only one strategy
+            strat = StrategyResolver(self.config).strategy
+
+            self.strategylist.append(StrategyResolver(self.config).strategy)
+        # Load one strategy
+        self._set_strategy(self.strategylist[0])
+
+        self.exchange = Exchange(self.config)
+        self.fee = self.exchange.get_fee()
+
+    def _set_strategy(self, strategy):
         """
-        Init objects required for backtesting
-        :return: None
+        Load strategy into backtesting
         """
-        self.analyze = Analyze(self.config)
-        self.ticker_interval = self.analyze.strategy.ticker_interval
-        self.tickerdata_to_dataframe = self.analyze.tickerdata_to_dataframe
-        self.populate_buy_trend = self.analyze.populate_buy_trend
-        self.populate_sell_trend = self.analyze.populate_sell_trend
-        exchange._API = Bittrex({'key': '', 'secret': ''})
+        self.strategy = strategy
+        self.ticker_interval = self.config.get('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]:
@@ -62,7 +102,7 @@ class Backtesting(object):
         :return: tuple containing min_date, max_date
         """
         timeframe = [
-            (arrow.get(min(frame.date)), arrow.get(max(frame.date)))
+            (arrow.get(frame['date'].min()), arrow.get(frame['date'].max()))
             for frame in data.values()
         ]
         return min(timeframe, key=operator.itemgetter(0))[0], \
@@ -73,22 +113,24 @@ class Backtesting(object):
         Generates and returns a text table for the given backtest data and the results dataframe
         :return: pretty printed table with tabulate as str
         """
-        stake_currency = self.config.get('stake_currency')
+        stake_currency = str(self.config.get('stake_currency'))
 
-        floatfmt = ('s', 'd', '.2f', '.8f', '.1f')
+        floatfmt = ('s', 'd', '.2f', '.2f', '.8f', 'd', '.1f', '.1f')
         tabular_data = []
-        headers = ['pair', 'buy count', 'avg profit %',
+        headers = ['pair', 'buy count', 'avg profit %', 'cum profit %',
                    'total profit ' + stake_currency, 'avg duration', 'profit', 'loss']
         for pair in data:
-            result = results[results.currency == pair]
+            result = results[results.pair == pair]
             tabular_data.append([
                 pair,
                 len(result.index),
                 result.profit_percent.mean() * 100.0,
-                result.profit_BTC.sum(),
-                result.duration.mean(),
-                len(result[result.profit_BTC > 0]),
-                len(result[result.profit_BTC < 0])
+                result.profit_percent.sum() * 100.0,
+                result.profit_abs.sum(),
+                str(timedelta(
+                    minutes=round(result.trade_duration.mean()))) if not result.empty else '0:00',
+                len(result[result.profit_abs > 0]),
+                len(result[result.profit_abs < 0])
             ])
 
         # Append Total
@@ -96,25 +138,79 @@ class Backtesting(object):
             'TOTAL',
             len(results.index),
             results.profit_percent.mean() * 100.0,
-            results.profit_BTC.sum(),
-            results.duration.mean(),
-            len(results[results.profit_BTC > 0]),
-            len(results[results.profit_BTC < 0])
+            results.profit_percent.sum() * 100.0,
+            results.profit_abs.sum(),
+            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)
+        return tabulate(tabular_data, headers=headers, floatfmt=floatfmt, tablefmt="pipe")
+
+    def _generate_text_table_sell_reason(self, data: Dict[str, Dict], results: DataFrame) -> str:
+        """
+        Generate small table outlining Backtest results
+        """
+        tabular_data = []
+        headers = ['Sell Reason', 'Count']
+        for reason, count in results['sell_reason'].value_counts().iteritems():
+            tabular_data.append([reason.value,  count])
+        return tabulate(tabular_data, headers=headers, tablefmt="pipe")
+
+    def _generate_text_table_strategy(self, all_results: dict) -> str:
+        """
+        Generate summary table per strategy
+        """
+        stake_currency = str(self.config.get('stake_currency'))
+
+        floatfmt = ('s', 'd', '.2f', '.2f', '.8f', 'd', '.1f', '.1f')
+        tabular_data = []
+        headers = ['Strategy', 'buy count', 'avg profit %', 'cum profit %',
+                   'total profit ' + stake_currency, 'avg duration', 'profit', 'loss']
+        for strategy, results in all_results.items():
+            tabular_data.append([
+                strategy,
+                len(results.index),
+                results.profit_percent.mean() * 100.0,
+                results.profit_percent.sum() * 100.0,
+                results.profit_abs.sum(),
+                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")
+
+    def _store_backtest_result(self, recordfilename: str, results: DataFrame,
+                               strategyname: Optional[str] = None) -> None:
+
+        records = [(t.pair, t.profit_percent, t.open_time.timestamp(),
+                    t.close_time.timestamp(), t.open_index - 1, t.trade_duration,
+                    t.open_rate, t.close_rate, t.open_at_end, t.sell_reason.value)
+                   for index, t in results.iterrows()]
+
+        if records:
+            if strategyname:
+                # Inject strategyname to filename
+                recname = Path(recordfilename)
+                recordfilename = str(Path.joinpath(
+                    recname.parent, f'{recname.stem}-{strategyname}').with_suffix(recname.suffix))
+            logger.info('Dumping backtest results to %s', recordfilename)
+            file_dump_json(recordfilename, records)
 
     def _get_sell_trade_entry(
             self, pair: str, buy_row: DataFrame,
-            partial_ticker: List, trade_count_lock: Dict, args: Dict) -> Optional[Tuple]:
+            partial_ticker: List, trade_count_lock: Dict, args: Dict) -> Optional[BacktestResult]:
 
         stake_amount = args['stake_amount']
         max_open_trades = args.get('max_open_trades', 0)
         trade = Trade(
-            open_rate=buy_row.close,
+            open_rate=buy_row.open,
             open_date=buy_row.date,
             stake_amount=stake_amount,
             amount=stake_amount / buy_row.open,
-            fee=exchange.get_fee()
+            fee_open=self.fee,
+            fee_close=self.fee
         )
 
         # calculate win/lose forwards from buy point
@@ -124,17 +220,44 @@ class Backtesting(object):
                 trade_count_lock[sell_row.date] = trade_count_lock.get(sell_row.date, 0) + 1
 
             buy_signal = sell_row.buy
-            if self.analyze.should_sell(trade, sell_row.close, sell_row.date, buy_signal,
-                                        sell_row.sell):
-                return \
-                    sell_row, \
-                    (
-                        pair,
-                        trade.calc_profit_percent(rate=sell_row.close),
-                        trade.calc_profit(rate=sell_row.close),
-                        (sell_row.date - buy_row.date).seconds // 60
-                    ), \
-                    sell_row.date
+            sell = self.strategy.should_sell(trade, sell_row.open, sell_row.date, buy_signal,
+                                             sell_row.sell)
+            if sell.sell_flag:
+
+                return BacktestResult(pair=pair,
+                                      profit_percent=trade.calc_profit_percent(rate=sell_row.open),
+                                      profit_abs=trade.calc_profit(rate=sell_row.open),
+                                      open_time=buy_row.date,
+                                      close_time=sell_row.date,
+                                      trade_duration=int((
+                                          sell_row.date - buy_row.date).total_seconds() // 60),
+                                      open_index=buy_row.Index,
+                                      close_index=sell_row.Index,
+                                      open_at_end=False,
+                                      open_rate=buy_row.open,
+                                      close_rate=sell_row.open,
+                                      sell_reason=sell.sell_type
+                                      )
+        if partial_ticker:
+            # no sell condition found - trade stil open at end of backtest period
+            sell_row = partial_ticker[-1]
+            btr = BacktestResult(pair=pair,
+                                 profit_percent=trade.calc_profit_percent(rate=sell_row.open),
+                                 profit_abs=trade.calc_profit(rate=sell_row.open),
+                                 open_time=buy_row.date,
+                                 close_time=sell_row.date,
+                                 trade_duration=int((
+                                     sell_row.date - buy_row.date).total_seconds() // 60),
+                                 open_index=buy_row.Index,
+                                 close_index=sell_row.Index,
+                                 open_at_end=True,
+                                 open_rate=buy_row.open,
+                                 close_rate=sell_row.open,
+                                 sell_reason=SellType.FORCE_SELL
+                                 )
+            logger.debug('Force_selling still open trade %s with %s perc - %s', btr.pair,
+                         btr.profit_percent, btr.profit_abs)
+            return btr
         return None
 
     def backtest(self, args: Dict) -> DataFrame:
@@ -149,23 +272,29 @@ class Backtesting(object):
             stake_amount: btc amount to use for each trade
             processed: a processed dictionary with format {pair, data}
             max_open_trades: maximum number of concurrent trades (default: 0, disabled)
-            realistic: do we try to simulate realistic trades? (default: True)
-            sell_profit_only: sell if profit only
-            use_sell_signal: act on sell-signal
+            position_stacking: do we allow position stacking? (default: False)
         :return: DataFrame
         """
         headers = ['date', 'buy', 'open', 'close', 'sell']
         processed = args['processed']
         max_open_trades = args.get('max_open_trades', 0)
-        realistic = args.get('realistic', False)
-        record = args.get('record', None)
-        records = []
+        position_stacking = args.get('position_stacking', False)
         trades = []
-        trade_count_lock = {}
+        trade_count_lock: Dict = {}
         for pair, pair_data in processed.items():
             pair_data['buy'], pair_data['sell'] = 0, 0  # cleanup from previous run
 
-            ticker_data = self.populate_sell_trend(self.populate_buy_trend(pair_data))[headers]
+            ticker_data = self.advise_sell(
+                self.advise_buy(pair_data, {'pair': pair}), {'pair': pair})[headers].copy()
+
+            # to avoid using data from future, we buy/sell with signal from previous candle
+            ticker_data.loc[:, 'buy'] = ticker_data['buy'].shift(1)
+            ticker_data.loc[:, 'sell'] = ticker_data['sell'].shift(1)
+
+            ticker_data.drop(ticker_data.head(1).index, inplace=True)
+
+            # Convert from Pandas to list for performance reasons
+            # (Looping Pandas is slow.)
             ticker = [x for x in ticker_data.itertuples()]
 
             lock_pair_until = None
@@ -173,7 +302,7 @@ class Backtesting(object):
                 if row.buy == 0 or row.sell == 1:
                     continue  # skip rows where no buy signal or that would immediately sell off
 
-                if realistic:
+                if not position_stacking:
                     if lock_pair_until is not None and row.date <= lock_pair_until:
                         continue
                 if max_open_trades > 0:
@@ -183,28 +312,18 @@ class Backtesting(object):
 
                     trade_count_lock[row.date] = trade_count_lock.get(row.date, 0) + 1
 
-                ret = self._get_sell_trade_entry(pair, row, ticker[index + 1:],
+                trade_entry = self._get_sell_trade_entry(pair, row, ticker[index + 1:],
                                                          trade_count_lock, args)
 
-                if ret:
-                    row2, trade_entry, next_date = ret
-                    lock_pair_until = next_date
+                if trade_entry:
+                    lock_pair_until = trade_entry.close_time
                     trades.append(trade_entry)
-                    if record:
-                        # Note, need to be json.dump friendly
-                        # record a tuple of pair, current_profit_percent,
-                        # entry-date, duration
-                        records.append((pair, trade_entry[1],
-                                        row.date.strftime('%s'),
-                                        row2.date.strftime('%s'),
-                                        index, trade_entry[3]))
-        # For now export inside backtest(), maybe change so that backtest()
-        # returns a tuple like: (dataframe, records, logs, etc)
-        if record and record.find('trades') >= 0:
-            logger.info('Dumping backtest results')
-            file_dump_json('backtest-result.json', records)
-        labels = ['currency', 'profit_percent', 'profit_BTC', 'duration']
-        return DataFrame.from_records(trades, columns=labels)
+                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
+
+        return DataFrame.from_records(trades, columns=BacktestResult._fields)
 
     def start(self) -> None:
         """
@@ -219,26 +338,37 @@ class Backtesting(object):
         if self.config.get('live'):
             logger.info('Downloading data for all pairs in whitelist ...')
             for pair in pairs:
-                data[pair] = exchange.get_ticker_history(pair, self.ticker_interval)
+                data[pair] = self.exchange.get_candle_history(pair, self.ticker_interval)
         else:
             logger.info('Using local backtesting data (using whitelist in given config) ...')
 
-            timerange = Arguments.parse_timerange(self.config.get('timerange'))
+            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'],
                 pairs=pairs,
                 ticker_interval=self.ticker_interval,
                 refresh_pairs=self.config.get('refresh_pairs', False),
+                exchange=self.exchange,
                 timerange=timerange
             )
 
-        # Ignore max_open_trades in backtesting, except realistic flag was passed
-        if self.config.get('realistic_simulation', False):
+        if not data:
+            logger.critical("No data found. Terminating.")
+            return
+        # Use max_open_trades in backtesting, except --disable-max-market-positions is set
+        if self.config.get('use_max_market_positions', True):
             max_open_trades = self.config['max_open_trades']
         else:
-            logger.info('Ignoring max_open_trades (realistic_simulation not set) ...')
+            logger.info('Ignoring max_open_trades (--disable-max-market-positions was used) ...')
             max_open_trades = 0
+        all_results = {}
 
+        for strat in self.strategylist:
+            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
@@ -251,29 +381,36 @@ class Backtesting(object):
             )
 
             # Execute backtest and print results
-        sell_profit_only = self.config.get('experimental', {}).get('sell_profit_only', False)
-        use_sell_signal = self.config.get('experimental', {}).get('use_sell_signal', False)
-        results = self.backtest(
+            all_results[self.strategy.get_strategy_name()] = self.backtest(
                 {
                     'stake_amount': self.config.get('stake_amount'),
                     'processed': preprocessed,
                     'max_open_trades': max_open_trades,
-                'realistic': self.config.get('realistic_simulation', False),
-                'sell_profit_only': sell_profit_only,
-                'use_sell_signal': use_sell_signal,
-                'record': self.config.get('export')
+                    'position_stacking': self.config.get('position_stacking', False),
                 }
             )
-        logger.info(
-            '\n==================================== '
-            'BACKTESTING REPORT'
-            ' ====================================\n'
-            '%s',
-            self._generate_text_table(
-                data,
-                results
-            )
-        )
+
+        for strategy, results in all_results.items():
+
+            if self.config.get('export', False):
+                self._store_backtest_result(self.config['exportfilename'], results,
+                                            strategy if len(self.strategylist) > 1 else None)
+
+            print(f"Result for strategy {strategy}")
+            print(' BACKTESTING REPORT '.center(119, '='))
+            print(self._generate_text_table(data, results))
+
+            print(' SELL REASON STATS '.center(119, '='))
+            print(self._generate_text_table_sell_reason(data, results))
+
+            print(' LEFT OPEN TRADES REPORT '.center(119, '='))
+            print(self._generate_text_table(data, results.loc[results.open_at_end]))
+            print()
+        if len(all_results) > 1:
+            # Print Strategy summary table
+            print(' Strategy Summary '.center(119, '='))
+            print(self._generate_text_table_strategy(all_results))
+            print('\nFor more details, please look at the detail tables above')
 
 
 def setup_configuration(args: Namespace) -> Dict[str, Any]:
@@ -289,6 +426,10 @@ def setup_configuration(args: Namespace) -> Dict[str, Any]:
     config['exchange']['key'] = ''
     config['exchange']['secret'] = ''
 
+    if config['stake_amount'] == constants.UNLIMITED_STAKE_AMOUNT:
+        raise DependencyException('stake amount could not be "%s" for backtesting' %
+                                  constants.UNLIMITED_STAKE_AMOUNT)
+
     return config
 
 

freqtrade/optimize/hyperopt.py

@@ -4,34 +4,33 @@
 This module contains the hyperopt logic
 """
 
-import json
 import logging
+import multiprocessing
 import os
-import pickle
-import signal
 import sys
 from argparse import Namespace
 from functools import reduce
 from math import exp
 from operator import itemgetter
-from typing import Dict, Any, Callable
+from typing import Any, Callable, Dict, List
 
-import numpy
 import talib.abstract as ta
-from hyperopt import STATUS_FAIL, STATUS_OK, Trials, fmin, hp, space_eval, tpe
-from hyperopt.mongoexp import MongoTrials
 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
 
 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.optimize.backtesting import Backtesting
-from user_data.hyperopt_conf import hyperopt_optimize_conf
-
 
 logger = logging.getLogger(__name__)
 
+MAX_LOSS = 100000  # just a big enough number to be bad result in loss optimization
+TICKERDATA_PICKLE = os.path.join('user_data', 'hyperopt_tickerdata.pkl')
+
 
 class Hyperopt(Backtesting):
     """
@@ -42,13 +41,11 @@ class Hyperopt(Backtesting):
     hyperopt.start()
     """
     def __init__(self, config: Dict[str, Any]) -> None:
-
         super().__init__(config)
         # set TARGET_TRADES to suit your number concurrent trades so its realistic
         # to the number of days
         self.target_trades = 600
         self.total_tries = config.get('epochs', 0)
-        self.current_tries = 0
         self.current_best_loss = 100
 
         # max average trade duration in minutes
@@ -60,130 +57,38 @@ class Hyperopt(Backtesting):
         # check that the reported Σ% values do not exceed this!
         self.expected_max_profit = 3.0
 
-        # Configuration and data used by hyperopt
-        self.processed = None
+        # Previous evaluations
+        self.trials_file = os.path.join('user_data', 'hyperopt_results.pickle')
+        self.trials: List = []
 
-        # Hyperopt Trials
-        self.trials_file = os.path.join('user_data', 'hyperopt_trials.pickle')
-        self.trials = Trials()
+    def get_args(self, params):
+        dimensions = self.hyperopt_space()
+        # Ensure the number of dimensions match
+        # the number of parameters in the list x.
+        if len(params) != len(dimensions):
+            raise ValueError('Mismatch in number of search-space dimensions. '
+                             f'len(dimensions)=={len(dimensions)} and len(x)=={len(params)}')
+
+        # Create a dict where the keys are the names of the dimensions
+        # and the values are taken from the list of parameters x.
+        arg_dict = {dim.name: value for dim, value in zip(dimensions, params)}
+        return arg_dict
 
     @staticmethod
-    def populate_indicators(dataframe: DataFrame) -> DataFrame:
-        """
-        Adds several different TA indicators to the given DataFrame
-        """
+    def populate_indicators(dataframe: DataFrame, metadata: dict) -> DataFrame:
         dataframe['adx'] = ta.ADX(dataframe)
-        dataframe['ao'] = qtpylib.awesome_oscillator(dataframe)
-        dataframe['cci'] = ta.CCI(dataframe)
         macd = ta.MACD(dataframe)
         dataframe['macd'] = macd['macd']
         dataframe['macdsignal'] = macd['macdsignal']
-        dataframe['macdhist'] = macd['macdhist']
         dataframe['mfi'] = ta.MFI(dataframe)
-        dataframe['minus_dm'] = ta.MINUS_DM(dataframe)
-        dataframe['minus_di'] = ta.MINUS_DI(dataframe)
-        dataframe['plus_dm'] = ta.PLUS_DM(dataframe)
-        dataframe['plus_di'] = ta.PLUS_DI(dataframe)
-        dataframe['roc'] = ta.ROC(dataframe)
         dataframe['rsi'] = ta.RSI(dataframe)
-        # Inverse Fisher transform on RSI, values [-1.0, 1.0] (https://goo.gl/2JGGoy)
-        rsi = 0.1 * (dataframe['rsi'] - 50)
-        dataframe['fisher_rsi'] = (numpy.exp(2 * rsi) - 1) / (numpy.exp(2 * rsi) + 1)
-        # Inverse Fisher transform on RSI normalized, value [0.0, 100.0] (https://goo.gl/2JGGoy)
-        dataframe['fisher_rsi_norma'] = 50 * (dataframe['fisher_rsi'] + 1)
-        # Stoch
-        stoch = ta.STOCH(dataframe)
-        dataframe['slowd'] = stoch['slowd']
-        dataframe['slowk'] = stoch['slowk']
-        # Stoch fast
         stoch_fast = ta.STOCHF(dataframe)
         dataframe['fastd'] = stoch_fast['fastd']
-        dataframe['fastk'] = stoch_fast['fastk']
-        # Stoch RSI
-        stoch_rsi = ta.STOCHRSI(dataframe)
-        dataframe['fastd_rsi'] = stoch_rsi['fastd']
-        dataframe['fastk_rsi'] = stoch_rsi['fastk']
+        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_middleband'] = bollinger['mid']
-        dataframe['bb_upperband'] = bollinger['upper']
-        # EMA - Exponential Moving Average
-        dataframe['ema3'] = ta.EMA(dataframe, timeperiod=3)
-        dataframe['ema5'] = ta.EMA(dataframe, timeperiod=5)
-        dataframe['ema10'] = ta.EMA(dataframe, timeperiod=10)
-        dataframe['ema50'] = ta.EMA(dataframe, timeperiod=50)
-        dataframe['ema100'] = ta.EMA(dataframe, timeperiod=100)
-        # SAR Parabolic
         dataframe['sar'] = ta.SAR(dataframe)
-        # SMA - Simple Moving Average
-        dataframe['sma'] = ta.SMA(dataframe, timeperiod=40)
-        # TEMA - Triple Exponential Moving Average
-        dataframe['tema'] = ta.TEMA(dataframe, timeperiod=9)
-        # Hilbert Transform Indicator - SineWave
-        hilbert = ta.HT_SINE(dataframe)
-        dataframe['htsine'] = hilbert['sine']
-        dataframe['htleadsine'] = hilbert['leadsine']
-
-        # Pattern Recognition - Bullish candlestick patterns
-        # ------------------------------------
-        """
-        # Hammer: values [0, 100]
-        dataframe['CDLHAMMER'] = ta.CDLHAMMER(dataframe)
-        # Inverted Hammer: values [0, 100]
-        dataframe['CDLINVERTEDHAMMER'] = ta.CDLINVERTEDHAMMER(dataframe)
-        # Dragonfly Doji: values [0, 100]
-        dataframe['CDLDRAGONFLYDOJI'] = ta.CDLDRAGONFLYDOJI(dataframe)
-        # Piercing Line: values [0, 100]
-        dataframe['CDLPIERCING'] = ta.CDLPIERCING(dataframe) # values [0, 100]
-        # Morningstar: values [0, 100]
-        dataframe['CDLMORNINGSTAR'] = ta.CDLMORNINGSTAR(dataframe) # values [0, 100]
-        # Three White Soldiers: values [0, 100]
-        dataframe['CDL3WHITESOLDIERS'] = ta.CDL3WHITESOLDIERS(dataframe) # values [0, 100]
-        """
-
-        # Pattern Recognition - Bearish candlestick patterns
-        # ------------------------------------
-        """
-        # Hanging Man: values [0, 100]
-        dataframe['CDLHANGINGMAN'] = ta.CDLHANGINGMAN(dataframe)
-        # Shooting Star: values [0, 100]
-        dataframe['CDLSHOOTINGSTAR'] = ta.CDLSHOOTINGSTAR(dataframe)
-        # Gravestone Doji: values [0, 100]
-        dataframe['CDLGRAVESTONEDOJI'] = ta.CDLGRAVESTONEDOJI(dataframe)
-        # Dark Cloud Cover: values [0, 100]
-        dataframe['CDLDARKCLOUDCOVER'] = ta.CDLDARKCLOUDCOVER(dataframe)
-        # Evening Doji Star: values [0, 100]
-        dataframe['CDLEVENINGDOJISTAR'] = ta.CDLEVENINGDOJISTAR(dataframe)
-        # Evening Star: values [0, 100]
-        dataframe['CDLEVENINGSTAR'] = ta.CDLEVENINGSTAR(dataframe)
-        """
-
-        # Pattern Recognition - Bullish/Bearish candlestick patterns
-        # ------------------------------------
-        """
-        # Three Line Strike: values [0, -100, 100]
-        dataframe['CDL3LINESTRIKE'] = ta.CDL3LINESTRIKE(dataframe)
-        # Spinning Top: values [0, -100, 100]
-        dataframe['CDLSPINNINGTOP'] = ta.CDLSPINNINGTOP(dataframe) # values [0, -100, 100]
-        # Engulfing: values [0, -100, 100]
-        dataframe['CDLENGULFING'] = ta.CDLENGULFING(dataframe) # values [0, -100, 100]
-        # Harami: values [0, -100, 100]
-        dataframe['CDLHARAMI'] = ta.CDLHARAMI(dataframe) # values [0, -100, 100]
-        # Three Outside Up/Down: values [0, -100, 100]
-        dataframe['CDL3OUTSIDE'] = ta.CDL3OUTSIDE(dataframe) # values [0, -100, 100]
-        # Three Inside Up/Down: values [0, -100, 100]
-        dataframe['CDL3INSIDE'] = ta.CDL3INSIDE(dataframe) # values [0, -100, 100]
-        """
-
-        # Chart type
-        # ------------------------------------
-        # Heikinashi stategy
-        heikinashi = qtpylib.heikinashi(dataframe)
-        dataframe['ha_open'] = heikinashi['open']
-        dataframe['ha_close'] = heikinashi['close']
-        dataframe['ha_high'] = heikinashi['high']
-        dataframe['ha_low'] = heikinashi['low']
 
         return dataframe
 
@@ -191,15 +96,16 @@ class Hyperopt(Backtesting):
         """
         Save hyperopt trials to file
         """
-        logger.info('Saving Trials to \'%s\'', self.trials_file)
-        pickle.dump(self.trials, open(self.trials_file, 'wb'))
+        if self.trials:
+            logger.info('Saving %d evaluations to \'%s\'', len(self.trials), self.trials_file)
+            dump(self.trials, self.trials_file)
 
-    def read_trials(self) -> Trials:
+    def read_trials(self) -> List:
         """
         Read hyperopt trials file
         """
         logger.info('Reading Trials from \'%s\'', self.trials_file)
-        trials = pickle.load(open(self.trials_file, 'rb'))
+        trials = load(self.trials_file)
         os.remove(self.trials_file)
         return trials
 
@@ -207,22 +113,27 @@ class Hyperopt(Backtesting):
         """
         Display Best hyperopt result
         """
-        vals = json.dumps(self.trials.best_trial['misc']['vals'], indent=4)
-        results = self.trials.best_trial['result']['result']
-        logger.info('Best result:\n%s\nwith values:\n%s', results, vals)
+        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']
+        )
+        if 'roi_t1' in best_result['params']:
+            logger.info('ROI table:\n%s', self.generate_roi_table(best_result['params']))
 
     def log_results(self, results) -> None:
         """
         Log results if it is better than any previous evaluation
         """
         if results['loss'] < self.current_best_loss:
+            current = results['current_tries']
+            total = results['total_tries']
+            res = results['result']
+            loss = results['loss']
             self.current_best_loss = results['loss']
-            log_msg = '\n{:5d}/{}: {}. Loss {:.5f}'.format(
-                results['current_tries'],
-                results['total_tries'],
-                results['result'],
-                results['loss']
-            )
+            log_msg = f'\n{current:5d}/{total}: {res}. Loss {loss:.5f}'
             print(log_msg)
         else:
             print('.', end='')
@@ -235,7 +146,8 @@ class Hyperopt(Backtesting):
         trade_loss = 1 - 0.25 * exp(-(trade_count - self.target_trades) ** 2 / 10 ** 5.8)
         profit_loss = max(0, 1 - total_profit / self.expected_max_profit)
         duration_loss = 0.4 * min(trade_duration / self.max_accepted_trade_duration, 1)
-        return trade_loss + profit_loss + duration_loss
+        result = trade_loss + profit_loss + duration_loss
+        return result
 
     @staticmethod
     def generate_roi_table(params: Dict) -> Dict[int, float]:
@@ -251,87 +163,44 @@ class Hyperopt(Backtesting):
         return roi_table
 
     @staticmethod
-    def roi_space() -> Dict[str, Any]:
+    def roi_space() -> List[Dimension]:
         """
         Values to search for each ROI steps
         """
-        return {
-            'roi_t1': hp.quniform('roi_t1', 10, 120, 20),
-            'roi_t2': hp.quniform('roi_t2', 10, 60, 15),
-            'roi_t3': hp.quniform('roi_t3', 10, 40, 10),
-            'roi_p1': hp.quniform('roi_p1', 0.01, 0.04, 0.01),
-            'roi_p2': hp.quniform('roi_p2', 0.01, 0.07, 0.01),
-            'roi_p3': hp.quniform('roi_p3', 0.01, 0.20, 0.01),
-        }
+        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() -> Dict[str, Any]:
+    def stoploss_space() -> List[Dimension]:
         """
-        Stoploss Value to search
+        Stoploss search space
         """
-        return {
-            'stoploss': hp.quniform('stoploss', -0.5, -0.02, 0.02),
-        }
+        return [
+            Real(-0.5, -0.02, name='stoploss'),
+        ]
 
     @staticmethod
-    def indicator_space() -> Dict[str, Any]:
+    def indicator_space() -> List[Dimension]:
         """
         Define your Hyperopt space for searching strategy parameters
         """
-        return {
-            'macd_below_zero': hp.choice('macd_below_zero', [
-                {'enabled': False},
-                {'enabled': True}
-            ]),
-            'mfi': hp.choice('mfi', [
-                {'enabled': False},
-                {'enabled': True, 'value': hp.quniform('mfi-value', 10, 25, 5)}
-            ]),
-            'fastd': hp.choice('fastd', [
-                {'enabled': False},
-                {'enabled': True, 'value': hp.quniform('fastd-value', 15, 45, 5)}
-            ]),
-            'adx': hp.choice('adx', [
-                {'enabled': False},
-                {'enabled': True, 'value': hp.quniform('adx-value', 20, 50, 5)}
-            ]),
-            'rsi': hp.choice('rsi', [
-                {'enabled': False},
-                {'enabled': True, 'value': hp.quniform('rsi-value', 20, 40, 5)}
-            ]),
-            'uptrend_long_ema': hp.choice('uptrend_long_ema', [
-                {'enabled': False},
-                {'enabled': True}
-            ]),
-            'uptrend_short_ema': hp.choice('uptrend_short_ema', [
-                {'enabled': False},
-                {'enabled': True}
-            ]),
-            'over_sar': hp.choice('over_sar', [
-                {'enabled': False},
-                {'enabled': True}
-            ]),
-            'green_candle': hp.choice('green_candle', [
-                {'enabled': False},
-                {'enabled': True}
-            ]),
-            'uptrend_sma': hp.choice('uptrend_sma', [
-                {'enabled': False},
-                {'enabled': True}
-            ]),
-            'trigger': hp.choice('trigger', [
-                {'type': 'lower_bb'},
-                {'type': 'lower_bb_tema'},
-                {'type': 'faststoch10'},
-                {'type': 'ao_cross_zero'},
-                {'type': 'ema3_cross_ema10'},
-                {'type': 'macd_cross_signal'},
-                {'type': 'sar_reversal'},
-                {'type': 'ht_sine'},
-                {'type': 'heiken_reversal_bull'},
-                {'type': 'di_cross'},
-            ]),
-        }
+        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:
         """
@@ -341,17 +210,17 @@ class Hyperopt(Backtesting):
             return True
         return False
 
-    def hyperopt_space(self) -> Dict[str, Any]:
+    def hyperopt_space(self) -> List[Dimension]:
         """
         Return the space to use during Hyperopt
         """
-        spaces = {}
+        spaces: List[Dimension] = []
         if self.has_space('buy'):
-            spaces = {**spaces, **Hyperopt.indicator_space()}
+            spaces += Hyperopt.indicator_space()
         if self.has_space('roi'):
-            spaces = {**spaces, **Hyperopt.roi_space()}
+            spaces += Hyperopt.roi_space()
         if self.has_space('stoploss'):
-            spaces = {**spaces, **Hyperopt.stoploss_space()}
+            spaces += Hyperopt.stoploss_space()
         return spaces
 
     @staticmethod
@@ -359,69 +228,32 @@ class Hyperopt(Backtesting):
         """
         Define the buy strategy parameters to be used by hyperopt
         """
-        def populate_buy_trend(dataframe: DataFrame) -> DataFrame:
+        def populate_buy_trend(dataframe: DataFrame, metadata: dict) -> DataFrame:
             """
             Buy strategy Hyperopt will build and use
             """
             conditions = []
             # GUARDS AND TRENDS
-            if 'uptrend_long_ema' in params and params['uptrend_long_ema']['enabled']:
-                conditions.append(dataframe['ema50'] > dataframe['ema100'])
-            if 'macd_below_zero' in params and params['macd_below_zero']['enabled']:
-                conditions.append(dataframe['macd'] < 0)
-            if 'uptrend_short_ema' in params and params['uptrend_short_ema']['enabled']:
-                conditions.append(dataframe['ema5'] > dataframe['ema10'])
-            if 'mfi' in params and params['mfi']['enabled']:
-                conditions.append(dataframe['mfi'] < params['mfi']['value'])
-            if 'fastd' in params and params['fastd']['enabled']:
-                conditions.append(dataframe['fastd'] < params['fastd']['value'])
-            if 'adx' in params and params['adx']['enabled']:
-                conditions.append(dataframe['adx'] > params['adx']['value'])
-            if 'rsi' in params and params['rsi']['enabled']:
-                conditions.append(dataframe['rsi'] < params['rsi']['value'])
-            if 'over_sar' in params and params['over_sar']['enabled']:
-                conditions.append(dataframe['close'] > dataframe['sar'])
-            if 'green_candle' in params and params['green_candle']['enabled']:
-                conditions.append(dataframe['close'] > dataframe['open'])
-            if 'uptrend_sma' in params and params['uptrend_sma']['enabled']:
-                prevsma = dataframe['sma'].shift(1)
-                conditions.append(dataframe['sma'] > prevsma)
+            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
-            triggers = {
-                'lower_bb': (
-                    dataframe['close'] < dataframe['bb_lowerband']
-                ),
-                'lower_bb_tema': (
-                    dataframe['tema'] < dataframe['bb_lowerband']
-                ),
-                'faststoch10': (qtpylib.crossed_above(
-                    dataframe['fastd'], 10.0
-                )),
-                'ao_cross_zero': (qtpylib.crossed_above(
-                    dataframe['ao'], 0.0
-                )),
-                'ema3_cross_ema10': (qtpylib.crossed_above(
-                    dataframe['ema3'], dataframe['ema10']
-                )),
-                'macd_cross_signal': (qtpylib.crossed_above(
+            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']
-                )),
-                'sar_reversal': (qtpylib.crossed_above(
+                ))
+            if params['trigger'] == 'sar_reversal':
+                conditions.append(qtpylib.crossed_above(
                     dataframe['close'], dataframe['sar']
-                )),
-                'ht_sine': (qtpylib.crossed_above(
-                    dataframe['htleadsine'], dataframe['htsine']
-                )),
-                'heiken_reversal_bull': (
-                    (qtpylib.crossed_above(dataframe['ha_close'], dataframe['ha_open'])) &
-                    (dataframe['ha_low'] == dataframe['ha_open'])
-                ),
-                'di_cross': (qtpylib.crossed_above(
-                    dataframe['plus_di'], dataframe['minus_di']
-                )),
-            }
-            conditions.append(triggers.get(params['trigger']['type']))
+                ))
 
             dataframe.loc[
                 reduce(lambda x, y: x & y, conditions),
@@ -431,153 +263,124 @@ class Hyperopt(Backtesting):
 
         return populate_buy_trend
 
-    def generate_optimizer(self, params: Dict) -> Dict:
+    def generate_optimizer(self, _params) -> Dict:
+        params = self.get_args(_params)
+
         if self.has_space('roi'):
-            self.analyze.strategy.minimal_roi = self.generate_roi_table(params)
+            self.strategy.minimal_roi = self.generate_roi_table(params)
 
         if self.has_space('buy'):
-            self.populate_buy_trend = self.buy_strategy_generator(params)
+            self.advise_buy = self.buy_strategy_generator(params)
 
         if self.has_space('stoploss'):
-            self.analyze.strategy.stoploss = params['stoploss']
+            self.strategy.stoploss = params['stoploss']
 
+        processed = load(TICKERDATA_PICKLE)
         results = self.backtest(
             {
                 'stake_amount': self.config['stake_amount'],
-                'processed': self.processed,
-                'realistic': self.config.get('realistic_simulation', False),
+                'processed': processed,
+                'position_stacking': self.config.get('position_stacking', True),
             }
         )
         result_explanation = self.format_results(results)
 
         total_profit = results.profit_percent.sum()
         trade_count = len(results.index)
-        trade_duration = results.duration.mean()
+        trade_duration = results.trade_duration.mean()
 
-        if trade_count == 0 or trade_duration > self.max_accepted_trade_duration:
-            print('.', end='')
+        if trade_count == 0:
             return {
-                'status': STATUS_FAIL,
-                'loss': float('inf')
+                'loss': MAX_LOSS,
+                'params': params,
+                'result': result_explanation,
             }
 
         loss = self.calculate_loss(total_profit, trade_count, trade_duration)
 
-        self.current_tries += 1
-
-        self.log_results(
-            {
-                'loss': loss,
-                'current_tries': self.current_tries,
-                'total_tries': self.total_tries,
-                'result': result_explanation,
-            }
-        )
-
         return {
             'loss': loss,
-            'status': STATUS_OK,
+            'params': params,
             'result': result_explanation,
         }
 
-    @staticmethod
-    def format_results(results: DataFrame) -> str:
+    def format_results(self, results: DataFrame) -> str:
         """
         Return the format result in a string
         """
-        return ('{:6d} trades. Avg profit {: 5.2f}%. '
-                'Total profit {: 11.8f} BTC ({:.4f}Σ%). Avg duration {:5.1f} mins.').format(
-                    len(results.index),
-                    results.profit_percent.mean() * 100.0,
-                    results.profit_BTC.sum(),
-                    results.profit_percent.sum(),
-                    results.duration.mean(),
+        trades = len(results.index)
+        avg_profit = results.profit_percent.mean() * 100.0
+        total_profit = results.profit_abs.sum()
+        stake_cur = self.config['stake_currency']
+        profit = results.profit_percent.sum()
+        duration = results.trade_duration.mean()
+
+        return (f'{trades:6d} trades. Avg profit {avg_profit: 5.2f}%. '
+                f'Total profit {total_profit: 11.8f} {stake_cur} '
+                f'({profit:.4f}Σ%). Avg duration {duration:5.1f} mins.')
+
+    def get_optimizer(self, cpu_count) -> Optimizer:
+        return Optimizer(
+            self.hyperopt_space(),
+            base_estimator="ET",
+            acq_optimizer="auto",
+            n_initial_points=30,
+            acq_optimizer_kwargs={'n_jobs': cpu_count}
+        )
+
+    def run_optimizer_parallel(self, parallel, asked) -> List:
+        return parallel(delayed(self.generate_optimizer)(v) for v in asked)
+
+    def load_previous_results(self):
+        """ read trials file if we have one """
+        if os.path.exists(self.trials_file) and os.path.getsize(self.trials_file) > 0:
+            self.trials = self.read_trials()
+            logger.info(
+                'Loaded %d previous evaluations from disk.',
+                len(self.trials)
             )
 
     def start(self) -> None:
-        timerange = Arguments.parse_timerange(self.config.get('timerange'))
+        timerange = Arguments.parse_timerange(None if self.config.get(
+            'timerange') is None else str(self.config.get('timerange')))
         data = load_data(
-            datadir=self.config.get('datadir'),
+            datadir=str(self.config.get('datadir')),
             pairs=self.config['exchange']['pair_whitelist'],
             ticker_interval=self.ticker_interval,
             timerange=timerange
         )
 
         if self.has_space('buy'):
-            self.analyze.populate_indicators = Hyperopt.populate_indicators
-        self.processed = self.tickerdata_to_dataframe(data)
+            self.strategy.advise_indicators = Hyperopt.populate_indicators  # type: ignore
+        dump(self.tickerdata_to_dataframe(data), TICKERDATA_PICKLE)
+        self.exchange = None  # type: ignore
+        self.load_previous_results()
 
-        if self.config.get('mongodb'):
-            logger.info('Using mongodb ...')
-            logger.info(
-                'Start scripts/start-mongodb.sh and start-hyperopt-worker.sh manually!'
-            )
-
-            db_name = 'freqtrade_hyperopt'
-            self.trials = MongoTrials(
-                arg='mongo://127.0.0.1:1234/{}/jobs'.format(db_name),
-                exp_key='exp1'
-            )
-        else:
-            logger.info('Preparing Trials..')
-            signal.signal(signal.SIGINT, self.signal_handler)
-            # read trials file if we have one
-            if os.path.exists(self.trials_file) and os.path.getsize(self.trials_file) > 0:
-                self.trials = self.read_trials()
-
-                self.current_tries = len(self.trials.results)
-                self.total_tries += self.current_tries
-                logger.info(
-                    'Continuing with trials. Current: %d, Total: %d',
-                    self.current_tries,
-                    self.total_tries
-                )
+        cpus = multiprocessing.cpu_count()
+        logger.info(f'Found {cpus} CPU cores. Let\'s make them scream!')
 
+        opt = self.get_optimizer(cpus)
+        EVALS = max(self.total_tries // cpus, 1)
         try:
-            best_parameters = fmin(
-                fn=self.generate_optimizer,
-                space=self.hyperopt_space(),
-                algo=tpe.suggest,
-                max_evals=self.total_tries,
-                trials=self.trials
-            )
+            with Parallel(n_jobs=cpus) as parallel:
+                for i in range(EVALS):
+                    asked = opt.ask(n_points=cpus)
+                    f_val = self.run_optimizer_parallel(parallel, asked)
+                    opt.tell(asked, [i['loss'] for i in f_val])
 
-            results = sorted(self.trials.results, key=itemgetter('loss'))
-            best_result = results[0]['result']
-
-        except ValueError:
-            best_parameters = {}
-            best_result = 'Sorry, Hyperopt was not able to find good parameters. Please ' \
-                          'try with more epochs (param: -e).'
-
-        # Improve best parameter logging display
-        if best_parameters:
-            best_parameters = space_eval(
-                self.hyperopt_space(),
-                best_parameters
-            )
-
-        logger.info('Best parameters:\n%s', json.dumps(best_parameters, indent=4))
-        if 'roi_t1' in best_parameters:
-            logger.info('ROI table:\n%s', self.generate_roi_table(best_parameters))
-
-        logger.info('Best Result:\n%s', best_result)
-
-        # Store trials result to file to resume next time
-        self.save_trials()
-
-    def signal_handler(self, sig, frame) -> None:
-        """
-        Hyperopt SIGINT handler
-        """
-        logger.info(
-            'Hyperopt received %s',
-            signal.Signals(sig).name
-        )
+                    self.trials += f_val
+                    for j in range(cpus):
+                        self.log_results({
+                            'loss': f_val[j]['loss'],
+                            'current_tries': i * cpus + j,
+                            'total_tries': self.total_tries,
+                            'result': f_val[j]['result'],
+                        })
+        except KeyboardInterrupt:
+            print('User interrupted..')
 
         self.save_trials()
         self.log_trials_result()
-        sys.exit(0)
 
 
 def start(args: Namespace) -> None:
@@ -588,18 +391,14 @@ def start(args: Namespace) -> None:
     """
 
     # Remove noisy log messages
-    logging.getLogger('hyperopt.mongoexp').setLevel(logging.WARNING)
     logging.getLogger('hyperopt.tpe').setLevel(logging.WARNING)
 
     # Initialize configuration
     # Monkey patch the configuration with hyperopt_conf.py
     configuration = Configuration(args)
     logger.info('Starting freqtrade in Hyperopt mode')
+    config = configuration.load_config()
 
-    optimize_config = hyperopt_optimize_conf()
-    config = configuration._load_common_config(optimize_config)
-    config = configuration._load_backtesting_config(config)
-    config = configuration._load_hyperopt_config(config)
     config['exchange']['key'] = ''
     config['exchange']['secret'] = ''
 

freqtrade/persistence.py

@@ -5,57 +5,131 @@ This module contains the class to persist trades into SQLite
 import logging
 from datetime import datetime
 from decimal import Decimal, getcontext
-from typing import Dict, Optional
+from typing import Any, Dict, Optional
 
 import arrow
 from sqlalchemy import (Boolean, Column, DateTime, Float, Integer, String,
-                        create_engine)
-from sqlalchemy.engine import Engine
+                        create_engine, inspect)
+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.pool import StaticPool
 
+from freqtrade import OperationalException
+
 logger = logging.getLogger(__name__)
 
-_CONF = {}
-_DECL_BASE = declarative_base()
+_DECL_BASE: Any = declarative_base()
+_SQL_DOCS_URL = 'http://docs.sqlalchemy.org/en/latest/core/engines.html#database-urls'
 
 
-def init(config: dict, engine: Optional[Engine] = None) -> None:
+def init(config: Dict) -> None:
     """
     Initializes this module with the given config,
     registers all known command handlers
     and starts polling for message updates
     :param config: config to use
-    :param engine: database engine for sqlalchemy (Optional)
     :return: None
     """
-    _CONF.update(config)
-    if not engine:
-        if _CONF.get('dry_run', False):
-            # the user wants dry run to use a DB
-            if _CONF.get('dry_run_db', False):
-                engine = create_engine('sqlite:///tradesv3.dry_run.sqlite')
-            # Otherwise dry run will store in memory
-            else:
-                engine = create_engine('sqlite://',
-                                       connect_args={'check_same_thread': False},
-                                       poolclass=StaticPool,
-                                       echo=False)
-        else:
-            engine = create_engine('sqlite:///tradesv3.sqlite')
+    db_url = config.get('db_url', None)
+    kwargs = {}
+
+    # Take care of thread ownership if in-memory db
+    if db_url == 'sqlite://':
+        kwargs.update({
+            'connect_args': {'check_same_thread': False},
+            'poolclass': StaticPool,
+            'echo': False,
+        })
+
+    try:
+        engine = create_engine(db_url, **kwargs)
+    except NoSuchModuleError:
+        raise OperationalException(f'Given value for db_url: \'{db_url}\' '
+                                   f'is no valid database URL! (See {_SQL_DOCS_URL})')
 
     session = scoped_session(sessionmaker(bind=engine, autoflush=True, autocommit=True))
     Trade.session = session()
     Trade.query = session.query_property()
     _DECL_BASE.metadata.create_all(engine)
+    check_migrate(engine)
 
-    # Clean dry_run DB
-    if _CONF.get('dry_run', False) and _CONF.get('dry_run_db', False):
+    # Clean dry_run DB if the db is not in-memory
+    if config.get('dry_run', False) and db_url != 'sqlite://':
         clean_dry_run_db()
 
 
+def has_column(columns, searchname: str) -> bool:
+    return len(list(filter(lambda x: x["name"] == searchname, columns))) == 1
+
+
+def get_column_def(columns, column: str, default: str) -> str:
+    return default if not has_column(columns, column) else column
+
+
+def check_migrate(engine) -> None:
+    """
+    Checks if migration is necessary and migrates if necessary
+    """
+    inspector = inspect(engine)
+
+    cols = inspector.get_columns('trades')
+    tabs = inspector.get_table_names()
+    table_back_name = 'trades_bak'
+    for i, table_back_name in enumerate(tabs):
+        table_back_name = f'trades_bak{i}'
+        logger.info(f'trying {table_back_name}')
+
+    # Check for latest column
+    if not has_column(cols, 'ticker_interval'):
+        fee_open = get_column_def(cols, 'fee_open', 'fee')
+        fee_close = get_column_def(cols, 'fee_close', 'fee')
+        open_rate_requested = get_column_def(cols, 'open_rate_requested', 'null')
+        close_rate_requested = get_column_def(cols, 'close_rate_requested', 'null')
+        stop_loss = get_column_def(cols, 'stop_loss', '0.0')
+        initial_stop_loss = get_column_def(cols, 'initial_stop_loss', '0.0')
+        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')
+        ticker_interval = get_column_def(cols, 'ticker_interval', 'null')
+
+        # Schema migration necessary
+        engine.execute(f"alter table trades rename to {table_back_name}")
+        # let SQLAlchemy create the schema as required
+        _DECL_BASE.metadata.create_all(engine)
+
+        # Copy data back - following the correct schema
+        engine.execute(f"""insert into trades
+                (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,
+                ticker_interval
+                )
+            select id, lower(exchange),
+                case
+                    when instr(pair, '_') != 0 then
+                    substr(pair,    instr(pair, '_') + 1) || '/' ||
+                    substr(pair, 1, instr(pair, '_') - 1)
+                    else pair
+                    end
+                pair,
+                is_open, {fee_open} fee_open, {fee_close} fee_close,
+                open_rate, {open_rate_requested} open_rate_requested, close_rate,
+                {close_rate_requested} close_rate_requested, close_profit,
+                stake_amount, amount, open_date, close_date, open_order_id,
+                {stop_loss} stop_loss, {initial_stop_loss} initial_stop_loss,
+                {max_rate} max_rate, {sell_reason} sell_reason, {strategy} strategy,
+                {ticker_interval} ticker_interval
+                from {table_back_name}
+             """)
+
+        # Reread columns - the above recreated the table!
+        inspector = inspect(engine)
+        cols = inspector.get_columns('trades')
+
+
 def cleanup() -> None:
     """
     Flushes all pending operations to disk.
@@ -83,26 +157,74 @@ class Trade(_DECL_BASE):
 
     id = Column(Integer, primary_key=True)
     exchange = Column(String, nullable=False)
-    pair = Column(String, nullable=False)
-    is_open = Column(Boolean, nullable=False, default=True)
-    fee = Column(Float, nullable=False, default=0.0)
+    pair = Column(String, nullable=False, index=True)
+    is_open = Column(Boolean, nullable=False, default=True, index=True)
+    fee_open = Column(Float, nullable=False, default=0.0)
+    fee_close = Column(Float, nullable=False, default=0.0)
     open_rate = Column(Float)
+    open_rate_requested = Column(Float)
     close_rate = Column(Float)
+    close_rate_requested = Column(Float)
     close_profit = Column(Float)
     stake_amount = Column(Float, nullable=False)
     amount = Column(Float)
     open_date = Column(DateTime, nullable=False, default=datetime.utcnow)
     close_date = Column(DateTime)
     open_order_id = Column(String)
+    # absolute value of the stop loss
+    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)
+    # absolute value of the highest reached price
+    max_rate = Column(Float, nullable=True, default=0.0)
+    sell_reason = Column(String, nullable=True)
+    strategy = Column(String, nullable=True)
+    ticker_interval = Column(Integer, nullable=True)
 
     def __repr__(self):
-        return 'Trade(id={}, pair={}, amount={:.8f}, open_rate={:.8f}, open_since={})'.format(
-            self.id,
-            self.pair,
-            self.amount,
-            self.open_rate,
-            arrow.get(self.open_date).humanize() if self.is_open else 'closed'
-        )
+        open_since = arrow.get(self.open_date).humanize() if self.is_open else 'closed'
+
+        return (f'Trade(id={self.id}, pair={self.pair}, amount={self.amount:.8f}, '
+                f'open_rate={self.open_rate:.8f}, open_since={open_since})')
+
+    def adjust_stop_loss(self, current_price: float, stoploss: float, initial: bool = False):
+        """this adjusts the stop loss to it's most recently observed setting"""
+
+        if initial and not (self.stop_loss is None or self.stop_loss == 0):
+            # Don't modify if called with initial and nothing to do
+            return
+
+        new_loss = float(current_price * (1 - abs(stoploss)))
+
+        # keeping track of the highest observed rate for this trade
+        if self.max_rate is None:
+            self.max_rate = current_price
+        else:
+            if current_price > self.max_rate:
+                self.max_rate = current_price
+
+        # no stop loss assigned yet
+        if not self.stop_loss:
+            logger.debug("assigning new stop loss")
+            self.stop_loss = new_loss
+            self.initial_stop_loss = new_loss
+
+        # 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
+                logger.debug("adjusted stop loss")
+            else:
+                logger.debug("keeping current stop loss")
+
+        logger.debug(
+            f"{self.pair} - current price {current_price:.8f}, "
+            f"bought at {self.open_rate:.8f} and calculated "
+            f"stop loss is at: {self.initial_stop_loss:.8f} initial "
+            f"stop at {self.stop_loss:.8f}. "
+            f"trailing stop loss saved us: "
+            f"{float(self.stop_loss) - float(self.initial_stop_loss):.8f} "
+            f"and max observed rate was {self.max_rate:.8f}")
 
     def update(self, order: Dict) -> None:
         """
@@ -110,23 +232,24 @@ class Trade(_DECL_BASE):
         :param order: order retrieved by exchange.get_order()
         :return: None
         """
+        order_type = order['type']
         # Ignore open and cancelled orders
-        if not order['closed'] or order['rate'] is None:
+        if order['status'] == 'open' or order['price'] is None:
             return
 
         logger.info('Updating trade (id=%d) ...', self.id)
 
         getcontext().prec = 8  # Bittrex do not go above 8 decimal
-        if order['type'] == 'LIMIT_BUY':
+        if order_type == 'limit' and order['side'] == 'buy':
             # Update open rate and actual amount
-            self.open_rate = Decimal(order['rate'])
+            self.open_rate = Decimal(order['price'])
             self.amount = Decimal(order['amount'])
             logger.info('LIMIT_BUY has been fulfilled for %s.', self)
             self.open_order_id = None
-        elif order['type'] == 'LIMIT_SELL':
-            self.close(order['rate'])
+        elif order_type == 'limit' and order['side'] == 'sell':
+            self.close(order['price'])
         else:
-            raise ValueError('Unknown order type: {}'.format(order['type']))
+            raise ValueError(f'Unknown order type: {order_type}')
         cleanup()
 
     def close(self, rate: float) -> None:
@@ -156,7 +279,7 @@ class Trade(_DECL_BASE):
         getcontext().prec = 8
 
         buy_trade = (Decimal(self.amount) * Decimal(self.open_rate))
-        fees = buy_trade * Decimal(fee or self.fee)
+        fees = buy_trade * Decimal(fee or self.fee_open)
         return float(buy_trade + fees)
 
     def calc_close_trade_price(
@@ -177,7 +300,7 @@ class Trade(_DECL_BASE):
             return 0.0
 
         sell_trade = (Decimal(self.amount) * Decimal(rate or self.close_rate))
-        fees = sell_trade * Decimal(fee or self.fee)
+        fees = sell_trade * Decimal(fee or self.fee_close)
         return float(sell_trade - fees)
 
     def calc_profit(
@@ -195,9 +318,10 @@ class Trade(_DECL_BASE):
         open_trade_price = self.calc_open_trade_price()
         close_trade_price = self.calc_close_trade_price(
             rate=(rate or self.close_rate),
-            fee=(fee or self.fee)
+            fee=(fee or self.fee_close)
         )
-        return float("{0:.8f}".format(close_trade_price - open_trade_price))
+        profit = close_trade_price - open_trade_price
+        return float(f"{profit:.8f}")
 
     def calc_profit_percent(
             self,
@@ -215,7 +339,7 @@ class Trade(_DECL_BASE):
         open_trade_price = self.calc_open_trade_price()
         close_trade_price = self.calc_close_trade_price(
             rate=(rate or self.close_rate),
-            fee=(fee or self.fee)
+            fee=(fee or self.fee_close)
         )
-
-        return float("{0:.8f}".format((close_trade_price / open_trade_price) - 1))
+        profit_percent = (close_trade_price / open_trade_price) - 1
+        return float(f"{profit_percent:.8f}")

freqtrade/rpc/__init__.py

@@ -0,0 +1,2 @@
+from .rpc import RPC, RPCMessageType, RPCException  # noqa
+from .rpc_manager import RPCManager  # noqa

freqtrade/rpc/rpc.py

@@ -2,124 +2,152 @@
 This module contains class to define a RPC communications
 """
 import logging
-from datetime import datetime, timedelta
+from abc import abstractmethod
+from datetime import timedelta, datetime, date
 from decimal import Decimal
-from typing import Tuple, Any
+from enum import Enum
+from typing import Dict, Any, List, Optional
 
 import arrow
 import sqlalchemy as sql
+from numpy import mean, nan_to_num
 from pandas import DataFrame
 
-from freqtrade import exchange
+from freqtrade.fiat_convert import CryptoToFiatConverter
 from freqtrade.misc import shorten_date
 from freqtrade.persistence import Trade
 from freqtrade.state import State
-
+from freqtrade.strategy.interface import SellType
 
 logger = logging.getLogger(__name__)
 
 
+class RPCMessageType(Enum):
+    STATUS_NOTIFICATION = 'status'
+    WARNING_NOTIFICATION = 'warning'
+    CUSTOM_NOTIFICATION = 'custom'
+    BUY_NOTIFICATION = 'buy'
+    SELL_NOTIFICATION = 'sell'
+
+    def __repr__(self):
+        return self.value
+
+
+class RPCException(Exception):
+    """
+    Should be raised with a rpc-formatted message in an _rpc_* method
+    if the required state is wrong, i.e.:
+
+    raise RPCException('*Status:* `no active trade`')
+    """
+    def __init__(self, message: str) -> None:
+        super().__init__(self)
+        self.message = message
+
+    def __str__(self):
+        return self.message
+
+
 class RPC(object):
     """
     RPC class can be used to have extra feature, like bot data, and access to DB data
     """
+    # Bind _fiat_converter if needed in each RPC handler
+    _fiat_converter: Optional[CryptoToFiatConverter] = None
+
     def __init__(self, freqtrade) -> None:
         """
         Initializes all enabled rpc modules
         :param freqtrade: Instance of a freqtrade bot
         :return: None
         """
-        self.freqtrade = freqtrade
+        self._freqtrade = freqtrade
 
-    def rpc_trade_status(self) -> Tuple[bool, Any]:
+    @property
+    def name(self) -> str:
+        """ Returns the lowercase name of the implementation """
+        return self.__class__.__name__.lower()
+
+    @abstractmethod
+    def cleanup(self) -> None:
+        """ Cleanup pending module resources """
+
+    @abstractmethod
+    def send_msg(self, msg: Dict[str, str]) -> None:
+        """ Sends a message to all registered rpc modules """
+
+    def _rpc_trade_status(self) -> List[Dict[str, Any]]:
         """
         Below follows the RPC backend it is prefixed with rpc_ to raise awareness that it is
         a remotely exposed function
-        :return:
         """
         # Fetch open trade
         trades = Trade.query.filter(Trade.is_open.is_(True)).all()
-        if self.freqtrade.state != State.RUNNING:
-            return True, '*Status:* `trader is not running`'
+        if self._freqtrade.state != State.RUNNING:
+            raise RPCException('trader is not running')
         elif not trades:
-            return True, '*Status:* `no active trade`'
+            raise RPCException('no active trade')
         else:
-            result = []
+            results = []
             for trade in trades:
                 order = None
                 if trade.open_order_id:
-                    order = exchange.get_order(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 = exchange.get_ticker(trade.pair, False)['bid']
+                current_rate = self._freqtrade.exchange.get_ticker(trade.pair, False)['bid']
                 current_profit = trade.calc_profit_percent(current_rate)
-                fmt_close_profit = '{:.2f}%'.format(
-                    round(trade.close_profit * 100, 2)
-                ) if trade.close_profit else None
-                message = "*Trade ID:* `{trade_id}`\n" \
-                          "*Current Pair:* [{pair}]({market_url})\n" \
-                          "*Open Since:* `{date}`\n" \
-                          "*Amount:* `{amount}`\n" \
-                          "*Open Rate:* `{open_rate:.8f}`\n" \
-                          "*Close Rate:* `{close_rate}`\n" \
-                          "*Current Rate:* `{current_rate:.8f}`\n" \
-                          "*Close Profit:* `{close_profit}`\n" \
-                          "*Current Profit:* `{current_profit:.2f}%`\n" \
-                          "*Open Order:* `{open_order}`"\
-                          .format(
+                fmt_close_profit = (f'{round(trade.close_profit * 100, 2):.2f}%'
+                                    if trade.close_profit else None)
+                results.append(dict(
                     trade_id=trade.id,
                     pair=trade.pair,
-                              market_url=exchange.get_pair_detail_url(trade.pair),
-                              date=arrow.get(trade.open_date).humanize(),
+                    market_url=self._freqtrade.exchange.get_pair_detail_url(trade.pair),
+                    date=arrow.get(trade.open_date),
                     open_rate=trade.open_rate,
                     close_rate=trade.close_rate,
                     current_rate=current_rate,
                     amount=round(trade.amount, 8),
                     close_profit=fmt_close_profit,
                     current_profit=round(current_profit * 100, 2),
-                              open_order='({} rem={:.8f})'.format(
-                                  order['type'], order['remaining']
+                    open_order='({} {} rem={:.8f})'.format(
+                      order['type'], order['side'], order['remaining']
                     ) if order else None,
-                          )
-                result.append(message)
-            return False, result
+                ))
+            return results
 
-    def rpc_status_table(self) -> Tuple[bool, Any]:
+    def _rpc_status_table(self) -> DataFrame:
         trades = Trade.query.filter(Trade.is_open.is_(True)).all()
-        if self.freqtrade.state != State.RUNNING:
-            return True, '*Status:* `trader is not running`'
+        if self._freqtrade.state != State.RUNNING:
+            raise RPCException('trader is not running')
         elif not trades:
-            return True, '*Status:* `no active order`'
+            raise RPCException('no active order')
         else:
             trades_list = []
             for trade in trades:
                 # calculate profit and send message to user
-                current_rate = exchange.get_ticker(trade.pair, False)['bid']
+                current_rate = self._freqtrade.exchange.get_ticker(trade.pair, False)['bid']
+                trade_perc = (100 * trade.calc_profit_percent(current_rate))
                 trades_list.append([
                     trade.id,
                     trade.pair,
                     shorten_date(arrow.get(trade.open_date).humanize(only_distance=True)),
-                    '{:.2f}%'.format(100 * trade.calc_profit_percent(current_rate))
+                    f'{trade_perc:.2f}%'
                 ])
 
             columns = ['ID', 'Pair', 'Since', 'Profit']
             df_statuses = DataFrame.from_records(trades_list, columns=columns)
             df_statuses = df_statuses.set_index(columns[0])
-            # The style used throughout is to return a tuple
-            # consisting of (error_occured?, result)
-            # Another approach would be to just return the
-            # result, or raise error
-            return False, df_statuses
+            return df_statuses
 
-    def rpc_daily_profit(
+    def _rpc_daily_profit(
             self, timescale: int,
-            stake_currency: str, fiat_display_currency: str) -> Tuple[bool, Any]:
+            stake_currency: str, fiat_display_currency: str) -> List[List[Any]]:
         today = datetime.utcnow().date()
-        profit_days = {}
+        profit_days: Dict[date, Dict] = {}
 
         if not (isinstance(timescale, int) and timescale > 0):
-            return True, '*Daily [n]:* `must be an integer greater than 0`'
+            raise RPCException('timescale must be an integer greater than 0')
 
-        fiat = self.freqtrade.fiat_converter
         for day in range(0, timescale):
             profitday = today - timedelta(days=day)
             trades = Trade.query \
@@ -130,11 +158,11 @@ class RPC(object):
                 .all()
             curdayprofit = sum(trade.calc_profit() for trade in trades)
             profit_days[profitday] = {
-                'amount': format(curdayprofit, '.8f'),
+                'amount': f'{curdayprofit:.8f}',
                 'trades': len(trades)
             }
 
-        stats = [
+        return [
             [
                 key,
                 '{value:.8f} {symbol}'.format(
@@ -142,11 +170,11 @@ class RPC(object):
                     symbol=stake_currency
                 ),
                 '{value:.3f} {symbol}'.format(
-                    value=fiat.convert_amount(
+                    value=self._fiat_converter.convert_amount(
                         value['amount'],
                         stake_currency,
                         fiat_display_currency
-                    ),
+                    ) if self._fiat_converter else 0,
                     symbol=fiat_display_currency
                 ),
                 '{value} trade{s}'.format(
@@ -156,13 +184,10 @@ class RPC(object):
             ]
             for key, value in profit_days.items()
         ]
-        return False, stats
 
-    def rpc_trade_statistics(
-            self, stake_currency: str, fiat_display_currency: str) -> Tuple[bool, Any]:
-        """
-        :return: cumulative profit statistics.
-        """
+    def _rpc_trade_statistics(
+            self, stake_currency: str, fiat_display_currency: str) -> Dict[str, Any]:
+        """ Returns cumulative profit statistics """
         trades = Trade.query.order_by(Trade.id).all()
 
         profit_all_coin = []
@@ -172,7 +197,7 @@ class RPC(object):
         durations = []
 
         for trade in trades:
-            current_rate = None
+            current_rate: float = 0.0
 
             if not trade.open_rate:
                 continue
@@ -185,7 +210,7 @@ class RPC(object):
                 profit_closed_percent.append(profit_percent)
             else:
                 # Get current rate
-                current_rate = exchange.get_ticker(trade.pair, False)['bid']
+                current_rate = self._freqtrade.exchange.get_ticker(trade.pair, False)['bid']
                 profit_percent = trade.calc_profit_percent(rate=current_rate)
 
             profit_all_coin.append(
@@ -200,36 +225,33 @@ class RPC(object):
             .order_by(sql.text('profit_sum DESC')).first()
 
         if not best_pair:
-            return True, '*Status:* `no closed trade`'
+            raise RPCException('no closed trade')
 
         bp_pair, bp_rate = best_pair
 
-        # FIX: we want to keep fiatconverter in a state/environment,
-        #      doing this will utilize its caching functionallity, instead we reinitialize it here
-        fiat = self.freqtrade.fiat_converter
         # Prepare data to display
-        profit_closed_coin = round(sum(profit_closed_coin), 8)
-        profit_closed_percent = round(sum(profit_closed_percent) * 100, 2)
-        profit_closed_fiat = fiat.convert_amount(
-            profit_closed_coin,
+        profit_closed_coin_sum = round(sum(profit_closed_coin), 8)
+        profit_closed_percent = round(nan_to_num(mean(profit_closed_percent)) * 100, 2)
+        profit_closed_fiat = self._fiat_converter.convert_amount(
+            profit_closed_coin_sum,
             stake_currency,
             fiat_display_currency
-        )
-        profit_all_coin = round(sum(profit_all_coin), 8)
-        profit_all_percent = round(sum(profit_all_percent) * 100, 2)
-        profit_all_fiat = fiat.convert_amount(
-            profit_all_coin,
+        ) if self._fiat_converter else 0
+
+        profit_all_coin_sum = round(sum(profit_all_coin), 8)
+        profit_all_percent = round(nan_to_num(mean(profit_all_percent)) * 100, 2)
+        profit_all_fiat = self._fiat_converter.convert_amount(
+            profit_all_coin_sum,
             stake_currency,
             fiat_display_currency
-        )
+        ) if self._fiat_converter else 0
+
         num = float(len(durations) or 1)
-        return (
-            False,
-            {
-                'profit_closed_coin': profit_closed_coin,
+        return {
+            'profit_closed_coin': profit_closed_coin_sum,
             'profit_closed_percent': profit_closed_percent,
             'profit_closed_fiat': profit_closed_fiat,
-                'profit_all_coin': profit_all_coin,
+            'profit_all_coin': profit_all_coin_sum,
             'profit_all_percent': profit_all_percent,
             'profit_all_fiat': profit_all_fiat,
             'trade_count': len(trades),
@@ -237,104 +259,107 @@ class RPC(object):
             'latest_trade_date': arrow.get(trades[-1].open_date).humanize(),
             'avg_duration': str(timedelta(seconds=sum(durations) / num)).split('.')[0],
             'best_pair': bp_pair,
-                'best_rate': round(bp_rate * 100, 2)
+            'best_rate': round(bp_rate * 100, 2),
         }
-        )
-
-    def rpc_balance(self, fiat_display_currency: str) -> Tuple[bool, Any]:
-        """
-        :return: current account balance per crypto
-        """
-        balances = [
-            c for c in exchange.get_balances()
-            if c['Balance'] or c['Available'] or c['Pending']
-        ]
-        if not balances:
-            return True, '`All balances are zero.`'
 
+    def _rpc_balance(self, fiat_display_currency: str) -> Dict:
+        """ Returns current account balance per crypto """
         output = []
         total = 0.0
-        for currency in balances:
-            coin = currency['Currency']
+        for coin, balance in self._freqtrade.exchange.get_balances().items():
+            if not balance['total']:
+                continue
+
             if coin == 'BTC':
-                currency["Rate"] = 1.0
+                rate = 1.0
             else:
                 if coin == 'USDT':
-                    currency["Rate"] = 1.0 / exchange.get_ticker('USDT_BTC', False)['bid']
+                    rate = 1.0 / self._freqtrade.exchange.get_ticker('BTC/USDT', False)['bid']
                 else:
-                    currency["Rate"] = exchange.get_ticker('BTC_' + coin, False)['bid']
-            currency['BTC'] = currency["Rate"] * currency["Balance"]
-            total = total + currency['BTC']
-            output.append(
-                {
-                    'currency': currency['Currency'],
-                    'available': currency['Available'],
-                    'balance': currency['Balance'],
-                    'pending': currency['Pending'],
-                    'est_btc': currency['BTC']
-                }
-            )
-        fiat = self.freqtrade.fiat_converter
+                    rate = self._freqtrade.exchange.get_ticker(coin + '/BTC', False)['bid']
+            est_btc: float = rate * balance['total']
+            total = total + est_btc
+            output.append({
+                'currency': coin,
+                'available': balance['free'],
+                'balance': balance['total'],
+                'pending': balance['used'],
+                'est_btc': est_btc,
+            })
+        if total == 0.0:
+            raise RPCException('all balances are zero')
+
         symbol = fiat_display_currency
-        value = fiat.convert_amount(total, 'BTC', symbol)
-        return False, (output, total, symbol, value)
+        value = self._fiat_converter.convert_amount(total, 'BTC',
+                                                    symbol) if self._fiat_converter else 0
+        return {
+            'currencies': output,
+            'total': total,
+            'symbol': symbol,
+            'value': value,
+        }
 
-    def rpc_start(self) -> (bool, str):
-        """
-        Handler for start.
-        """
-        if self.freqtrade.state == State.RUNNING:
-            return True, '*Status:* `already running`'
+    def _rpc_start(self) -> Dict[str, str]:
+        """ Handler for start """
+        if self._freqtrade.state == State.RUNNING:
+            return {'status': 'already running'}
 
-        self.freqtrade.state = State.RUNNING
-        return False, '`Starting trader ...`'
+        self._freqtrade.state = State.RUNNING
+        return {'status': 'starting trader ...'}
 
-    def rpc_stop(self) -> (bool, str):
-        """
-        Handler for stop.
-        """
-        if self.freqtrade.state == State.RUNNING:
-            self.freqtrade.state = State.STOPPED
-            return False, '`Stopping trader ...`'
+    def _rpc_stop(self) -> Dict[str, str]:
+        """ Handler for stop """
+        if self._freqtrade.state == State.RUNNING:
+            self._freqtrade.state = State.STOPPED
+            return {'status': 'stopping trader ...'}
 
-        return True, '*Status:* `already stopped`'
+        return {'status': 'already stopped'}
 
-    # FIX: no test for this!!!!
-    def rpc_forcesell(self, trade_id) -> Tuple[bool, Any]:
+    def _rpc_reload_conf(self) -> Dict[str, str]:
+        """ Handler for reload_conf. """
+        self._freqtrade.state = State.RELOAD_CONF
+        return {'status': 'reloading config ...'}
+
+    def _rpc_forcesell(self, trade_id) -> None:
         """
         Handler for forcesell <id>.
         Sells the given trade at current price
-        :return: error or None
         """
         def _exec_forcesell(trade: Trade) -> None:
             # Check if there is there is an open order
             if trade.open_order_id:
-                order = exchange.get_order(trade.open_order_id)
+                order = self._freqtrade.exchange.get_order(trade.open_order_id, trade.pair)
 
                 # Cancel open LIMIT_BUY orders and close trade
-                if order and not order['closed'] and order['type'] == 'LIMIT_BUY':
-                    exchange.cancel_order(trade.open_order_id)
-                    trade.close(order.get('rate') or trade.open_rate)
-                    # TODO: sell amount which has been bought already
+                if order and order['status'] == 'open' \
+                        and order['type'] == 'limit' \
+                        and order['side'] == 'buy':
+                    self._freqtrade.exchange.cancel_order(trade.open_order_id, trade.pair)
+                    trade.close(order.get('price') or trade.open_rate)
+                    # Do the best effort, if we don't know 'filled' amount, don't try selling
+                    if order['filled'] is None:
                         return
+                    trade.amount = order['filled']
 
                 # Ignore trades with an attached LIMIT_SELL order
-                if order and not order['closed'] and order['type'] == 'LIMIT_SELL':
+                if order and order['status'] == 'open' \
+                        and order['type'] == 'limit' \
+                        and order['side'] == 'sell':
                     return
 
             # Get current rate and execute sell
-            current_rate = exchange.get_ticker(trade.pair, False)['bid']
-            self.freqtrade.execute_sell(trade, current_rate)
+            current_rate = self._freqtrade.exchange.get_ticker(trade.pair, False)['bid']
+            self._freqtrade.execute_sell(trade, current_rate, SellType.FORCE_SELL)
         # ---- EOF def _exec_forcesell ----
 
-        if self.freqtrade.state != State.RUNNING:
-            return True, '`trader is not running`'
+        if self._freqtrade.state != State.RUNNING:
+            raise RPCException('trader is not running')
 
         if trade_id == 'all':
             # Execute sell for all open orders
             for trade in Trade.query.filter(Trade.is_open.is_(True)).all():
                 _exec_forcesell(trade)
-            return False, ''
+            return
 
         # Query for trade
         trade = Trade.query.filter(
@@ -345,18 +370,18 @@ class RPC(object):
         ).first()
         if not trade:
             logger.warning('forcesell: Invalid argument received')
-            return True, 'Invalid argument.'
+            raise RPCException('invalid argument')
 
         _exec_forcesell(trade)
-        return False, ''
+        Trade.session.flush()
 
-    def rpc_performance(self) -> Tuple[bool, Any]:
+    def _rpc_performance(self) -> List[Dict]:
         """
         Handler for performance.
         Shows a performance statistic from finished trades
         """
-        if self.freqtrade.state != State.RUNNING:
-            return True, '`trader is not running`'
+        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'),
@@ -365,19 +390,14 @@ class RPC(object):
             .group_by(Trade.pair) \
             .order_by(sql.text('profit_sum DESC')) \
             .all()
-        trades = []
-        for (pair, rate, count) in pair_rates:
-            trades.append({'pair': pair, 'profit': round(rate * 100, 2), 'count': count})
+        return [
+            {'pair': pair, 'profit': round(rate * 100, 2), 'count': count}
+            for pair, rate, count in pair_rates
+        ]
 
-        return False, trades
+    def _rpc_count(self) -> List[Trade]:
+        """ Returns the number of trades running """
+        if self._freqtrade.state != State.RUNNING:
+            raise RPCException('trader is not running')
 
-    def rpc_count(self) -> Tuple[bool, Any]:
-        """
-        Returns the number of trades running
-        :return: None
-        """
-        if self.freqtrade.state != State.RUNNING:
-            return True, '`trader is not running`'
-
-        trades = Trade.query.filter(Trade.is_open.is_(True)).all()
-        return False, trades
+        return Trade.query.filter(Trade.is_open.is_(True)).all()

freqtrade/rpc/rpc_manager.py

@@ -2,9 +2,9 @@
 This module contains class to manage RPC communications (Telegram, Slack, ...)
 """
 import logging
+from typing import List, Dict, Any
 
-from freqtrade.rpc.telegram import Telegram
-
+from freqtrade.rpc import RPC
 
 logger = logging.getLogger(__name__)
 
@@ -14,43 +14,40 @@ class RPCManager(object):
     Class to manage RPC objects (Telegram, Slack, ...)
     """
     def __init__(self, freqtrade) -> None:
-        """
-        Initializes all enabled rpc modules
-        :param config: config to use
-        :return: None
-        """
-        self.freqtrade = freqtrade
+        """ Initializes all enabled rpc modules """
+        self.registered_modules: List[RPC] = []
 
-        self.registered_modules = []
-        self.telegram = None
-        self._init()
-
-    def _init(self) -> None:
-        """
-        Init RPC modules
-        :return:
-        """
-        if self.freqtrade.config['telegram'].get('enabled', False):
+        # Enable telegram
+        if freqtrade.config['telegram'].get('enabled', False):
             logger.info('Enabling rpc.telegram ...')
-            self.registered_modules.append('telegram')
-            self.telegram = Telegram(self.freqtrade)
+            from freqtrade.rpc.telegram import Telegram
+            self.registered_modules.append(Telegram(freqtrade))
+
+        # Enable Webhook
+        if freqtrade.config.get('webhook', {}).get('enabled', False):
+            logger.info('Enabling rpc.webhook ...')
+            from freqtrade.rpc.webhook import Webhook
+            self.registered_modules.append(Webhook(freqtrade))
 
     def cleanup(self) -> None:
-        """
-        Stops all enabled rpc modules
-        :return: None
-        """
-        if 'telegram' in self.registered_modules:
-            logger.info('Cleaning up rpc.telegram ...')
-            self.registered_modules.remove('telegram')
-            self.telegram.cleanup()
+        """ Stops all enabled rpc modules """
+        logger.info('Cleaning up rpc modules ...')
+        while self.registered_modules:
+            mod = self.registered_modules.pop()
+            logger.debug('Cleaning up rpc.%s ...', mod.name)
+            mod.cleanup()
+            del mod
 
-    def send_msg(self, msg: str) -> None:
+    def send_msg(self, msg: Dict[str, Any]) -> None:
         """
-        Send given markdown message to all registered rpc modules
-        :param msg: message
-        :return: None
+        Send given message to all registered rpc modules.
+        A message consists of one or more key value pairs of strings.
+        e.g.:
+        {
+            'status': 'stopping bot'
+        }
         """
-        logger.info(msg)
-        if 'telegram' in self.registered_modules:
-            self.telegram.send_msg(msg)
+        logger.info('Sending rpc message: %s', msg)
+        for mod in self.registered_modules:
+            logger.debug('Forwarding message to rpc.%s', mod.name)
+            mod.send_msg(msg)

freqtrade/rpc/telegram.py

@@ -4,7 +4,7 @@
 This module manage Telegram communication
 """
 import logging
-from typing import Any, Callable
+from typing import Any, Callable, Dict
 
 from tabulate import tabulate
 from telegram import Bot, ParseMode, ReplyKeyboardMarkup, Update
@@ -12,22 +12,22 @@ from telegram.error import NetworkError, TelegramError
 from telegram.ext import CommandHandler, Updater
 
 from freqtrade.__init__ import __version__
-from freqtrade.rpc.rpc import RPC
-
+from freqtrade.fiat_convert import CryptoToFiatConverter
+from freqtrade.rpc import RPC, RPCException, RPCMessageType
 
 logger = logging.getLogger(__name__)
 
+logger.debug('Included module rpc.telegram ...')
 
-def authorized_only(command_handler: Callable[[Bot, Update], None]) -> Callable[..., Any]:
+
+def authorized_only(command_handler: Callable[[Any, Bot, Update], None]) -> Callable[..., Any]:
     """
     Decorator to check if the message comes from the correct chat_id
     :param command_handler: Telegram CommandHandler
     :return: decorated function
     """
     def wrapper(self, *args, **kwargs):
-        """
-        Decorator logic
-        """
+        """ Decorator logic """
         update = kwargs.get('update') or args[1]
 
         # Reject unauthorized messages
@@ -54,9 +54,8 @@ def authorized_only(command_handler: Callable[[Bot, Update], None]) -> Callable[
 
 
 class Telegram(RPC):
-    """
-    Telegram, this class send messages to Telegram
-    """
+    """  This class handles all telegram communication """
+
     def __init__(self, freqtrade) -> None:
         """
         Init the Telegram call, and init the super class RPC
@@ -65,21 +64,18 @@ class Telegram(RPC):
         """
         super().__init__(freqtrade)
 
-        self._updater = None
+        self._updater: Updater = None
         self._config = freqtrade.config
         self._init()
+        if self._config.get('fiat_display_currency', None):
+            self._fiat_converter = CryptoToFiatConverter()
 
     def _init(self) -> None:
         """
         Initializes this module with the given config,
         registers all known command handlers
         and starts polling for message updates
-        :param config: config to use
-        :return: None
         """
-        if not self.is_enabled():
-            return
-
         self._updater = Updater(token=self._config['telegram']['token'], workers=0)
 
         # Register command handler and start telegram message polling
@@ -93,6 +89,7 @@ class Telegram(RPC):
             CommandHandler('performance', self._performance),
             CommandHandler('daily', self._daily),
             CommandHandler('count', self._count),
+            CommandHandler('reload_conf', self._reload_conf),
             CommandHandler('help', self._help),
             CommandHandler('version', self._version),
         ]
@@ -114,16 +111,59 @@ class Telegram(RPC):
         Stops all running telegram threads.
         :return: None
         """
-        if not self.is_enabled():
-            return
-
         self._updater.stop()
 
-    def is_enabled(self) -> bool:
-        """
-        Returns True if the telegram module is activated, False otherwise
-        """
-        return bool(self._config.get('telegram', {}).get('enabled', False))
+    def send_msg(self, msg: Dict[str, Any]) -> None:
+        """ Send a message to telegram channel """
+
+        if msg['type'] == RPCMessageType.BUY_NOTIFICATION:
+            if self._fiat_converter:
+                msg['stake_amount_fiat'] = self._fiat_converter.convert_amount(
+                    msg['stake_amount'], msg['stake_currency'], msg['fiat_currency'])
+            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)
+
+            if msg.get('fiat_currency', None):
+                message += ",{stake_amount_fiat:.3f} {fiat_currency}".format(**msg)
+            message += ")`"
+
+        elif msg['type'] == RPCMessageType.SELL_NOTIFICATION:
+            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)
+
+            # Check if all sell properties are available.
+            # This might not be the case if the message origin is triggered by /forcesell
+            if (all(prop in msg for prop in ['gain', 'fiat_currency', 'stake_currency'])
+               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)
+
+        elif msg['type'] == RPCMessageType.STATUS_NOTIFICATION:
+            message = '*Status:* `{status}`'.format(**msg)
+
+        elif msg['type'] == RPCMessageType.WARNING_NOTIFICATION:
+            message = '*Warning:* `{status}`'.format(**msg)
+
+        elif msg['type'] == RPCMessageType.CUSTOM_NOTIFICATION:
+            message = '{status}'.format(**msg)
+
+        else:
+            raise NotImplementedError('Unknown message type: {}'.format(msg['type']))
+
+        self._send_msg(message)
 
     @authorized_only
     def _status(self, bot: Bot, update: Update) -> None:
@@ -142,13 +182,29 @@ class Telegram(RPC):
             self._status_table(bot, update)
             return
 
-        # Fetch open trade
-        (error, trades) = self.rpc_trade_status()
-        if error:
-            self.send_msg(trades, bot=bot)
-        else:
-            for trademsg in trades:
-                self.send_msg(trademsg, bot=bot)
+        try:
+            results = self._rpc_trade_status()
+            # pre format data
+            for result in results:
+                result['date'] = result['date'].humanize()
+
+            messages = [
+                "*Trade ID:* `{trade_id}`\n"
+                "*Current Pair:* [{pair}]({market_url})\n"
+                "*Open Since:* `{date}`\n"
+                "*Amount:* `{amount}`\n"
+                "*Open Rate:* `{open_rate:.8f}`\n"
+                "*Close Rate:* `{close_rate}`\n"
+                "*Current Rate:* `{current_rate:.8f}`\n"
+                "*Close Profit:* `{close_profit}`\n"
+                "*Current Profit:* `{current_profit:.2f}%`\n"
+                "*Open Order:* `{open_order}`".format(**result)
+                for result in results
+            ]
+            for msg in messages:
+                self._send_msg(msg, bot=bot)
+        except RPCException as e:
+            self._send_msg(str(e), bot=bot)
 
     @authorized_only
     def _status_table(self, bot: Bot, update: Update) -> None:
@@ -159,15 +215,12 @@ class Telegram(RPC):
         :param update: message update
         :return: None
         """
-        # Fetch open trade
-        (err, df_statuses) = self.rpc_status_table()
-        if err:
-            self.send_msg(df_statuses, bot=bot)
-        else:
+        try:
+            df_statuses = self._rpc_status_table()
             message = tabulate(df_statuses, headers='keys', tablefmt='simple')
-            message = "<pre>{}</pre>".format(message)
-
-            self.send_msg(message, parse_mode=ParseMode.HTML)
+            self._send_msg(f"<pre>{message}</pre>", parse_mode=ParseMode.HTML)
+        except RPCException as e:
+            self._send_msg(str(e), bot=bot)
 
     @authorized_only
     def _daily(self, bot: Bot, update: Update) -> None:
@@ -178,31 +231,29 @@ class Telegram(RPC):
         :param update: message update
         :return: None
         """
+        stake_cur = self._config['stake_currency']
+        fiat_disp_cur = self._config.get('fiat_display_currency', '')
         try:
             timescale = int(update.message.text.replace('/daily', '').strip())
         except (TypeError, ValueError):
             timescale = 7
-        (error, stats) = self.rpc_daily_profit(
+        try:
+            stats = self._rpc_daily_profit(
                 timescale,
-            self._config['stake_currency'],
-            self._config['fiat_display_currency']
+                stake_cur,
+                fiat_disp_cur
             )
-        if error:
-            self.send_msg(stats, bot=bot)
-        else:
             stats = tabulate(stats,
                              headers=[
                                  'Day',
-                                 'Profit {}'.format(self._config['stake_currency']),
-                                 'Profit {}'.format(self._config['fiat_display_currency'])
+                                 f'Profit {stake_cur}',
+                                 f'Profit {fiat_disp_cur}'
                              ],
                              tablefmt='simple')
-            message = '<b>Daily Profit over the last {} days</b>:\n<pre>{}</pre>'\
-                      .format(
-                          timescale,
-                          stats
-                      )
-            self.send_msg(message, bot=bot, parse_mode=ParseMode.HTML)
+            message = f'<b>Daily Profit over the last {timescale} days</b>:\n<pre>{stats}</pre>'
+            self._send_msg(message, bot=bot, parse_mode=ParseMode.HTML)
+        except RPCException as e:
+            self._send_msg(str(e), bot=bot)
 
     @authorized_only
     def _profit(self, bot: Bot, update: Update) -> None:
@@ -213,69 +264,61 @@ class Telegram(RPC):
         :param update: message update
         :return: None
         """
-        (error, stats) = self.rpc_trade_statistics(
-            self._config['stake_currency'],
-            self._config['fiat_display_currency']
-        )
-        if error:
-            self.send_msg(stats, bot=bot)
-            return
+        stake_cur = self._config['stake_currency']
+        fiat_disp_cur = self._config.get('fiat_display_currency', '')
 
+        try:
+            stats = self._rpc_trade_statistics(
+                stake_cur,
+                fiat_disp_cur)
+            profit_closed_coin = stats['profit_closed_coin']
+            profit_closed_percent = stats['profit_closed_percent']
+            profit_closed_fiat = stats['profit_closed_fiat']
+            profit_all_coin = stats['profit_all_coin']
+            profit_all_percent = stats['profit_all_percent']
+            profit_all_fiat = stats['profit_all_fiat']
+            trade_count = stats['trade_count']
+            first_trade_date = stats['first_trade_date']
+            latest_trade_date = stats['latest_trade_date']
+            avg_duration = stats['avg_duration']
+            best_pair = stats['best_pair']
+            best_rate = stats['best_rate']
             # Message to display
             markdown_msg = "*ROI:* Close trades\n" \
-                       "∙ `{profit_closed_coin:.8f} {coin} ({profit_closed_percent:.2f}%)`\n" \
-                       "∙ `{profit_closed_fiat:.3f} {fiat}`\n" \
-                       "*ROI:* All trades\n" \
-                       "∙ `{profit_all_coin:.8f} {coin} ({profit_all_percent:.2f}%)`\n" \
-                       "∙ `{profit_all_fiat:.3f} {fiat}`\n" \
-                       "*Total Trade Count:* `{trade_count}`\n" \
-                       "*First Trade opened:* `{first_trade_date}`\n" \
-                       "*Latest Trade opened:* `{latest_trade_date}`\n" \
-                       "*Avg. Duration:* `{avg_duration}`\n" \
-                       "*Best Performing:* `{best_pair}: {best_rate:.2f}%`"\
-                       .format(
-                           coin=self._config['stake_currency'],
-                           fiat=self._config['fiat_display_currency'],
-                           profit_closed_coin=stats['profit_closed_coin'],
-                           profit_closed_percent=stats['profit_closed_percent'],
-                           profit_closed_fiat=stats['profit_closed_fiat'],
-                           profit_all_coin=stats['profit_all_coin'],
-                           profit_all_percent=stats['profit_all_percent'],
-                           profit_all_fiat=stats['profit_all_fiat'],
-                           trade_count=stats['trade_count'],
-                           first_trade_date=stats['first_trade_date'],
-                           latest_trade_date=stats['latest_trade_date'],
-                           avg_duration=stats['avg_duration'],
-                           best_pair=stats['best_pair'],
-                           best_rate=stats['best_rate']
-                       )
-        self.send_msg(markdown_msg, bot=bot)
+                           f"∙ `{profit_closed_coin:.8f} {stake_cur} "\
+                           f"({profit_closed_percent:.2f}%)`\n" \
+                           f"∙ `{profit_closed_fiat:.3f} {fiat_disp_cur}`\n" \
+                           f"*ROI:* All trades\n" \
+                           f"∙ `{profit_all_coin:.8f} {stake_cur} ({profit_all_percent:.2f}%)`\n" \
+                           f"∙ `{profit_all_fiat:.3f} {fiat_disp_cur}`\n" \
+                           f"*Total Trade Count:* `{trade_count}`\n" \
+                           f"*First Trade opened:* `{first_trade_date}`\n" \
+                           f"*Latest Trade opened:* `{latest_trade_date}`\n" \
+                           f"*Avg. Duration:* `{avg_duration}`\n" \
+                           f"*Best Performing:* `{best_pair}: {best_rate:.2f}%`"
+            self._send_msg(markdown_msg, bot=bot)
+        except RPCException as e:
+            self._send_msg(str(e), bot=bot)
 
     @authorized_only
     def _balance(self, bot: Bot, update: Update) -> None:
-        """
-        Handler for /balance
-        """
-        (error, result) = self.rpc_balance(self._config['fiat_display_currency'])
-        if error:
-            self.send_msg('`All balances are zero.`')
-            return
-
-        (currencys, total, symbol, value) = result
+        """ Handler for /balance """
+        try:
+            result = self._rpc_balance(self._config.get('fiat_display_currency', ''))
             output = ''
-        for currency in currencys:
-            output += """*Currency*: {currency}
-    *Available*: {available}
-    *Balance*: {balance}
-    *Pending*: {pending}
-    *Est. BTC*: {est_btc: .8f}
-    """.format(**currency)
+            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)
 
-        output += """*Estimated Value*:
-    *BTC*: {0: .8f}
-    *{1}*: {2: .2f}
-    """.format(total, symbol, value)
-        self.send_msg(output)
+            output += "\n*Estimated Value*:\n" \
+                      "\t`BTC: {total: .8f}`\n" \
+                      "\t`{symbol}: {value: .2f}`\n".format(**result)
+            self._send_msg(output, bot=bot)
+        except RPCException as e:
+            self._send_msg(str(e), bot=bot)
 
     @authorized_only
     def _start(self, bot: Bot, update: Update) -> None:
@@ -286,9 +329,8 @@ class Telegram(RPC):
         :param update: message update
         :return: None
         """
-        (error, msg) = self.rpc_start()
-        if error:
-            self.send_msg(msg, bot=bot)
+        msg = self._rpc_start()
+        self._send_msg('Status: `{status}`'.format(**msg), bot=bot)
 
     @authorized_only
     def _stop(self, bot: Bot, update: Update) -> None:
@@ -299,8 +341,20 @@ class Telegram(RPC):
         :param update: message update
         :return: None
         """
-        (error, msg) = self.rpc_stop()
-        self.send_msg(msg, bot=bot)
+        msg = self._rpc_stop()
+        self._send_msg('Status: `{status}`'.format(**msg), bot=bot)
+
+    @authorized_only
+    def _reload_conf(self, bot: Bot, update: Update) -> None:
+        """
+        Handler for /reload_conf.
+        Triggers a config file reload
+        :param bot: telegram bot
+        :param update: message update
+        :return: None
+        """
+        msg = self._rpc_reload_conf()
+        self._send_msg('Status: `{status}`'.format(**msg), bot=bot)
 
     @authorized_only
     def _forcesell(self, bot: Bot, update: Update) -> None:
@@ -313,10 +367,10 @@ class Telegram(RPC):
         """
 
         trade_id = update.message.text.replace('/forcesell', '').strip()
-        (error, message) = self.rpc_forcesell(trade_id)
-        if error:
-            self.send_msg(message, bot=bot)
-            return
+        try:
+            self._rpc_forcesell(trade_id)
+        except RPCException as e:
+            self._send_msg(str(e), bot=bot)
 
     @authorized_only
     def _performance(self, bot: Bot, update: Update) -> None:
@@ -327,11 +381,8 @@ class Telegram(RPC):
         :param update: message update
         :return: None
         """
-        (error, trades) = self.rpc_performance()
-        if error:
-            self.send_msg(trades, bot=bot)
-            return
-
+        try:
+            trades = self._rpc_performance()
             stats = '\n'.join('{index}.\t<code>{pair}\t{profit:.2f}% ({count})</code>'.format(
                 index=i + 1,
                 pair=trade['pair'],
@@ -339,7 +390,9 @@ class Telegram(RPC):
                 count=trade['count']
             ) for i, trade in enumerate(trades))
             message = '<b>Performance:</b>\n{}'.format(stats)
-        self.send_msg(message, parse_mode=ParseMode.HTML)
+            self._send_msg(message, parse_mode=ParseMode.HTML)
+        except RPCException as e:
+            self._send_msg(str(e), bot=bot)
 
     @authorized_only
     def _count(self, bot: Bot, update: Update) -> None:
@@ -350,11 +403,8 @@ class Telegram(RPC):
         :param update: message update
         :return: None
         """
-        (error, trades) = self.rpc_count()
-        if error:
-            self.send_msg(trades, bot=bot)
-            return
-
+        try:
+            trades = self._rpc_count()
             message = tabulate({
                 'current': [len(trades)],
                 'max': [self._config['max_open_trades']],
@@ -362,7 +412,9 @@ class Telegram(RPC):
             }, headers=['current', 'max', 'total stake'], tablefmt='simple')
             message = "<pre>{}</pre>".format(message)
             logger.debug(message)
-        self.send_msg(message, parse_mode=ParseMode.HTML)
+            self._send_msg(message, parse_mode=ParseMode.HTML)
+        except RPCException as e:
+            self._send_msg(str(e), bot=bot)
 
     @authorized_only
     def _help(self, bot: Bot, update: Update) -> None:
@@ -388,7 +440,7 @@ class Telegram(RPC):
                   "*/help:* `This help message`\n" \
                   "*/version:* `Show version`"
 
-        self.send_msg(message, bot=bot)
+        self._send_msg(message, bot=bot)
 
     @authorized_only
     def _version(self, bot: Bot, update: Update) -> None:
@@ -399,9 +451,9 @@ class Telegram(RPC):
         :param update: message update
         :return: None
         """
-        self.send_msg('*Version:* `{}`'.format(__version__), bot=bot)
+        self._send_msg('*Version:* `{}`'.format(__version__), bot=bot)
 
-    def send_msg(self, msg: str, bot: Bot = None,
+    def _send_msg(self, msg: str, bot: Bot = None,
                   parse_mode: ParseMode = ParseMode.MARKDOWN) -> None:
         """
         Send given markdown message
@@ -410,9 +462,6 @@ class Telegram(RPC):
         :param parse_mode: telegram parse mode
         :return: None
         """
-        if not self.is_enabled():
-            return
-
         bot = bot or self._updater.bot
 
         keyboard = [['/daily', '/profit', '/balance'],

freqtrade/rpc/webhook.py

@@ -0,0 +1,66 @@
+"""
+This module manages webhook communication
+"""
+import logging
+from typing import Any,  Dict
+
+from requests import post, RequestException
+
+from freqtrade.rpc import RPC, RPCMessageType
+
+
+logger = logging.getLogger(__name__)
+
+logger.debug('Included module rpc.webhook ...')
+
+
+class Webhook(RPC):
+    """  This class handles all webhook communication """
+
+    def __init__(self, freqtrade) -> None:
+        """
+        Init the Webhook class, and init the super class RPC
+        :param freqtrade: Instance of a freqtrade bot
+        :return: None
+        """
+        super().__init__(freqtrade)
+
+        self._config = freqtrade.config
+        self._url = self._config['webhook']['url']
+
+    def cleanup(self) -> None:
+        """
+        Cleanup pending module resources.
+        This will do nothing for webhooks, they will simply not be called anymore
+        """
+        pass
+
+    def send_msg(self, msg: Dict[str, Any]) -> None:
+        """ Send a message to telegram channel """
+        try:
+
+            if msg['type'] == RPCMessageType.BUY_NOTIFICATION:
+                valuedict = self._config['webhook'].get('webhookbuy', None)
+            elif msg['type'] == RPCMessageType.SELL_NOTIFICATION:
+                valuedict = self._config['webhook'].get('webhooksell', None)
+            elif msg['type'] == RPCMessageType.STATUS_NOTIFICATION:
+                valuedict = self._config['webhook'].get('webhookstatus', None)
+            else:
+                raise NotImplementedError('Unknown message type: {}'.format(msg['type']))
+            if not valuedict:
+                logger.info("Message type %s not configured for webhooks", msg['type'])
+                return
+
+            payload = {key: value.format(**msg) for (key, value) in valuedict.items()}
+            self._send_msg(payload)
+        except KeyError as exc:
+            logger.exception("Problem calling Webhook. Please check your webhook configuration. "
+                             "Exception: %s", exc)
+
+    def _send_msg(self, payload: dict) -> None:
+        """do the actual call to the webhook"""
+
+        try:
+            post(self._url, data=payload)
+        except RequestException as exc:
+            logger.warning("Could not call webhook url. Exception: %s", exc)

freqtrade/state.py

@@ -8,7 +8,8 @@ import enum
 
 class State(enum.Enum):
     """
-    Bot running states
+    Bot application states
     """
     RUNNING = 0
     STOPPED = 1
+    RELOAD_CONF = 2

freqtrade/strategy/__init__.py

@@ -0,0 +1,32 @@
+import logging
+from copy import deepcopy
+
+from freqtrade.strategy.interface import IStrategy
+
+
+logger = logging.getLogger(__name__)
+
+
+def import_strategy(strategy: IStrategy, config: dict) -> IStrategy:
+    """
+    Imports given Strategy instance to global scope
+    of freqtrade.strategy and returns an instance of it
+    """
+    # Copy all attributes from base class and class
+    attr = deepcopy({**strategy.__class__.__dict__, **strategy.__dict__})
+    # Adjust module name
+    attr['__module__'] = 'freqtrade.strategy'
+
+    name = strategy.__class__.__name__
+    clazz = type(name, (IStrategy,), attr)
+
+    logger.debug(
+        'Imported strategy %s.%s as %s.%s',
+        strategy.__module__, strategy.__class__.__name__,
+        clazz.__module__, strategy.__class__.__name__,
+    )
+
+    # Modify global scope to declare class
+    globals()[name] = clazz
+
+    return clazz(config)

freqtrade/strategy/default_strategy.py

@@ -26,15 +26,18 @@ class DefaultStrategy(IStrategy):
     stoploss = -0.10
 
     # Optimal ticker interval for the strategy
-    ticker_interval = 5
+    ticker_interval = '5m'
 
-    def populate_indicators(self, dataframe: DataFrame) -> DataFrame:
+    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
         """
         Adds several different TA indicators to the given DataFrame
 
         Performance Note: For the best performance be frugal on the number of indicators
         you are using. Let uncomment only the indicator you are using in your strategies
         or your hyperopt configuration, otherwise you will waste your memory and CPU usage.
+        :param dataframe: Raw data from the exchange and parsed by parse_ticker_dataframe()
+        :param metadata: Additional information, like the currently traded pair
+        :return: a Dataframe with all mandatory indicators for the strategies
         """
 
         # Momentum Indicator
@@ -196,10 +199,11 @@ class DefaultStrategy(IStrategy):
 
         return dataframe
 
-    def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
+    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
+        :param metadata: Additional information, like the currently traded pair
         :return: DataFrame with buy column
         """
         dataframe.loc[
@@ -217,10 +221,11 @@ class DefaultStrategy(IStrategy):
 
         return dataframe
 
-    def populate_sell_trend(self, dataframe: DataFrame) -> DataFrame:
+    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
+        :param metadata: Additional information, like the currently traded pair
         :return: DataFrame with buy column
         """
         dataframe.loc[

freqtrade/strategy/interface.py

@@ -2,11 +2,50 @@
 IStrategy interface
 This module defines the interface to apply for strategies
 """
-
+import logging
 from abc import ABC, abstractmethod
+from datetime import datetime
+from enum import Enum
+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.persistence import Trade
+
+logger = logging.getLogger(__name__)
+
+
+class SignalType(Enum):
+    """
+    Enum to distinguish between buy and sell signals
+    """
+    BUY = "buy"
+    SELL = "sell"
+
+
+class SellType(Enum):
+    """
+    Enum to distinguish between sell reasons
+    """
+    ROI = "roi"
+    STOP_LOSS = "stop_loss"
+    TRAILING_STOP_LOSS = "trailing_stop_loss"
+    SELL_SIGNAL = "sell_signal"
+    FORCE_SELL = "force_sell"
+    NONE = ""
+
+
+class SellCheckTuple(NamedTuple):
+    """
+    NamedTuple for Sell type + reason
+    """
+    sell_flag: bool
+    sell_type: SellType
+
 
 class IStrategy(ABC):
     """
@@ -16,29 +55,270 @@ class IStrategy(ABC):
     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
+        ticker_interval -> str: value of the ticker interval to use for the strategy
     """
 
+    _populate_fun_len: int = 0
+    _buy_fun_len: int = 0
+    _sell_fun_len: int = 0
+    # associated minimal roi
+    minimal_roi: Dict
+
+    # associated stoploss
+    stoploss: float
+
+    # associated ticker interval
+    ticker_interval: str
+
+    def __init__(self, config: dict) -> None:
+        self.config = config
+
     @abstractmethod
-    def populate_indicators(self, dataframe: DataFrame) -> DataFrame:
+    def populate_indicators(self, 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()
+        :param metadata: Additional information, like the currently traded pair
         :return: a Dataframe with all mandatory indicators for the strategies
         """
 
     @abstractmethod
-    def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
+    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
+        :param metadata: Additional information, like the currently traded pair
         :return: DataFrame with buy column
         """
 
     @abstractmethod
-    def populate_sell_trend(self, dataframe: DataFrame) -> DataFrame:
+    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
+        :param metadata: Additional information, like the currently traded pair
         :return: DataFrame with sell column
         """
+
+    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:
+        """
+        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)
+        dataframe = self.advise_indicators(dataframe, metadata)
+        dataframe = self.advise_buy(dataframe, metadata)
+        dataframe = self.advise_sell(dataframe, metadata)
+        return dataframe
+
+    def get_signal(self, pair: str, interval: str, ticker_hist: List[Dict]) -> 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)
+        :return: (Buy, Sell) A bool-tuple indicating buy/sell signal
+        """
+        if not ticker_hist:
+            logger.warning('Empty ticker history for pair %s', pair)
+            return False, False
+
+        try:
+            dataframe = self.analyze_ticker(ticker_hist, {'pair': pair})
+        except ValueError as error:
+            logger.warning(
+                'Unable to analyze ticker for pair %s: %s',
+                pair,
+                str(error)
+            )
+            return False, False
+        except Exception as error:
+            logger.exception(
+                'Unexpected error when analyzing ticker for pair %s: %s',
+                pair,
+                str(error)
+            )
+            return False, False
+
+        if dataframe.empty:
+            logger.warning('Empty dataframe for pair %s', pair)
+            return False, False
+
+        latest = dataframe.iloc[-1]
+
+        # Check if dataframe is out of date
+        signal_date = arrow.get(latest['date'])
+        interval_minutes = constants.TICKER_INTERVAL_MINUTES[interval]
+        if signal_date < (arrow.utcnow().shift(minutes=-(interval_minutes * 2 + 5))):
+            logger.warning(
+                'Outdated history for pair %s. Last tick is %s minutes old',
+                pair,
+                (arrow.utcnow() - signal_date).seconds // 60
+            )
+            return False, False
+
+        (buy, sell) = latest[SignalType.BUY.value] == 1, latest[SignalType.SELL.value] == 1
+        logger.debug(
+            'trigger: %s (pair=%s) buy=%s sell=%s',
+            latest['date'],
+            pair,
+            str(buy),
+            str(sell)
+        )
+        return buy, sell
+
+    def should_sell(self, trade: Trade, rate: float, date: datetime, buy: bool,
+                    sell: bool) -> 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)
+        if stoplossflag.sell_flag:
+            return stoplossflag
+
+        experimental = self.config.get('experimental', {})
+
+        if buy and experimental.get('ignore_roi_if_buy_signal', False):
+            logger.debug('Buy signal still active - not selling.')
+            return SellCheckTuple(sell_flag=False, sell_type=SellType.NONE)
+
+        # Check if minimal roi has been reached and no longer in buy conditions (avoiding a fee)
+        if self.min_roi_reached(trade=trade, current_profit=current_profit, current_time=date):
+            logger.debug('Required profit reached. Selling..')
+            return SellCheckTuple(sell_flag=True, sell_type=SellType.ROI)
+
+        if experimental.get('sell_profit_only', False):
+            logger.debug('Checking if trade is profitable..')
+            if trade.calc_profit(rate=rate) <= 0:
+                return SellCheckTuple(sell_flag=False, sell_type=SellType.NONE)
+        if sell and not buy and experimental.get('use_sell_signal', False):
+            logger.debug('Sell signal received. Selling..')
+            return SellCheckTuple(sell_flag=True, sell_type=SellType.SELL_SIGNAL)
+
+        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:
+        """
+        Based on current profit of the trade and configured (trailing) stoploss,
+        decides to sell or not
+        :param current_profit: current profit in percent
+        """
+
+        trailing_stop = self.config.get('trailing_stop', False)
+
+        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:
+            selltype = SellType.STOP_LOSS
+            if trailing_stop:
+                selltype = SellType.TRAILING_STOP_LOSS
+                logger.debug(
+                    f"HIT STOP: current price at {current_rate:.6f}, "
+                    f"stop loss is {trade.stop_loss:.6f}, "
+                    f"initial stop loss was at {trade.initial_stop_loss:.6f}, "
+                    f"trade opened at {trade.open_rate:.6f}")
+                logger.debug(f"trailing stop saved {trade.stop_loss - trade.initial_stop_loss:.6f}")
+
+            logger.debug('Stop loss hit.')
+            return SellCheckTuple(sell_flag=True, sell_type=selltype)
+
+        # update the stop loss afterwards, after all by definition it's supposed to be hanging
+        if trailing_stop:
+
+            # check if we have a special stop loss for positive condition
+            # and if profit is positive
+            stop_loss_value = self.stoploss
+            sl_offset = self.config.get('trailing_stop_positive_offset', 0.0)
+
+            if 'trailing_stop_positive' in self.config and current_profit > sl_offset:
+
+                # Ignore mypy error check in configuration that this is a float
+                stop_loss_value = self.config.get('trailing_stop_positive')  # type: ignore
+                logger.debug(f"using positive stop loss mode: {stop_loss_value} "
+                             f"with offset {sl_offset:.4g} "
+                             f"since we have profit {current_profit:.4f}%")
+
+            trade.adjust_stop_loss(current_rate, stop_loss_value)
+
+        return SellCheckTuple(sell_flag=False, sell_type=SellType.NONE)
+
+    def min_roi_reached(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
+        :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
+
+        return False
+
+    def tickerdata_to_dataframe(self, tickerdata: Dict[str, List]) -> Dict[str, DataFrame]:
+        """
+        Creates a dataframe and populates indicators for given ticker data
+        """
+        return {pair: self.advise_indicators(parse_ticker_dataframe(pair_data), {'pair': pair})
+                for pair, pair_data in tickerdata.items()}
+
+    def advise_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        """
+        Populate indicators that will be used in the Buy and Sell strategy
+        This method should not be overridden.
+        :param dataframe: Raw data from the exchange and parsed by parse_ticker_dataframe()
+        :param metadata: Additional information, like the currently traded pair
+        :return: a Dataframe with all mandatory indicators for the strategies
+        """
+        if self._populate_fun_len == 2:
+            warnings.warn("deprecated - check out the Sample strategy to see "
+                          "the current function headers!", DeprecationWarning)
+            return self.populate_indicators(dataframe)  # type: ignore
+        else:
+            return self.populate_indicators(dataframe, metadata)
+
+    def advise_buy(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        """
+        Based on TA indicators, populates the buy signal for the given dataframe
+        This method should not be overridden.
+        :param dataframe: DataFrame
+        :param pair: Additional information, like the currently traded pair
+        :return: DataFrame with buy column
+        """
+        if self._buy_fun_len == 2:
+            warnings.warn("deprecated - check out the Sample strategy to see "
+                          "the current function headers!", DeprecationWarning)
+            return self.populate_buy_trend(dataframe)  # type: ignore
+        else:
+            return self.populate_buy_trend(dataframe, metadata)
+
+    def advise_sell(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+        """
+        Based on TA indicators, populates the sell signal for the given dataframe
+        This method should not be overridden.
+        :param dataframe: DataFrame
+        :param pair: Additional information, like the currently traded pair
+        :return: DataFrame with sell column
+        """
+        if self._sell_fun_len == 2:
+            warnings.warn("deprecated - check out the Sample strategy to see "
+                          "the current function headers!", DeprecationWarning)
+            return self.populate_sell_trend(dataframe)  # type: ignore
+        else:
+            return self.populate_sell_trend(dataframe, metadata)

freqtrade/strategy/resolver.py

@@ -7,13 +7,16 @@ import importlib.util
 import inspect
 import logging
 import os
+import tempfile
+from base64 import urlsafe_b64decode
 from collections import OrderedDict
-from typing import Optional, Dict, Type
+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__)
 
 
@@ -33,19 +36,25 @@ class StrategyResolver(object):
 
         # Verify the strategy is in the configuration, otherwise fallback to the default strategy
         strategy_name = config.get('strategy') or constants.DEFAULT_STRATEGY
-        self.strategy = self._load_strategy(strategy_name, extra_dir=config.get('strategy_path'))
+        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.")
+        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']
@@ -53,25 +62,27 @@ class StrategyResolver(object):
                 "Override strategy \'ticker_interval\' with value in config file: %s.",
                 config['ticker_interval']
             )
+        else:
+            config['ticker_interval'] = self.strategy.ticker_interval
 
         # 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.ticker_interval = int(self.strategy.ticker_interval)
 
     def _load_strategy(
-            self, strategy_name: str, extra_dir: Optional[str] = None) -> Optional[IStrategy]:
+            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(current_path, '..', '..', 'user_data', 'strategies'),
+            os.path.join(os.getcwd(), 'user_data', 'strategies'),
             current_path,
         ]
 
@@ -79,11 +90,37 @@ class StrategyResolver(object):
             # 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:
-            strategy = self._search_strategy(path, strategy_name)
+            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)
-                return strategy
+                    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"
@@ -100,9 +137,9 @@ class StrategyResolver(object):
         """
 
         # Generate spec based on absolute path
-        spec = importlib.util.spec_from_file_location('user_data.strategies', module_path)
+        spec = importlib.util.spec_from_file_location('unknown', module_path)
         module = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(module)
+        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)
@@ -111,7 +148,7 @@ class StrategyResolver(object):
         return next(valid_strategies_gen, None)
 
     @staticmethod
-    def _search_strategy(directory: str, strategy_name: str) -> Optional[IStrategy]:
+    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
@@ -127,5 +164,5 @@ class StrategyResolver(object):
                 os.path.abspath(os.path.join(directory, entry)), strategy_name
             )
             if strategy:
-                return strategy()
+                return strategy(config)
         return None

freqtrade/tests/conftest.py

@@ -3,29 +3,43 @@ import json
 import logging
 from datetime import datetime
 from functools import reduce
+from typing import Dict, Optional
 from unittest.mock import MagicMock
 
 import arrow
 import pytest
-from jsonschema import validate
-from sqlalchemy import create_engine
 from telegram import Chat, Message, Update
 
-from freqtrade.analyze import Analyze
-from freqtrade import constants
+from freqtrade.exchange.exchange_helpers import parse_ticker_dataframe
+from freqtrade.exchange import Exchange
 from freqtrade.freqtradebot import FreqtradeBot
 
 logging.getLogger('').setLevel(logging.INFO)
 
 
 def log_has(line, logs):
-    # caplog mocker returns log as a tuple: ('freqtrade.analyze', logging.WARNING, 'foobar')
+    # caplog mocker returns log as a tuple: ('freqtrade.something', logging.WARNING, 'foobar')
     # and we want to match line against foobar in the tuple
     return reduce(lambda a, b: a or b,
                   filter(lambda x: x[2] == line, logs),
                   False)
 
 
+def patch_exchange(mocker, api_mock=None) -> None:
+    mocker.patch('freqtrade.exchange.Exchange.validate_pairs', MagicMock())
+    mocker.patch('freqtrade.exchange.Exchange.validate_timeframes', MagicMock())
+    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)
+    exchange = Exchange(config)
+    return exchange
+
+
 # Functions for recurrent object patching
 def get_patched_freqtradebot(mocker, config) -> FreqtradeBot:
     """
@@ -34,16 +48,36 @@ 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})
-    mocker.patch('freqtrade.freqtradebot.Analyze', MagicMock())
+    # 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())
-    mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
+    patch_exchange(mocker, None)
     mocker.patch('freqtrade.freqtradebot.RPCManager._init', MagicMock())
     mocker.patch('freqtrade.freqtradebot.RPCManager.send_msg', MagicMock())
-    mocker.patch('freqtrade.freqtradebot.Analyze.get_signal', MagicMock())
 
-    return FreqtradeBot(config, create_engine('sqlite://'))
+    return FreqtradeBot(config)
+
+
+def patch_coinmarketcap(mocker, value: Optional[Dict[str, float]] = None) -> None:
+    """
+    Mocker to coinmarketcap to speed up tests
+    :param mocker: mocker to patch coinmarketcap class
+    :return: None
+    """
+
+    tickermock = MagicMock(return_value={'price_usd': 12345.0})
+    listmock = MagicMock(return_value={'data': [{'id': 1, 'name': 'Bitcoin', 'symbol': 'BTC',
+                                                 'website_slug': 'bitcoin'},
+                                                {'id': 1027, 'name': 'Ethereum', 'symbol': 'ETH',
+                                                 'website_slug': 'ethereum'}
+                                                ]})
+    mocker.patch.multiple(
+        'freqtrade.fiat_convert.Market',
+        ticker=tickermock,
+        listings=listmock,
+
+    )
 
 
 @pytest.fixture(scope="function")
@@ -54,7 +88,7 @@ def default_conf():
         "stake_currency": "BTC",
         "stake_amount": 0.001,
         "fiat_display_currency": "USD",
-        "ticker_interval": 5,
+        "ticker_interval": '5m',
         "dry_run": True,
         "minimal_roi": {
             "40": 0.0,
@@ -63,7 +97,10 @@ def default_conf():
             "0": 0.04
         },
         "stoploss": -0.10,
-        "unfilledtimeout": 600,
+        "unfilledtimeout": {
+            "buy": 10,
+            "sell": 30
+        },
         "bid_strategy": {
             "ask_last_balance": 0.0
         },
@@ -73,11 +110,10 @@ def default_conf():
             "key": "key",
             "secret": "secret",
             "pair_whitelist": [
-                "BTC_ETH",
-                "BTC_TKN",
-                "BTC_TRST",
-                "BTC_SWT",
-                "BTC_BCC"
+                "ETH/BTC",
+                "LTC/BTC",
+                "XRP/BTC",
+                "NEO/BTC"
             ]
         },
         "telegram": {
@@ -86,9 +122,9 @@ def default_conf():
             "chat_id": "0"
         },
         "initial_state": "running",
-        "loglevel": logging.DEBUG
+        "db_url": "sqlite://",
+        "loglevel": logging.DEBUG,
     }
-    validate(configuration, constants.CONF_SCHEMA)
     return configuration
 
 
@@ -99,6 +135,11 @@ def update():
     return _update
 
 
+@pytest.fixture
+def fee():
+    return MagicMock(return_value=0.0025)
+
+
 @pytest.fixture
 def ticker():
     return MagicMock(return_value={
@@ -127,46 +168,178 @@ def ticker_sell_down():
 
 
 @pytest.fixture
-def health():
-    return MagicMock(return_value=[{
-        'Currency': 'BTC',
-        'IsActive': True,
-        'LastChecked': '2017-11-13T20:15:00.00',
-        'Notice': None
-    }, {
-        'Currency': 'ETH',
-        'IsActive': True,
-        'LastChecked': '2017-11-13T20:15:00.00',
-        'Notice': None
-    }, {
-        'Currency': 'TRST',
-        'IsActive': True,
-        'LastChecked': '2017-11-13T20:15:00.00',
-        'Notice': None
-    }, {
-        'Currency': 'SWT',
-        'IsActive': True,
-        'LastChecked': '2017-11-13T20:15:00.00',
-        'Notice': None
-    }, {
-        'Currency': 'BCC',
-        'IsActive': False,
-        'LastChecked': '2017-11-13T20:15:00.00',
-        'Notice': None
-    }])
+def markets():
+    return MagicMock(return_value=[
+        {
+            'id': 'ethbtc',
+            'symbol': 'ETH/BTC',
+            'base': 'ETH',
+            'quote': 'BTC',
+            'active': True,
+            'precision': {
+                'price': 8,
+                'amount': 8,
+                'cost': 8,
+            },
+            'lot': 0.00000001,
+            'limits': {
+                'amount': {
+                    'min': 0.01,
+                    'max': 1000,
+                },
+                'price': 500000,
+                'cost': {
+                    'min': 1,
+                    'max': 500000,
+                },
+            },
+            'info': '',
+        },
+        {
+            'id': 'tknbtc',
+            'symbol': 'TKN/BTC',
+            'base': 'TKN',
+            'quote': 'BTC',
+            'active': True,
+            'precision': {
+                'price': 8,
+                'amount': 8,
+                'cost': 8,
+            },
+            'lot': 0.00000001,
+            'limits': {
+                'amount': {
+                    'min': 0.01,
+                    'max': 1000,
+                },
+                'price': 500000,
+                'cost': {
+                    'min': 1,
+                    'max': 500000,
+                },
+            },
+            'info': '',
+        },
+        {
+            'id': 'blkbtc',
+            'symbol': 'BLK/BTC',
+            'base': 'BLK',
+            'quote': 'BTC',
+            'active': True,
+            'precision': {
+                'price': 8,
+                'amount': 8,
+                'cost': 8,
+            },
+            'lot': 0.00000001,
+            'limits': {
+                'amount': {
+                    'min': 0.01,
+                    'max': 1000,
+                },
+                'price': 500000,
+                'cost': {
+                    'min': 1,
+                    'max': 500000,
+                },
+            },
+            'info': '',
+        },
+        {
+            'id': 'ltcbtc',
+            'symbol': 'LTC/BTC',
+            'base': 'LTC',
+            'quote': 'BTC',
+            'active': False,
+            'precision': {
+                'price': 8,
+                'amount': 8,
+                'cost': 8,
+            },
+            'lot': 0.00000001,
+            'limits': {
+                'amount': {
+                    'min': 0.01,
+                    'max': 1000,
+                },
+                'price': 500000,
+                'cost': {
+                    'min': 1,
+                    'max': 500000,
+                },
+            },
+            'info': '',
+        },
+        {
+            'id': 'xrpbtc',
+            'symbol': 'XRP/BTC',
+            'base': 'XRP',
+            'quote': 'BTC',
+            'active': False,
+            'precision': {
+                'price': 8,
+                'amount': 8,
+                'cost': 8,
+            },
+            'lot': 0.00000001,
+            'limits': {
+                'amount': {
+                    'min': 0.01,
+                    'max': 1000,
+                },
+                'price': 500000,
+                'cost': {
+                    'min': 1,
+                    'max': 500000,
+                },
+            },
+            'info': '',
+        },
+        {
+            'id': 'neobtc',
+            'symbol': 'NEO/BTC',
+            'base': 'NEO',
+            'quote': 'BTC',
+            'active': False,
+            'precision': {
+                'price': 8,
+                'amount': 8,
+                'cost': 8,
+            },
+            'lot': 0.00000001,
+            'limits': {
+                'amount': {
+                    'min': 0.01,
+                    'max': 1000,
+                },
+                'price': 500000,
+                'cost': {
+                    'min': 1,
+                    'max': 500000,
+                },
+            },
+            'info': '',
+        }
+    ])
 
 
 @pytest.fixture
+def markets_empty():
+    return MagicMock(return_value=[])
+
+
+@pytest.fixture(scope='function')
 def limit_buy_order():
     return {
         'id': 'mocked_limit_buy',
-        'type': 'LIMIT_BUY',
+        'type': 'limit',
+        'side': 'buy',
         'pair': 'mocked',
-        'opened': str(arrow.utcnow().datetime),
-        'rate': 0.00001099,
+        'datetime': arrow.utcnow().isoformat(),
+        'price': 0.00001099,
         'amount': 90.99181073,
         'remaining': 0.0,
-        'closed': str(arrow.utcnow().datetime),
+        'status': 'closed'
     }
 
 
@@ -174,12 +347,14 @@ def limit_buy_order():
 def limit_buy_order_old():
     return {
         'id': 'mocked_limit_buy_old',
-        'type': 'LIMIT_BUY',
-        'pair': 'BTC_ETH',
-        'opened': str(arrow.utcnow().shift(minutes=-601).datetime),
-        'rate': 0.00001099,
+        'type': 'limit',
+        'side': 'buy',
+        'pair': 'mocked',
+        'datetime': str(arrow.utcnow().shift(minutes=-601).datetime),
+        'price': 0.00001099,
         'amount': 90.99181073,
         'remaining': 90.99181073,
+        'status': 'open'
     }
 
 
@@ -187,12 +362,14 @@ def limit_buy_order_old():
 def limit_sell_order_old():
     return {
         'id': 'mocked_limit_sell_old',
-        'type': 'LIMIT_SELL',
-        'pair': 'BTC_ETH',
-        'opened': str(arrow.utcnow().shift(minutes=-601).datetime),
-        'rate': 0.00001099,
+        'type': 'limit',
+        'side': 'sell',
+        'pair': 'ETH/BTC',
+        'datetime': arrow.utcnow().shift(minutes=-601).isoformat(),
+        'price': 0.00001099,
         'amount': 90.99181073,
         'remaining': 90.99181073,
+        'status': 'open'
     }
 
 
@@ -200,12 +377,14 @@ def limit_sell_order_old():
 def limit_buy_order_old_partial():
     return {
         'id': 'mocked_limit_buy_old_partial',
-        'type': 'LIMIT_BUY',
-        'pair': 'BTC_ETH',
-        'opened': str(arrow.utcnow().shift(minutes=-601).datetime),
-        'rate': 0.00001099,
+        'type': 'limit',
+        'side': 'buy',
+        'pair': 'ETH/BTC',
+        'datetime': arrow.utcnow().shift(minutes=-601).isoformat(),
+        'price': 0.00001099,
         'amount': 90.99181073,
         'remaining': 67.99181073,
+        'status': 'open'
     }
 
 
@@ -213,85 +392,227 @@ def limit_buy_order_old_partial():
 def limit_sell_order():
     return {
         'id': 'mocked_limit_sell',
-        'type': 'LIMIT_SELL',
+        'type': 'limit',
+        'side': 'sell',
         'pair': 'mocked',
-        'opened': str(arrow.utcnow().datetime),
-        'rate': 0.00001173,
+        'datetime': arrow.utcnow().isoformat(),
+        'price': 0.00001173,
         'amount': 90.99181073,
         'remaining': 0.0,
-        'closed': str(arrow.utcnow().datetime),
+        'status': 'closed'
     }
 
 
 @pytest.fixture
 def ticker_history():
     return [
-        {
-            "O": 8.794e-05,
-            "H": 8.948e-05,
-            "L": 8.794e-05,
-            "C": 8.88e-05,
-            "V": 991.09056638,
-            "T": "2017-11-26T08:50:00",
-            "BV": 0.0877869
-        },
-        {
-            "O": 8.88e-05,
-            "H": 8.942e-05,
-            "L": 8.88e-05,
-            "C": 8.893e-05,
-            "V": 658.77935965,
-            "T": "2017-11-26T08:55:00",
-            "BV": 0.05874751
-        },
-        {
-            "O": 8.891e-05,
-            "H": 8.893e-05,
-            "L": 8.875e-05,
-            "C": 8.877e-05,
-            "V": 7920.73570705,
-            "T": "2017-11-26T09:00:00",
-            "BV": 0.7039405
-        }
+        [
+            1511686200000,  # unix timestamp ms
+            8.794e-05,  # open
+            8.948e-05,  # high
+            8.794e-05,  # low
+            8.88e-05,  # close
+            0.0877869,  # volume (in quote currency)
+        ],
+        [
+            1511686500000,
+            8.88e-05,
+            8.942e-05,
+            8.88e-05,
+            8.893e-05,
+            0.05874751,
+        ],
+        [
+            1511686800000,
+            8.891e-05,
+            8.893e-05,
+            8.875e-05,
+            8.877e-05,
+            0.7039405
+        ]
     ]
 
 
 @pytest.fixture
-def ticker_history_without_bv():
-    return [
-        {
-            "O": 8.794e-05,
-            "H": 8.948e-05,
-            "L": 8.794e-05,
-            "C": 8.88e-05,
-            "V": 991.09056638,
-            "T": "2017-11-26T08:50:00"
+def tickers():
+    return MagicMock(return_value={
+        'ETH/BTC': {
+            'symbol': 'ETH/BTC',
+            'timestamp': 1522014806207,
+            'datetime': '2018-03-25T21:53:26.207Z',
+            'high': 0.061697,
+            'low': 0.060531,
+            'bid': 0.061588,
+            'bidVolume': 3.321,
+            'ask': 0.061655,
+            'askVolume': 0.212,
+            'vwap': 0.06105296,
+            'open': 0.060809,
+            'close': 0.060761,
+            'first': None,
+            'last': 0.061588,
+            'change': 1.281,
+            'percentage': None,
+            'average': None,
+            'baseVolume': 111649.001,
+            'quoteVolume': 6816.50176926,
+            'info': {}
         },
-        {
-            "O": 8.88e-05,
-            "H": 8.942e-05,
-            "L": 8.88e-05,
-            "C": 8.893e-05,
-            "V": 658.77935965,
-            "T": "2017-11-26T08:55:00"
+        'TKN/BTC': {
+            'symbol': 'TKN/BTC',
+            'timestamp': 1522014806169,
+            'datetime': '2018-03-25T21:53:26.169Z',
+            'high': 0.01885,
+            'low': 0.018497,
+            'bid': 0.018799,
+            'bidVolume': 8.38,
+            'ask': 0.018802,
+            'askVolume': 15.0,
+            'vwap': 0.01869197,
+            'open': 0.018585,
+            'close': 0.018573,
+            'baseVolume': 81058.66,
+            'quoteVolume': 2247.48374509,
         },
-        {
-            "O": 8.891e-05,
-            "H": 8.893e-05,
-            "L": 8.875e-05,
-            "C": 8.877e-05,
-            "V": 7920.73570705,
-            "T": "2017-11-26T09:00:00"
+        'BLK/BTC': {
+            'symbol': 'BLK/BTC',
+            'timestamp': 1522014806072,
+            'datetime': '2018-03-25T21:53:26.720Z',
+            'high': 0.007745,
+            'low': 0.007512,
+            'bid': 0.007729,
+            'bidVolume': 0.01,
+            'ask': 0.007743,
+            'askVolume': 21.37,
+            'vwap': 0.00761466,
+            'open': 0.007653,
+            'close': 0.007652,
+            'first': None,
+            'last': 0.007743,
+            'change': 1.176,
+            'percentage': None,
+            'average': None,
+            'baseVolume': 295152.26,
+            'quoteVolume': 1515.14631229,
+            'info': {}
+        },
+        'LTC/BTC': {
+            'symbol': 'LTC/BTC',
+            'timestamp': 1523787258992,
+            'datetime': '2018-04-15T10:14:19.992Z',
+            'high': 0.015978,
+            'low': 0.0157,
+            'bid': 0.015954,
+            'bidVolume': 12.83,
+            'ask': 0.015957,
+            'askVolume': 0.49,
+            'vwap': 0.01581636,
+            'open': 0.015823,
+            'close': 0.01582,
+            'first': None,
+            'last': 0.015951,
+            'change': 0.809,
+            'percentage': None,
+            'average': None,
+            'baseVolume': 88620.68,
+            'quoteVolume': 1401.65697943,
+            'info': {}
+        },
+        'ETH/USDT': {
+            'symbol': 'ETH/USDT',
+            'timestamp': 1522014804118,
+            'datetime': '2018-03-25T21:53:24.118Z',
+            'high': 530.88,
+            'low': 512.0,
+            'bid': 529.73,
+            'bidVolume': 0.2,
+            'ask': 530.21,
+            'askVolume': 0.2464,
+            'vwap': 521.02438405,
+            'open': 527.27,
+            'close': 528.42,
+            'first': None,
+            'last': 530.21,
+            'change': 0.558,
+            'percentage': None,
+            'average': None,
+            'baseVolume': 72300.0659,
+            'quoteVolume': 37670097.3022171,
+            'info': {}
+        },
+        'TKN/USDT': {
+            'symbol': 'TKN/USDT',
+            'timestamp': 1522014806198,
+            'datetime': '2018-03-25T21:53:26.198Z',
+            'high': 8718.0,
+            'low': 8365.77,
+            'bid': 8603.64,
+            'bidVolume': 0.15846,
+            'ask': 8603.67,
+            'askVolume': 0.069147,
+            'vwap': 8536.35621697,
+            'open': 8680.0,
+            'close': 8680.0,
+            'first': None,
+            'last': 8603.67,
+            'change': -0.879,
+            'percentage': None,
+            'average': None,
+            'baseVolume': 30414.604298,
+            'quoteVolume': 259629896.48584127,
+            'info': {}
+        },
+        'BLK/USDT': {
+            'symbol': 'BLK/USDT',
+            'timestamp': 1522014806145,
+            'datetime': '2018-03-25T21:53:26.145Z',
+            'high': 66.95,
+            'low': 63.38,
+            'bid': 66.473,
+            'bidVolume': 4.968,
+            'ask': 66.54,
+            'askVolume': 2.704,
+            'vwap': 65.0526901,
+            'open': 66.43,
+            'close': 66.383,
+            'first': None,
+            'last': 66.5,
+            'change': 0.105,
+            'percentage': None,
+            'average': None,
+            'baseVolume': 294106.204,
+            'quoteVolume': 19132399.743954,
+            'info': {}
+        },
+        'LTC/USDT': {
+            'symbol': 'LTC/USDT',
+            'timestamp': 1523787257812,
+            'datetime': '2018-04-15T10:14:18.812Z',
+            'high': 129.94,
+            'low': 124.0,
+            'bid': 129.28,
+            'bidVolume': 0.03201,
+            'ask': 129.52,
+            'askVolume': 0.14529,
+            'vwap': 126.92838682,
+            'open': 127.0,
+            'close': 127.1,
+            'first': None,
+            'last': 129.28,
+            'change': 1.795,
+            'percentage': None,
+            'average': None,
+            'baseVolume': 59698.79897,
+            'quoteVolume': 29132399.743954,
+            'info': {}
         }
-    ]
+    })
 
 
-# FIX: Perhaps change result fixture to use BTC_UNITEST instead?
 @pytest.fixture
 def result():
-    with open('freqtrade/tests/testdata/BTC_ETH-1.json') as data_file:
-        return Analyze.parse_ticker_dataframe(json.load(data_file))
-
+    with open('freqtrade/tests/testdata/UNITTEST_BTC-1m.json') as data_file:
+        return parse_ticker_dataframe(json.load(data_file))
 
 # FIX:
 # Create an fixture/function
@@ -300,132 +621,88 @@ def result():
 # See tests in rpc/main that could use this
 
 
+@pytest.fixture(scope="function")
+def trades_for_order():
+    return [{'info': {'id': 34567,
+                      'orderId': 123456,
+                      'price': '0.24544100',
+                      'qty': '8.00000000',
+                      'commission': '0.00800000',
+                      'commissionAsset': 'LTC',
+                      'time': 1521663363189,
+                      'isBuyer': True,
+                      'isMaker': False,
+                      'isBestMatch': True},
+             'timestamp': 1521663363189,
+             'datetime': '2018-03-21T20:16:03.189Z',
+             'symbol': 'LTC/ETH',
+             'id': '34567',
+             'order': '123456',
+             'type': None,
+             'side': 'buy',
+             'price': 0.245441,
+             'cost': 1.963528,
+             'amount': 8.0,
+             'fee': {'cost': 0.008, 'currency': 'LTC'}}]
+
+
+@pytest.fixture(scope="function")
+def trades_for_order2():
+    return [{'info': {'id': 34567,
+                      'orderId': 123456,
+                      'price': '0.24544100',
+                      'qty': '8.00000000',
+                      'commission': '0.00800000',
+                      'commissionAsset': 'LTC',
+                      'time': 1521663363189,
+                      'isBuyer': True,
+                      'isMaker': False,
+                      'isBestMatch': True},
+             'timestamp': 1521663363189,
+             'datetime': '2018-03-21T20:16:03.189Z',
+             'symbol': 'LTC/ETH',
+             'id': '34567',
+             'order': '123456',
+             'type': None,
+             'side': 'buy',
+             'price': 0.245441,
+             'cost': 1.963528,
+             'amount': 4.0,
+             'fee': {'cost': 0.004, 'currency': 'LTC'}},
+            {'info': {'id': 34567,
+                      'orderId': 123456,
+                      'price': '0.24544100',
+                      'qty': '8.00000000',
+                      'commission': '0.00800000',
+                      'commissionAsset': 'LTC',
+                      'time': 1521663363189,
+                      'isBuyer': True,
+                      'isMaker': False,
+                      'isBestMatch': True},
+             'timestamp': 1521663363189,
+             'datetime': '2018-03-21T20:16:03.189Z',
+             'symbol': 'LTC/ETH',
+             'id': '34567',
+             'order': '123456',
+             'type': None,
+             'side': 'buy',
+             'price': 0.245441,
+             'cost': 1.963528,
+             'amount': 4.0,
+             'fee': {'cost': 0.004, 'currency': 'LTC'}}]
+
+
 @pytest.fixture
-def get_market_summaries_data():
-    """
-    This fixture is a real result from exchange.get_market_summaries() but reduced to only
-    8 entries. 4 BTC, 4 USTD
-    :return: JSON market summaries
-    """
-    return [
-        {
-            'Ask': 1.316e-05,
-            'BaseVolume': 5.72599471,
-            'Bid': 1.3e-05,
-            'Created': '2014-04-14T00:00:00',
-            'High': 1.414e-05,
-            'Last': 1.298e-05,
-            'Low': 1.282e-05,
-            'MarketName': 'BTC-XWC',
-            'OpenBuyOrders': 2000,
-            'OpenSellOrders': 1484,
-            'PrevDay': 1.376e-05,
-            'TimeStamp': '2018-02-05T01:32:40.493',
-            'Volume': 424041.21418375
-        },
-        {
-            'Ask': 0.00627051,
-            'BaseVolume': 93.23302388,
-            'Bid': 0.00618192,
-            'Created': '2016-10-20T04:48:30.387',
-            'High': 0.00669897,
-            'Last': 0.00618192,
-            'Low': 0.006,
-            'MarketName': 'BTC-XZC',
-            'OpenBuyOrders': 343,
-            'OpenSellOrders': 2037,
-            'PrevDay': 0.00668229,
-            'TimeStamp': '2018-02-05T01:32:43.383',
-            'Volume': 14863.60730702
-        },
-        {
-            'Ask': 0.01137247,
-            'BaseVolume': 383.55922657,
-            'Bid': 0.01136006,
-            'Created': '2016-11-15T20:29:59.73',
-            'High': 0.012,
-            'Last': 0.01137247,
-            'Low': 0.01119883,
-            'MarketName': 'BTC-ZCL',
-            'OpenBuyOrders': 1332,
-            'OpenSellOrders': 5317,
-            'PrevDay': 0.01179603,
-            'TimeStamp': '2018-02-05T01:32:42.773',
-            'Volume': 33308.07358285
-        },
-        {
-            'Ask': 0.04155821,
-            'BaseVolume': 274.75369074,
-            'Bid': 0.04130002,
-            'Created': '2016-10-28T17:13:10.833',
-            'High': 0.04354429,
-            'Last': 0.041585,
-            'Low': 0.0413,
-            'MarketName': 'BTC-ZEC',
-            'OpenBuyOrders': 863,
-            'OpenSellOrders': 5579,
-            'PrevDay': 0.0429,
-            'TimeStamp': '2018-02-05T01:32:43.21',
-            'Volume': 6479.84033259
-        },
-        {
-            'Ask': 210.99999999,
-            'BaseVolume': 615132.70989532,
-            'Bid': 210.05503736,
-            'Created': '2017-07-21T01:08:49.397',
-            'High': 257.396,
-            'Last': 211.0,
-            'Low': 209.05333589,
-            'MarketName': 'USDT-XMR',
-            'OpenBuyOrders': 180,
-            'OpenSellOrders': 1203,
-            'PrevDay': 247.93528899,
-            'TimeStamp': '2018-02-05T01:32:43.117',
-            'Volume': 2688.17410793
-        },
-        {
-            'Ask': 0.79589979,
-            'BaseVolume': 9349557.01853031,
-            'Bid': 0.789226,
-            'Created': '2017-07-14T17:10:10.737',
-            'High': 0.977,
-            'Last': 0.79589979,
-            'Low': 0.781,
-            'MarketName': 'USDT-XRP',
-            'OpenBuyOrders': 1075,
-            'OpenSellOrders': 6508,
-            'PrevDay': 0.93300218,
-            'TimeStamp': '2018-02-05T01:32:42.383',
-            'Volume': 10801663.00788851
-        },
-        {
-            'Ask': 0.05154982,
-            'BaseVolume': 2311087.71232136,
-            'Bid': 0.05040107,
-            'Created': '2017-12-29T19:29:18.357',
-            'High': 0.06668561,
-            'Last': 0.0508,
-            'Low': 0.05006731,
-            'MarketName': 'USDT-XVG',
-            'OpenBuyOrders': 655,
-            'OpenSellOrders': 5544,
-            'PrevDay': 0.0627,
-            'TimeStamp': '2018-02-05T01:32:41.507',
-            'Volume': 40031424.2152716
-        },
-        {
-            'Ask': 332.65500022,
-            'BaseVolume': 562911.87455665,
-            'Bid': 330.00000001,
-            'Created': '2017-07-14T17:10:10.673',
-            'High': 401.59999999,
-            'Last': 332.65500019,
-            'Low': 330.0,
-            'MarketName': 'USDT-ZEC',
-            'OpenBuyOrders': 161,
-            'OpenSellOrders': 1731,
-            'PrevDay': 391.42,
-            'TimeStamp': '2018-02-05T01:32:42.947',
-            'Volume': 1571.09647946
+def buy_order_fee():
+    return {
+        'id': 'mocked_limit_buy_old',
+        'type': 'limit',
+        'side': 'buy',
+        'pair': 'mocked',
+        'datetime': str(arrow.utcnow().shift(minutes=-601).datetime),
+        'price': 0.245441,
+        'amount': 8.0,
+        'remaining': 90.99181073,
+        'status': 'closed',
+        'fee': None
     }
-    ]

freqtrade/tests/exchange/test_exchange.py

@@ -1,286 +1,837 @@
 # pragma pylint: disable=missing-docstring, C0103, bad-continuation, global-statement
 # pragma pylint: disable=protected-access
 import logging
+from datetime import datetime
 from random import randint
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, PropertyMock
 
+import ccxt
 import pytest
-from requests.exceptions import RequestException
 
-import freqtrade.exchange as exchange
-from freqtrade import OperationalException
-from freqtrade.exchange import init, validate_pairs, buy, sell, get_balance, get_balances, \
-    get_ticker, get_ticker_history, cancel_order, get_name, get_fee
-from freqtrade.tests.conftest import log_has
-
-API_INIT = False
+from freqtrade import DependencyException, OperationalException, TemporaryError
+from freqtrade.exchange import API_RETRY_COUNT, Exchange
+from freqtrade.tests.conftest import get_patched_exchange, log_has
 
 
-def maybe_init_api(conf, mocker, force=False):
-    global API_INIT
-    if force or not API_INIT:
-        mocker.patch('freqtrade.exchange.validate_pairs',
-                     side_effect=lambda s: True)
-        init(config=conf)
-        API_INIT = True
+def ccxt_exceptionhandlers(mocker, default_conf, api_mock, fun, mock_ccxt_fun, **kwargs):
+    with pytest.raises(TemporaryError):
+        api_mock.__dict__[mock_ccxt_fun] = MagicMock(side_effect=ccxt.NetworkError)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        getattr(exchange, fun)(**kwargs)
+    assert api_mock.__dict__[mock_ccxt_fun].call_count == API_RETRY_COUNT + 1
+
+    with pytest.raises(OperationalException):
+        api_mock.__dict__[mock_ccxt_fun] = MagicMock(side_effect=ccxt.BaseError)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        getattr(exchange, fun)(**kwargs)
+    assert api_mock.__dict__[mock_ccxt_fun].call_count == 1
 
 
 def test_init(default_conf, mocker, caplog):
     caplog.set_level(logging.INFO)
-    maybe_init_api(default_conf, mocker, True)
+    get_patched_exchange(mocker, default_conf)
     assert log_has('Instance is running with dry_run enabled', caplog.record_tuples)
 
 
-def test_init_exception(default_conf):
+def test_init_exception(default_conf, mocker):
     default_conf['exchange']['name'] = 'wrong_exchange_name'
 
     with pytest.raises(
             OperationalException,
             match='Exchange {} is not supported'.format(default_conf['exchange']['name'])):
-        init(config=default_conf)
+        Exchange(default_conf)
+
+    default_conf['exchange']['name'] = 'binance'
+    with pytest.raises(
+            OperationalException,
+            match='Exchange {} is not supported'.format(default_conf['exchange']['name'])):
+        mocker.patch("ccxt.binance", MagicMock(side_effect=AttributeError))
+        Exchange(default_conf)
+
+
+def test_symbol_amount_prec(default_conf, mocker):
+    '''
+    Test rounds down to 4 Decimal places
+    '''
+    api_mock = MagicMock()
+    api_mock.load_markets = MagicMock(return_value={
+        'ETH/BTC': '', 'LTC/BTC': '', 'XRP/BTC': '', 'NEO/BTC': ''
+    })
+    mocker.patch('freqtrade.exchange.Exchange.name', PropertyMock(return_value='binance'))
+
+    markets = PropertyMock(return_value={'ETH/BTC': {'precision': {'amount': 4}}})
+    type(api_mock).markets = markets
+
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
+    mocker.patch('freqtrade.exchange.Exchange.validate_timeframes', MagicMock())
+    exchange = Exchange(default_conf)
+
+    amount = 2.34559
+    pair = 'ETH/BTC'
+    amount = exchange.symbol_amount_prec(pair, amount)
+    assert amount == 2.3455
+
+
+def test_symbol_price_prec(default_conf, mocker):
+    '''
+    Test rounds up to 4 decimal places
+    '''
+    api_mock = MagicMock()
+    api_mock.load_markets = MagicMock(return_value={
+        'ETH/BTC': '', 'LTC/BTC': '', 'XRP/BTC': '', 'NEO/BTC': ''
+    })
+    mocker.patch('freqtrade.exchange.Exchange.name', PropertyMock(return_value='binance'))
+
+    markets = PropertyMock(return_value={'ETH/BTC': {'precision': {'price': 4}}})
+    type(api_mock).markets = markets
+
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
+    mocker.patch('freqtrade.exchange.Exchange.validate_timeframes', MagicMock())
+    exchange = Exchange(default_conf)
+
+    price = 2.34559
+    pair = 'ETH/BTC'
+    price = exchange.symbol_price_prec(pair, price)
+    assert price == 2.3456
+
+
+def test_set_sandbox(default_conf, mocker):
+    """
+    Test working scenario
+    """
+    api_mock = MagicMock()
+    api_mock.load_markets = MagicMock(return_value={
+        'ETH/BTC': '', 'LTC/BTC': '', 'XRP/BTC': '', 'NEO/BTC': ''
+    })
+    url_mock = PropertyMock(return_value={'test': "api-public.sandbox.gdax.com",
+                                          'api': 'https://api.gdax.com'})
+    type(api_mock).urls = url_mock
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
+    mocker.patch('freqtrade.exchange.Exchange.validate_timeframes', MagicMock())
+
+    exchange = Exchange(default_conf)
+    liveurl = exchange._api.urls['api']
+    default_conf['exchange']['sandbox'] = True
+    exchange.set_sandbox(exchange._api, default_conf['exchange'], 'Logname')
+    assert exchange._api.urls['api'] != liveurl
+
+
+def test_set_sandbox_exception(default_conf, mocker):
+    """
+    Test Fail scenario
+    """
+    api_mock = MagicMock()
+    api_mock.load_markets = MagicMock(return_value={
+        'ETH/BTC': '', 'LTC/BTC': '', 'XRP/BTC': '', 'NEO/BTC': ''
+    })
+    url_mock = PropertyMock(return_value={'api': 'https://api.gdax.com'})
+    type(api_mock).urls = url_mock
+
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
+    mocker.patch('freqtrade.exchange.Exchange.validate_timeframes', MagicMock())
+
+    with pytest.raises(OperationalException, match=r'does not provide a sandbox api'):
+        exchange = Exchange(default_conf)
+        default_conf['exchange']['sandbox'] = True
+        exchange.set_sandbox(exchange._api, default_conf['exchange'], 'Logname')
 
 
 def test_validate_pairs(default_conf, mocker):
     api_mock = MagicMock()
-    api_mock.get_markets = MagicMock(return_value=[
-        'BTC_ETH', 'BTC_TKN', 'BTC_TRST', 'BTC_SWT', 'BTC_BCC',
-    ])
-    mocker.patch('freqtrade.exchange._API', api_mock)
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
-    validate_pairs(default_conf['exchange']['pair_whitelist'])
+    api_mock.load_markets = MagicMock(return_value={
+        'ETH/BTC': '', 'LTC/BTC': '', 'XRP/BTC': '', 'NEO/BTC': ''
+    })
+    id_mock = PropertyMock(return_value='test_exchange')
+    type(api_mock).id = id_mock
+
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
+    mocker.patch('freqtrade.exchange.Exchange.validate_timeframes', MagicMock())
+    Exchange(default_conf)
 
 
 def test_validate_pairs_not_available(default_conf, mocker):
     api_mock = MagicMock()
-    api_mock.get_markets = MagicMock(return_value=[])
-    mocker.patch('freqtrade.exchange._API', api_mock)
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
+    api_mock.load_markets = MagicMock(return_value={})
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
+    mocker.patch('freqtrade.exchange.Exchange.validate_timeframes', MagicMock())
+
     with pytest.raises(OperationalException, match=r'not available'):
-        validate_pairs(default_conf['exchange']['pair_whitelist'])
+        Exchange(default_conf)
 
 
 def test_validate_pairs_not_compatible(default_conf, mocker):
     api_mock = MagicMock()
-    api_mock.get_markets = MagicMock(
-        return_value=['BTC_ETH', 'BTC_TKN', 'BTC_TRST', 'BTC_SWT'])
+    api_mock.load_markets = MagicMock(return_value={
+        'ETH/BTC': '', 'TKN/BTC': '', 'TRST/BTC': '', 'SWT/BTC': '', 'BCC/BTC': ''
+    })
     default_conf['stake_currency'] = 'ETH'
-    mocker.patch('freqtrade.exchange._API', api_mock)
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
+    mocker.patch('freqtrade.exchange.Exchange.validate_timeframes', MagicMock())
     with pytest.raises(OperationalException, match=r'not compatible'):
-        validate_pairs(default_conf['exchange']['pair_whitelist'])
+        Exchange(default_conf)
 
 
 def test_validate_pairs_exception(default_conf, mocker, caplog):
     caplog.set_level(logging.INFO)
     api_mock = MagicMock()
-    api_mock.get_markets = MagicMock(side_effect=RequestException())
-    mocker.patch('freqtrade.exchange._API', api_mock)
+    mocker.patch('freqtrade.exchange.Exchange.name', PropertyMock(return_value='Binance'))
 
-    # with pytest.raises(RequestException, match=r'Unable to validate pairs'):
-    validate_pairs(default_conf['exchange']['pair_whitelist'])
+    api_mock.load_markets = MagicMock(return_value={})
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', api_mock)
+    mocker.patch('freqtrade.exchange.Exchange.validate_timeframes', MagicMock())
+
+    with pytest.raises(OperationalException, match=r'Pair ETH/BTC is not available at Binance'):
+        Exchange(default_conf)
+
+    api_mock.load_markets = MagicMock(side_effect=ccxt.BaseError())
+
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
+    Exchange(default_conf)
     assert log_has('Unable to validate pairs (assuming they are correct). Reason: ',
                    caplog.record_tuples)
 
 
+def test_validate_pairs_stake_exception(default_conf, mocker, caplog):
+    caplog.set_level(logging.INFO)
+    default_conf['stake_currency'] = 'ETH'
+    api_mock = MagicMock()
+    api_mock.name = MagicMock(return_value='binance')
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', api_mock)
+    mocker.patch('freqtrade.exchange.Exchange.validate_timeframes', MagicMock())
+
+    with pytest.raises(
+        OperationalException,
+        match=r'Pair ETH/BTC not compatible with stake_currency: ETH'
+    ):
+        Exchange(default_conf)
+
+
+def test_validate_timeframes(default_conf, mocker):
+    default_conf["ticker_interval"] = "5m"
+    api_mock = MagicMock()
+    id_mock = PropertyMock(return_value='test_exchange')
+    type(api_mock).id = id_mock
+    timeframes = PropertyMock(return_value={'1m': '1m',
+                                            '5m': '5m',
+                                            '15m': '15m',
+                                            '1h': '1h'})
+    type(api_mock).timeframes = timeframes
+
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
+    mocker.patch('freqtrade.exchange.Exchange.validate_pairs', MagicMock())
+    Exchange(default_conf)
+
+
+def test_validate_timeframes_failed(default_conf, mocker):
+    default_conf["ticker_interval"] = "3m"
+    api_mock = MagicMock()
+    id_mock = PropertyMock(return_value='test_exchange')
+    type(api_mock).id = id_mock
+    timeframes = PropertyMock(return_value={'1m': '1m',
+                                            '5m': '5m',
+                                            '15m': '15m',
+                                            '1h': '1h'})
+    type(api_mock).timeframes = timeframes
+
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
+    mocker.patch('freqtrade.exchange.Exchange.validate_pairs', MagicMock())
+    with pytest.raises(OperationalException, match=r'Invalid ticker 3m, this Exchange supports.*'):
+        Exchange(default_conf)
+
+
+def test_validate_timeframes_not_in_config(default_conf, mocker):
+    del default_conf["ticker_interval"]
+    api_mock = MagicMock()
+    id_mock = PropertyMock(return_value='test_exchange')
+    type(api_mock).id = id_mock
+    timeframes = PropertyMock(return_value={'1m': '1m',
+                                            '5m': '5m',
+                                            '15m': '15m',
+                                            '1h': '1h'})
+    type(api_mock).timeframes = timeframes
+
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
+    mocker.patch('freqtrade.exchange.Exchange.validate_pairs', MagicMock())
+    Exchange(default_conf)
+
+
+def test_exchange_has(default_conf, mocker):
+    exchange = get_patched_exchange(mocker, default_conf)
+    assert not exchange.exchange_has('ASDFASDF')
+    api_mock = MagicMock()
+
+    type(api_mock).has = PropertyMock(return_value={'deadbeef': True})
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+    assert exchange.exchange_has("deadbeef")
+
+    type(api_mock).has = PropertyMock(return_value={'deadbeef': False})
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+    assert not exchange.exchange_has("deadbeef")
+
+
 def test_buy_dry_run(default_conf, mocker):
     default_conf['dry_run'] = True
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
+    exchange = get_patched_exchange(mocker, default_conf)
 
-    assert 'dry_run_buy_' in buy(pair='BTC_ETH', rate=200, amount=1)
+    order = exchange.buy(pair='ETH/BTC', rate=200, amount=1)
+    assert 'id' in order
+    assert 'dry_run_buy_' in order['id']
 
 
 def test_buy_prod(default_conf, mocker):
     api_mock = MagicMock()
-    api_mock.buy = MagicMock(
-        return_value='dry_run_buy_{}'.format(randint(0, 10**6)))
-    mocker.patch('freqtrade.exchange._API', api_mock)
-
+    order_id = 'test_prod_buy_{}'.format(randint(0, 10 ** 6))
+    api_mock.create_limit_buy_order = MagicMock(return_value={
+        'id': order_id,
+        'info': {
+            'foo': 'bar'
+        }
+    })
     default_conf['dry_run'] = False
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
 
-    assert 'dry_run_buy_' in buy(pair='BTC_ETH', rate=200, amount=1)
+    order = exchange.buy(pair='ETH/BTC', rate=200, amount=1)
+    assert 'id' in order
+    assert 'info' in order
+    assert order['id'] == order_id
+
+    # test exception handling
+    with pytest.raises(DependencyException):
+        api_mock.create_limit_buy_order = MagicMock(side_effect=ccxt.InsufficientFunds)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.buy(pair='ETH/BTC', rate=200, amount=1)
+
+    with pytest.raises(DependencyException):
+        api_mock.create_limit_buy_order = MagicMock(side_effect=ccxt.InvalidOrder)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.buy(pair='ETH/BTC', rate=200, amount=1)
+
+    with pytest.raises(TemporaryError):
+        api_mock.create_limit_buy_order = MagicMock(side_effect=ccxt.NetworkError)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.buy(pair='ETH/BTC', rate=200, amount=1)
+
+    with pytest.raises(OperationalException):
+        api_mock.create_limit_buy_order = MagicMock(side_effect=ccxt.BaseError)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.buy(pair='ETH/BTC', rate=200, amount=1)
 
 
 def test_sell_dry_run(default_conf, mocker):
     default_conf['dry_run'] = True
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
+    exchange = get_patched_exchange(mocker, default_conf)
 
-    assert 'dry_run_sell_' in sell(pair='BTC_ETH', rate=200, amount=1)
+    order = exchange.sell(pair='ETH/BTC', rate=200, amount=1)
+    assert 'id' in order
+    assert 'dry_run_sell_' in order['id']
 
 
 def test_sell_prod(default_conf, mocker):
     api_mock = MagicMock()
-    api_mock.sell = MagicMock(
-        return_value='dry_run_sell_{}'.format(randint(0, 10**6)))
-    mocker.patch('freqtrade.exchange._API', api_mock)
-
+    order_id = 'test_prod_sell_{}'.format(randint(0, 10 ** 6))
+    api_mock.create_limit_sell_order = MagicMock(return_value={
+        'id': order_id,
+        'info': {
+            'foo': 'bar'
+        }
+    })
     default_conf['dry_run'] = False
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
 
-    assert 'dry_run_sell_' in sell(pair='BTC_ETH', rate=200, amount=1)
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+
+    order = exchange.sell(pair='ETH/BTC', rate=200, amount=1)
+    assert 'id' in order
+    assert 'info' in order
+    assert order['id'] == order_id
+
+    # test exception handling
+    with pytest.raises(DependencyException):
+        api_mock.create_limit_sell_order = MagicMock(side_effect=ccxt.InsufficientFunds)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.sell(pair='ETH/BTC', rate=200, amount=1)
+
+    with pytest.raises(DependencyException):
+        api_mock.create_limit_sell_order = MagicMock(side_effect=ccxt.InvalidOrder)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.sell(pair='ETH/BTC', rate=200, amount=1)
+
+    with pytest.raises(TemporaryError):
+        api_mock.create_limit_sell_order = MagicMock(side_effect=ccxt.NetworkError)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.sell(pair='ETH/BTC', rate=200, amount=1)
+
+    with pytest.raises(OperationalException):
+        api_mock.create_limit_sell_order = MagicMock(side_effect=ccxt.BaseError)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.sell(pair='ETH/BTC', rate=200, amount=1)
 
 
 def test_get_balance_dry_run(default_conf, mocker):
     default_conf['dry_run'] = True
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
 
-    assert get_balance(currency='BTC') == 999.9
+    exchange = get_patched_exchange(mocker, default_conf)
+    assert exchange.get_balance(currency='BTC') == 999.9
 
 
 def test_get_balance_prod(default_conf, mocker):
     api_mock = MagicMock()
-    api_mock.get_balance = MagicMock(return_value=123.4)
-    mocker.patch('freqtrade.exchange._API', api_mock)
-
+    api_mock.fetch_balance = MagicMock(return_value={'BTC': {'free': 123.4}})
     default_conf['dry_run'] = False
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
 
-    assert get_balance(currency='BTC') == 123.4
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+
+    assert exchange.get_balance(currency='BTC') == 123.4
+
+    with pytest.raises(OperationalException):
+        api_mock.fetch_balance = MagicMock(side_effect=ccxt.BaseError)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+
+        exchange.get_balance(currency='BTC')
+
+    with pytest.raises(TemporaryError, match=r'.*balance due to malformed exchange response:.*'):
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        mocker.patch('freqtrade.exchange.Exchange.get_balances', MagicMock(return_value={}))
+        exchange.get_balance(currency='BTC')
 
 
 def test_get_balances_dry_run(default_conf, mocker):
     default_conf['dry_run'] = True
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
-
-    assert get_balances() == []
+    exchange = get_patched_exchange(mocker, default_conf)
+    assert exchange.get_balances() == {}
 
 
 def test_get_balances_prod(default_conf, mocker):
     balance_item = {
-        'Currency': '1ST',
-        'Balance': 10.0,
-        'Available': 10.0,
-        'Pending': 0.0,
-        'CryptoAddress': None
+        'free': 10.0,
+        'total': 10.0,
+        'used': 0.0
     }
 
     api_mock = MagicMock()
-    api_mock.get_balances = MagicMock(
-        return_value=[balance_item, balance_item, balance_item])
-    mocker.patch('freqtrade.exchange._API', api_mock)
-
+    api_mock.fetch_balance = MagicMock(return_value={
+        '1ST': balance_item,
+        '2ST': balance_item,
+        '3ST': balance_item
+    })
     default_conf['dry_run'] = False
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+    assert len(exchange.get_balances()) == 3
+    assert exchange.get_balances()['1ST']['free'] == 10.0
+    assert exchange.get_balances()['1ST']['total'] == 10.0
+    assert exchange.get_balances()['1ST']['used'] == 0.0
 
-    assert len(get_balances()) == 3
-    assert get_balances()[0]['Currency'] == '1ST'
-    assert get_balances()[0]['Balance'] == 10.0
-    assert get_balances()[0]['Available'] == 10.0
-    assert get_balances()[0]['Pending'] == 0.0
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+                           "get_balances", "fetch_balance")
 
 
-# This test is somewhat redundant with
-# test_exchange_bittrex.py::test_exchange_bittrex_get_ticker
-def test_get_ticker(default_conf, mocker):
-    maybe_init_api(default_conf, mocker)
+def test_get_tickers(default_conf, mocker):
     api_mock = MagicMock()
-    tick = {"success": True, 'result': {'Bid': 0.00001098, 'Ask': 0.00001099, 'Last': 0.0001}}
-    api_mock.get_ticker = MagicMock(return_value=tick)
-    mocker.patch('freqtrade.exchange.bittrex._API', api_mock)
-
+    tick = {'ETH/BTC': {
+          'symbol': 'ETH/BTC',
+          'bid': 0.5,
+          'ask': 1,
+          'last': 42,
+      }, 'BCH/BTC': {
+          'symbol': 'BCH/BTC',
+          'bid': 0.6,
+          'ask': 0.5,
+          'last': 41,
+      }
+      }
+    api_mock.fetch_tickers = MagicMock(return_value=tick)
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
     # retrieve original ticker
-    ticker = get_ticker(pair='BTC_ETH')
+    tickers = exchange.get_tickers()
+
+    assert 'ETH/BTC' in tickers
+    assert 'BCH/BTC' in tickers
+    assert tickers['ETH/BTC']['bid'] == 0.5
+    assert tickers['ETH/BTC']['ask'] == 1
+    assert tickers['BCH/BTC']['bid'] == 0.6
+    assert tickers['BCH/BTC']['ask'] == 0.5
+
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+                           "get_tickers", "fetch_tickers")
+
+    with pytest.raises(OperationalException):
+        api_mock.fetch_tickers = MagicMock(side_effect=ccxt.NotSupported)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.get_tickers()
+
+    api_mock.fetch_tickers = MagicMock(return_value={})
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+    exchange.get_tickers()
+
+
+def test_get_ticker(default_conf, mocker):
+    api_mock = MagicMock()
+    tick = {
+        'symbol': 'ETH/BTC',
+        'bid': 0.00001098,
+        'ask': 0.00001099,
+        'last': 0.0001,
+    }
+    api_mock.fetch_ticker = MagicMock(return_value=tick)
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+    # retrieve original ticker
+    ticker = exchange.get_ticker(pair='ETH/BTC')
+
     assert ticker['bid'] == 0.00001098
     assert ticker['ask'] == 0.00001099
 
     # change the ticker
-    tick = {"success": True, 'result': {"Bid": 0.5, "Ask": 1, "Last": 42}}
-    api_mock.get_ticker = MagicMock(return_value=tick)
-    mocker.patch('freqtrade.exchange.bittrex._API', api_mock)
+    tick = {
+        'symbol': 'ETH/BTC',
+        'bid': 0.5,
+        'ask': 1,
+        'last': 42,
+    }
+    api_mock.fetch_ticker = MagicMock(return_value=tick)
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
 
     # if not caching the result we should get the same ticker
     # if not fetching a new result we should get the cached ticker
-    ticker = get_ticker(pair='BTC_ETH', refresh=False)
-    assert ticker['bid'] == 0.00001098
-    assert ticker['ask'] == 0.00001099
+    ticker = exchange.get_ticker(pair='ETH/BTC')
 
-    # force ticker refresh
-    ticker = get_ticker(pair='BTC_ETH', refresh=True)
+    assert api_mock.fetch_ticker.call_count == 1
     assert ticker['bid'] == 0.5
     assert ticker['ask'] == 1
 
+    assert 'ETH/BTC' in exchange._cached_ticker
+    assert exchange._cached_ticker['ETH/BTC']['bid'] == 0.5
+    assert exchange._cached_ticker['ETH/BTC']['ask'] == 1
 
-def test_get_ticker_history(default_conf, mocker):
+    # Test caching
+    api_mock.fetch_ticker = MagicMock()
+    exchange.get_ticker(pair='ETH/BTC', refresh=False)
+    assert api_mock.fetch_ticker.call_count == 0
+
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+                           "get_ticker", "fetch_ticker",
+                           pair='ETH/BTC', refresh=True)
+
+    api_mock.fetch_ticker = MagicMock(return_value={})
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+    exchange.get_ticker(pair='ETH/BTC', refresh=True)
+
+
+def make_fetch_ohlcv_mock(data):
+    def fetch_ohlcv_mock(pair, timeframe, since):
+        if since:
+            assert since > data[-1][0]
+            return []
+        return data
+    return fetch_ohlcv_mock
+
+
+def test_get_candle_history(default_conf, mocker):
     api_mock = MagicMock()
-    tick = 123
-    api_mock.get_ticker_history = MagicMock(return_value=tick)
-    mocker.patch('freqtrade.exchange._API', api_mock)
+    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 = get_ticker_history('BTC_ETH', int(default_conf['ticker_interval']))
-    assert ticks == 123
+    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 the ticker
-    tick = 999
-    api_mock.get_ticker_history = MagicMock(return_value=tick)
-    mocker.patch('freqtrade.exchange._API', api_mock)
+    # 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)
 
-    # ensure caching will still return the original ticker
-    ticks = get_ticker_history('BTC_ETH', int(default_conf['ticker_interval']))
-    assert ticks == 123
+    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()
+
+    # GDAX use-case (real data from GDAX)
+    # This ticker history is ordered DESC (newest first, oldest last)
+    tick = [
+        [1527833100000, 0.07666, 0.07671, 0.07666, 0.07668, 16.65244264],
+        [1527832800000, 0.07662, 0.07666, 0.07662, 0.07666, 1.30051526],
+        [1527832500000, 0.07656, 0.07661, 0.07656, 0.07661, 12.034778840000001],
+        [1527832200000, 0.07658, 0.07658, 0.07655, 0.07656, 0.59780186],
+        [1527831900000, 0.07658, 0.07658, 0.07658, 0.07658, 1.76278136],
+        [1527831600000, 0.07658, 0.07658, 0.07658, 0.07658, 2.22646521],
+        [1527831300000, 0.07655, 0.07657, 0.07655, 0.07657, 1.1753],
+        [1527831000000, 0.07654, 0.07654, 0.07651, 0.07651, 0.8073060299999999],
+        [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)
+
+    # Test the ticker history sort
+    ticks = exchange.get_candle_history('ETH/BTC', default_conf['ticker_interval'])
+    assert ticks[0][0] == 1527830400000
+    assert ticks[0][1] == 0.07649
+    assert ticks[0][2] == 0.07651
+    assert ticks[0][3] == 0.07649
+    assert ticks[0][4] == 0.07651
+    assert ticks[0][5] == 2.5734867
+
+    assert ticks[9][0] == 1527833100000
+    assert ticks[9][1] == 0.07666
+    assert ticks[9][2] == 0.07671
+    assert ticks[9][3] == 0.07666
+    assert ticks[9][4] == 0.07668
+    assert ticks[9][5] == 16.65244264
+
+    # Bittrex use-case (real data from Bittrex)
+    # This ticker history is ordered ASC (oldest first, newest last)
+    tick = [
+        [1527827700000, 0.07659999, 0.0766, 0.07627, 0.07657998, 1.85216924],
+        [1527828000000, 0.07657995, 0.07657995, 0.0763, 0.0763, 26.04051037],
+        [1527828300000, 0.0763, 0.07659998, 0.0763, 0.0764, 10.36434124],
+        [1527828600000, 0.0764, 0.0766, 0.0764, 0.0766, 5.71044773],
+        [1527828900000, 0.0764, 0.07666998, 0.0764, 0.07666998, 47.48888565],
+        [1527829200000, 0.0765, 0.07672999, 0.0765, 0.07672999, 3.37640326],
+        [1527829500000, 0.0766, 0.07675, 0.0765, 0.07675, 8.36203831],
+        [1527829800000, 0.07675, 0.07677999, 0.07620002, 0.076695, 119.22963884],
+        [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)
+    # Test the ticker history sort
+    ticks = exchange.get_candle_history('ETH/BTC', default_conf['ticker_interval'])
+    assert ticks[0][0] == 1527827700000
+    assert ticks[0][1] == 0.07659999
+    assert ticks[0][2] == 0.0766
+    assert ticks[0][3] == 0.07627
+    assert ticks[0][4] == 0.07657998
+    assert ticks[0][5] == 1.85216924
+
+    assert ticks[9][0] == 1527830400000
+    assert ticks[9][1] == 0.07671
+    assert ticks[9][2] == 0.07674399
+    assert ticks[9][3] == 0.07629216
+    assert ticks[9][4] == 0.07655213
+    assert ticks[9][5] == 2.31452783
 
 
 def test_cancel_order_dry_run(default_conf, mocker):
     default_conf['dry_run'] = True
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
-
-    assert cancel_order(order_id='123') is None
+    exchange = get_patched_exchange(mocker, default_conf)
+    assert exchange.cancel_order(order_id='123', pair='TKN/BTC') is None
 
 
 # Ensure that if not dry_run, we should call API
 def test_cancel_order(default_conf, mocker):
     default_conf['dry_run'] = False
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
     api_mock = MagicMock()
     api_mock.cancel_order = MagicMock(return_value=123)
-    mocker.patch('freqtrade.exchange._API', api_mock)
-    assert cancel_order(order_id='_') == 123
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+    assert exchange.cancel_order(order_id='_', pair='TKN/BTC') == 123
+
+    with pytest.raises(DependencyException):
+        api_mock.cancel_order = MagicMock(side_effect=ccxt.InvalidOrder)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.cancel_order(order_id='_', pair='TKN/BTC')
+    assert api_mock.cancel_order.call_count == API_RETRY_COUNT + 1
+
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+                           "cancel_order", "cancel_order",
+                           order_id='_', pair='TKN/BTC')
 
 
 def test_get_order(default_conf, mocker):
     default_conf['dry_run'] = True
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
     order = MagicMock()
     order.myid = 123
-    exchange._DRY_RUN_OPEN_ORDERS['X'] = order
-    print(exchange.get_order('X'))
-    assert exchange.get_order('X').myid == 123
+    exchange = get_patched_exchange(mocker, default_conf)
+    exchange._dry_run_open_orders['X'] = order
+    print(exchange.get_order('X', 'TKN/BTC'))
+    assert exchange.get_order('X', 'TKN/BTC').myid == 123
 
     default_conf['dry_run'] = False
-    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
     api_mock = MagicMock()
-    api_mock.get_order = MagicMock(return_value=456)
-    mocker.patch('freqtrade.exchange._API', api_mock)
-    assert exchange.get_order('X') == 456
+    api_mock.fetch_order = MagicMock(return_value=456)
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+    assert exchange.get_order('X', 'TKN/BTC') == 456
+
+    with pytest.raises(DependencyException):
+        api_mock.fetch_order = MagicMock(side_effect=ccxt.InvalidOrder)
+        exchange = get_patched_exchange(mocker, default_conf, api_mock)
+        exchange.get_order(order_id='_', pair='TKN/BTC')
+    assert api_mock.fetch_order.call_count == API_RETRY_COUNT + 1
+
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+                           'get_order', 'fetch_order',
+                           order_id='_', pair='TKN/BTC')
 
 
-def test_get_name(default_conf, mocker):
-    mocker.patch('freqtrade.exchange.validate_pairs',
+def test_name(default_conf, mocker):
+    mocker.patch('freqtrade.exchange.Exchange.validate_pairs',
                  side_effect=lambda s: True)
-    default_conf['exchange']['name'] = 'bittrex'
-    init(default_conf)
+    default_conf['exchange']['name'] = 'binance'
+    exchange = Exchange(default_conf)
 
-    assert get_name() == 'Bittrex'
+    assert exchange.name == 'Binance'
+
+
+def test_id(default_conf, mocker):
+    mocker.patch('freqtrade.exchange.Exchange.validate_pairs',
+                 side_effect=lambda s: True)
+    default_conf['exchange']['name'] = 'binance'
+    exchange = Exchange(default_conf)
+    assert exchange.id == 'binance'
+
+
+def test_get_pair_detail_url(default_conf, mocker, caplog):
+    mocker.patch('freqtrade.exchange.Exchange.validate_pairs',
+                 side_effect=lambda s: True)
+    default_conf['exchange']['name'] = 'binance'
+    exchange = Exchange(default_conf)
+
+    url = exchange.get_pair_detail_url('TKN/ETH')
+    assert 'TKN' in url
+    assert 'ETH' in url
+
+    url = exchange.get_pair_detail_url('LOOONG/BTC')
+    assert 'LOOONG' in url
+    assert 'BTC' in url
+
+    default_conf['exchange']['name'] = 'bittrex'
+    exchange = Exchange(default_conf)
+
+    url = exchange.get_pair_detail_url('TKN/ETH')
+    assert 'TKN' in url
+    assert 'ETH' in url
+
+    url = exchange.get_pair_detail_url('LOOONG/BTC')
+    assert 'LOOONG' in url
+    assert 'BTC' in url
+
+    default_conf['exchange']['name'] = 'poloniex'
+    exchange = Exchange(default_conf)
+    url = exchange.get_pair_detail_url('LOOONG/BTC')
+    assert '' == url
+    assert log_has('Could not get exchange url for Poloniex', caplog.record_tuples)
+
+
+def test_get_trades_for_order(default_conf, mocker):
+    order_id = 'ABCD-ABCD'
+    since = datetime(2018, 5, 5)
+    default_conf["dry_run"] = False
+    mocker.patch('freqtrade.exchange.Exchange.exchange_has', return_value=True)
+    api_mock = MagicMock()
+
+    api_mock.fetch_my_trades = MagicMock(return_value=[{'id': 'TTR67E-3PFBD-76IISV',
+                                                        'order': 'ABCD-ABCD',
+                                                        'info': {'pair': 'XLTCZBTC',
+                                                                 'time': 1519860024.4388,
+                                                                 'type': 'buy',
+                                                                 'ordertype': 'limit',
+                                                                 'price': '20.00000',
+                                                                 'cost': '38.62000',
+                                                                 'fee': '0.06179',
+                                                                 'vol': '5',
+                                                                 'id': 'ABCD-ABCD'},
+                                                        'timestamp': 1519860024438,
+                                                        'datetime': '2018-02-28T23:20:24.438Z',
+                                                        'symbol': 'LTC/BTC',
+                                                        'type': 'limit',
+                                                        'side': 'buy',
+                                                        'price': 165.0,
+                                                        'amount': 0.2340606,
+                                                        'fee': {'cost': 0.06179, 'currency': 'BTC'}
+                                                        }])
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+
+    orders = exchange.get_trades_for_order(order_id, 'LTC/BTC', since)
+    assert len(orders) == 1
+    assert orders[0]['price'] == 165
+
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+                           'get_trades_for_order', 'fetch_my_trades',
+                           order_id=order_id, pair='LTC/BTC', since=since)
+
+    mocker.patch('freqtrade.exchange.Exchange.exchange_has', MagicMock(return_value=False))
+    assert exchange.get_trades_for_order(order_id, 'LTC/BTC', since) == []
+
+
+def test_get_markets(default_conf, mocker, markets):
+    api_mock = MagicMock()
+    api_mock.fetch_markets = markets
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+    ret = exchange.get_markets()
+    assert isinstance(ret, list)
+    assert len(ret) == 6
+
+    assert ret[0]["id"] == "ethbtc"
+    assert ret[0]["symbol"] == "ETH/BTC"
+
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+                           'get_markets', 'fetch_markets')
 
 
 def test_get_fee(default_conf, mocker):
-    mocker.patch('freqtrade.exchange.validate_pairs',
-                 side_effect=lambda s: True)
-    init(default_conf)
-
-    assert get_fee() == 0.0025
-
-
-def test_exchange_misc(mocker):
     api_mock = MagicMock()
-    mocker.patch('freqtrade.exchange._API', api_mock)
-    exchange.get_markets()
-    assert api_mock.get_markets.call_count == 1
-    exchange.get_market_summaries()
-    assert api_mock.get_market_summaries.call_count == 1
-    api_mock.name = 123
-    assert exchange.get_name() == 123
-    api_mock.fee = 456
-    assert exchange.get_fee() == 456
-    exchange.get_wallet_health()
-    assert api_mock.get_wallet_health.call_count == 1
+    api_mock.calculate_fee = MagicMock(return_value={
+        'type': 'taker',
+        'currency': 'BTC',
+        'rate': 0.025,
+        'cost': 0.05
+    })
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+
+    assert exchange.get_fee() == 0.025
+
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+                           'get_fee', 'calculate_fee')
+
+
+def test_get_amount_lots(default_conf, mocker):
+    api_mock = MagicMock()
+    api_mock.amount_to_lots = MagicMock(return_value=1.0)
+    api_mock.markets = None
+    marketmock = MagicMock()
+    api_mock.load_markets = marketmock
+    exchange = get_patched_exchange(mocker, default_conf, api_mock)
+
+    assert exchange.get_amount_lots('LTC/BTC', 1.54) == 1
+    assert marketmock.call_count == 1

freqtrade/tests/exchange/test_exchange_bittrex.py

@@ -1,349 +0,0 @@
-# pragma pylint: disable=missing-docstring, C0103, protected-access, unused-argument
-
-from unittest.mock import MagicMock
-
-import pytest
-from requests.exceptions import ContentDecodingError
-
-import freqtrade.exchange.bittrex as btx
-from freqtrade.exchange.bittrex import Bittrex
-
-
-# Eat this flake8
-# +------------------+
-# |  bittrex.Bittrex |
-# +------------------+
-#         |
-#       (mock Fake_bittrex)
-#         |
-# +-----------------------------+
-# |  freqtrade.exchange.Bittrex |
-# +-----------------------------+
-# Call into Bittrex will flow up to the
-# external package bittrex.Bittrex.
-# By inserting a mock, we redirect those
-# calls.
-# The faked bittrex API is called just 'fb'
-# The freqtrade.exchange.Bittrex is a
-# wrapper, and is called 'wb'
-
-
-def _stub_config():
-    return {'key': '',
-            'secret': ''}
-
-
-class FakeBittrex():
-    def __init__(self, success=True):
-        self.success = True  # Believe in yourself
-        self.result = None
-        self.get_ticker_call_count = 0
-        # This is really ugly, doing side-effect during instance creation
-        # But we're allowed to in testing-code
-        btx._API = MagicMock()
-        btx._API.buy_limit = self.fake_buysell_limit
-        btx._API.sell_limit = self.fake_buysell_limit
-        btx._API.get_balance = self.fake_get_balance
-        btx._API.get_balances = self.fake_get_balances
-        btx._API.get_ticker = self.fake_get_ticker
-        btx._API.get_order = self.fake_get_order
-        btx._API.cancel = self.fake_cancel_order
-        btx._API.get_markets = self.fake_get_markets
-        btx._API.get_market_summaries = self.fake_get_market_summaries
-        btx._API_V2 = MagicMock()
-        btx._API_V2.get_candles = self.fake_get_candles
-        btx._API_V2.get_wallet_health = self.fake_get_wallet_health
-
-    def fake_buysell_limit(self, pair, amount, limit):
-        return {'success': self.success,
-                'result': {'uuid': '1234'},
-                'message': 'barter'}
-
-    def fake_get_balance(self, cur):
-        return {'success': self.success,
-                'result': {'Balance': 1234},
-                'message': 'unbalanced'}
-
-    def fake_get_balances(self):
-        return {'success': self.success,
-                'result': [{'BTC_ETH': 1234}],
-                'message': 'no balances'}
-
-    def fake_get_ticker(self, pair):
-        self.get_ticker_call_count += 1
-        return self.result or {'success': self.success,
-                               'result': {'Bid': 1, 'Ask': 1, 'Last': 1},
-                               'message': 'NO_API_RESPONSE'}
-
-    def fake_get_candles(self, pair, interval):
-        return self.result or {'success': self.success,
-                               'result': [{'C': 0, 'V': 0, 'O': 0, 'H': 0, 'L': 0, 'T': 0}],
-                               'message': 'candles lit'}
-
-    def fake_get_order(self, uuid):
-        return {'success': self.success,
-                'result': {'OrderUuid': 'ABC123',
-                           'Type': 'Type',
-                           'Exchange': 'BTC_ETH',
-                           'Opened': True,
-                           'PricePerUnit': 1,
-                           'Quantity': 1,
-                           'QuantityRemaining': 1,
-                           'Closed': True},
-                'message': 'lost'}
-
-    def fake_cancel_order(self, uuid):
-        return self.result or {'success': self.success,
-                               'message': 'no such order'}
-
-    def fake_get_markets(self):
-        return self.result or {'success': self.success,
-                               'message': 'market gone',
-                               'result': [{'MarketName': '-_'}]}
-
-    def fake_get_market_summaries(self):
-        return self.result or {'success': self.success,
-                               'message': 'no summary',
-                               'result': ['sum']}
-
-    def fake_get_wallet_health(self):
-        return self.result or {'success': self.success,
-                               'message': 'bad health',
-                               'result': [{'Health': {'Currency': 'BTC_ETH',
-                                                      'IsActive': True,
-                                                      'LastChecked': 0},
-                                           'Currency': {'Notice': True}}]}
-
-
-# The freqtrade.exchange.bittrex is called wrap_bittrex
-# to not confuse naming with bittrex.bittrex
-def make_wrap_bittrex():
-    conf = _stub_config()
-    wb = btx.Bittrex(conf)
-    return wb
-
-
-def test_exchange_bittrex_class():
-    conf = _stub_config()
-    b = Bittrex(conf)
-    assert isinstance(b, Bittrex)
-    slots = dir(b)
-    for name in ['fee', 'buy', 'sell', 'get_balance', 'get_balances',
-                 'get_ticker', 'get_ticker_history', 'get_order',
-                 'cancel_order', 'get_pair_detail_url', 'get_markets',
-                 'get_market_summaries', 'get_wallet_health']:
-        assert name in slots
-        # FIX: ensure that the slot is also a method in the class
-        # getattr(b, name) => bound method Bittrex.buy
-        # type(getattr(b, name)) => class 'method'
-
-
-def test_exchange_bittrex_fee():
-    fee = Bittrex.fee.__get__(Bittrex)
-    assert fee >= 0 and fee < 0.1  # Fee is 0-10 %
-
-
-def test_exchange_bittrex_buy_good():
-    wb = make_wrap_bittrex()
-    fb = FakeBittrex()
-    uuid = wb.buy('BTC_ETH', 1, 1)
-    assert uuid == fb.fake_buysell_limit(1, 2, 3)['result']['uuid']
-
-    fb.success = False
-    with pytest.raises(btx.OperationalException, match=r'barter.*'):
-        wb.buy('BAD', 1, 1)
-
-
-def test_exchange_bittrex_sell_good():
-    wb = make_wrap_bittrex()
-    fb = FakeBittrex()
-    uuid = wb.sell('BTC_ETH', 1, 1)
-    assert uuid == fb.fake_buysell_limit(1, 2, 3)['result']['uuid']
-
-    fb.success = False
-    with pytest.raises(btx.OperationalException, match=r'barter.*'):
-        uuid = wb.sell('BAD', 1, 1)
-
-
-def test_exchange_bittrex_get_balance():
-    wb = make_wrap_bittrex()
-    fb = FakeBittrex()
-    bal = wb.get_balance('BTC_ETH')
-    assert bal == fb.fake_get_balance(1)['result']['Balance']
-
-    fb.success = False
-    with pytest.raises(btx.OperationalException, match=r'unbalanced'):
-        wb.get_balance('BTC_ETH')
-
-
-def test_exchange_bittrex_get_balances():
-    wb = make_wrap_bittrex()
-    fb = FakeBittrex()
-    bals = wb.get_balances()
-    assert bals == fb.fake_get_balances()['result']
-
-    fb.success = False
-    with pytest.raises(btx.OperationalException, match=r'no balances'):
-        wb.get_balances()
-
-
-def test_exchange_bittrex_get_ticker():
-    wb = make_wrap_bittrex()
-    fb = FakeBittrex()
-
-    # Poll ticker, which updates the cache
-    tick = wb.get_ticker('BTC_ETH')
-    for x in ['bid', 'ask', 'last']:
-        assert x in tick
-    # Ensure the side-effect was made (update the ticker cache)
-    assert 'BTC_ETH' in wb.cached_ticker.keys()
-
-    # taint the cache, so we can recognize the cache wall utilized
-    wb.cached_ticker['BTC_ETH']['bid'] = 1234
-    # Poll again, getting the cached result
-    fb.get_ticker_call_count = 0
-    tick = wb.get_ticker('BTC_ETH', False)
-    # Ensure the result was from the cache, and that we didn't call exchange
-    assert wb.cached_ticker['BTC_ETH']['bid'] == 1234
-    assert fb.get_ticker_call_count == 0
-
-
-def test_exchange_bittrex_get_ticker_bad():
-    wb = make_wrap_bittrex()
-    fb = FakeBittrex()
-    fb.result = {'success': True, 'result': {'Bid': 1, 'Ask': 0}}  # incomplete result
-
-    with pytest.raises(ContentDecodingError, match=r'.*Invalid response from Bittrex params.*'):
-        wb.get_ticker('BTC_ETH')
-    fb.result = {'success': False, 'message': 'gone bad'}
-    with pytest.raises(btx.OperationalException, match=r'.*gone bad.*'):
-        wb.get_ticker('BTC_ETH')
-
-    fb.result = {'success': True, 'result': {}}  # incomplete result
-    with pytest.raises(ContentDecodingError, match=r'.*Invalid response from Bittrex params.*'):
-        wb.get_ticker('BTC_ETH')
-    fb.result = {'success': False, 'message': 'gone bad'}
-    with pytest.raises(btx.OperationalException, match=r'.*gone bad.*'):
-        wb.get_ticker('BTC_ETH')
-
-    fb.result = {'success': True,
-                 'result': {'Bid': 1, 'Ask': 0, 'Last': None}}  # incomplete result
-    with pytest.raises(ContentDecodingError, match=r'.*Invalid response from Bittrex params.*'):
-        wb.get_ticker('BTC_ETH')
-
-
-def test_exchange_bittrex_get_ticker_history_intervals():
-    wb = make_wrap_bittrex()
-    FakeBittrex()
-    for tick_interval in [1, 5, 30, 60, 1440]:
-        assert ([{'C': 0, 'V': 0, 'O': 0, 'H': 0, 'L': 0, 'T': 0}] ==
-                wb.get_ticker_history('BTC_ETH', tick_interval))
-
-
-def test_exchange_bittrex_get_ticker_history():
-    wb = make_wrap_bittrex()
-    fb = FakeBittrex()
-    assert wb.get_ticker_history('BTC_ETH', 5)
-    with pytest.raises(ValueError, match=r'.*Unknown tick_interval.*'):
-        wb.get_ticker_history('BTC_ETH', 2)
-
-    fb.success = False
-    with pytest.raises(btx.OperationalException, match=r'candles lit.*'):
-        wb.get_ticker_history('BTC_ETH', 5)
-
-    fb.success = True
-    with pytest.raises(ContentDecodingError, match=r'.*Invalid response from Bittrex.*'):
-        fb.result = {'bad': 0}
-        wb.get_ticker_history('BTC_ETH', 5)
-
-    with pytest.raises(ContentDecodingError, match=r'.*Required property C not present.*'):
-        fb.result = {'success': True,
-                     'result': [{'V': 0, 'O': 0, 'H': 0, 'L': 0, 'T': 0}],  # close is missing
-                     'message': 'candles lit'}
-        wb.get_ticker_history('BTC_ETH', 5)
-
-
-def test_exchange_bittrex_get_order():
-    wb = make_wrap_bittrex()
-    fb = FakeBittrex()
-    order = wb.get_order('someUUID')
-    assert order['id'] == 'ABC123'
-    fb.success = False
-    with pytest.raises(btx.OperationalException, match=r'lost'):
-        wb.get_order('someUUID')
-
-
-def test_exchange_bittrex_cancel_order():
-    wb = make_wrap_bittrex()
-    fb = FakeBittrex()
-    wb.cancel_order('someUUID')
-    with pytest.raises(btx.OperationalException, match=r'no such order'):
-        fb.success = False
-        wb.cancel_order('someUUID')
-    # Note: this can be a bug in exchange.bittrex._validate_response
-    with pytest.raises(KeyError):
-        fb.result = {'success': False}  # message is missing!
-        wb.cancel_order('someUUID')
-    with pytest.raises(btx.OperationalException, match=r'foo'):
-        fb.result = {'success': False, 'message': 'foo'}
-        wb.cancel_order('someUUID')
-
-
-def test_exchange_get_pair_detail_url():
-    wb = make_wrap_bittrex()
-    assert wb.get_pair_detail_url('BTC_ETH')
-
-
-def test_exchange_get_markets():
-    wb = make_wrap_bittrex()
-    fb = FakeBittrex()
-    x = wb.get_markets()
-    assert x == ['__']
-    with pytest.raises(btx.OperationalException, match=r'market gone'):
-        fb.success = False
-        wb.get_markets()
-
-
-def test_exchange_get_market_summaries():
-    wb = make_wrap_bittrex()
-    fb = FakeBittrex()
-    assert ['sum'] == wb.get_market_summaries()
-    with pytest.raises(btx.OperationalException, match=r'no summary'):
-        fb.success = False
-        wb.get_market_summaries()
-
-
-def test_exchange_get_wallet_health():
-    wb = make_wrap_bittrex()
-    fb = FakeBittrex()
-    x = wb.get_wallet_health()
-    assert x[0]['Currency'] == 'BTC_ETH'
-    with pytest.raises(btx.OperationalException, match=r'bad health'):
-        fb.success = False
-        wb.get_wallet_health()
-
-
-def test_validate_response_success():
-    response = {
-        'message': '',
-        'result': [],
-    }
-    Bittrex._validate_response(response)
-
-
-def test_validate_response_no_api_response():
-    response = {
-        'message': 'NO_API_RESPONSE',
-        'result': None,
-    }
-    with pytest.raises(ContentDecodingError, match=r'.*NO_API_RESPONSE.*'):
-        Bittrex._validate_response(response)
-
-
-def test_validate_response_min_trade_requirement_not_met():
-    response = {
-        'message': 'MIN_TRADE_REQUIREMENT_NOT_MET',
-        'result': None,
-    }
-    with pytest.raises(ContentDecodingError, match=r'.*MIN_TRADE_REQUIREMENT_NOT_MET.*'):
-        Bittrex._validate_response(response)

freqtrade/tests/exchange/test_exchange_helpers.py

@@ -0,0 +1,21 @@
+# 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/test_backtesting.py

@@ -3,22 +3,21 @@
 import json
 import math
 import random
-from copy import deepcopy
 from typing import List
 from unittest.mock import MagicMock
 
 import numpy as np
 import pandas as pd
+import pytest
 from arrow import Arrow
 
-from freqtrade import optimize
-from freqtrade.analyze import Analyze
-from freqtrade.arguments import Arguments
-from freqtrade.optimize.backtesting import Backtesting, start, setup_configuration
-from freqtrade.tests.conftest import default_conf, log_has
-
-# Avoid to reinit the same object again and again
-_BACKTESTING = Backtesting(default_conf())
+from freqtrade import DependencyException, constants, optimize
+from freqtrade.arguments import Arguments, TimeRange
+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.strategy.default_strategy import DefaultStrategy
 
 
 def get_args(args) -> List[str]:
@@ -33,50 +32,61 @@ def trim_dictlist(dict_list, num):
 
 
 def load_data_test(what):
-    timerange = ((None, 'line'), None, -100)
-    data = optimize.load_data(None, ticker_interval=1, pairs=['BTC_UNITEST'], timerange=timerange)
-    pair = data['BTC_UNITEST']
+    timerange = TimeRange(None, 'line', 0, -101)
+    data = optimize.load_data(None, ticker_interval='1m',
+                              pairs=['UNITTEST/BTC'], timerange=timerange)
+    pair = data['UNITTEST/BTC']
     datalen = len(pair)
     # Depending on the what parameter we now adjust the
     # loaded data looks:
-    # pair :: [{'O': 0.123, 'H': 0.123, 'L': 0.123,
-    #           'C': 0.123, 'V': 123.123,
-    #           'T': '2017-11-04T23:02:00', 'BV': 0.123}]
+    # 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 {'BTC_UNITEST':
-                [{'T': pair[x]['T'],  # Keep old dates
-                  'V': pair[x]['V'],  # Keep old volume
-                  'BV': pair[x]['BV'],  # keep too
-                  'O': x * base,        # But replace O,H,L,C
-                  'H': x * base + 0.0001,
-                  'L': x * base - 0.0001,
-                  'C': x * base} for x in range(0, datalen)]}
+        return {'UNITTEST/BTC': [
+            [
+                pair[x][0],  # Keep old dates
+                x * base,  # But replace O,H,L,C
+                x * base + 0.0001,
+                x * base - 0.0001,
+                x * base,
+                pair[x][5],  # Keep old volume
+            ] for x in range(0, datalen)
+        ]}
     if what == 'lower':
-        return {'BTC_UNITEST':
-                [{'T': pair[x]['T'],  # Keep old dates
-                  'V': pair[x]['V'],  # Keep old volume
-                  'BV': pair[x]['BV'],  # keep too
-                  'O': 1 - x * base,        # But replace O,H,L,C
-                  'H': 1 - x * base + 0.0001,
-                  'L': 1 - x * base - 0.0001,
-                  'C': 1 - x * base} for x in range(0, datalen)]}
+        return {'UNITTEST/BTC': [
+            [
+                pair[x][0],  # Keep old dates
+                1 - x * base,  # But replace O,H,L,C
+                1 - x * base + 0.0001,
+                1 - x * base - 0.0001,
+                1 - x * base,
+                pair[x][5]  # Keep old volume
+            ] for x in range(0, datalen)
+        ]}
     if what == 'sine':
         hz = 0.1  # frequency
-        return {'BTC_UNITEST':
-                [{'T': pair[x]['T'],  # Keep old dates
-                  'V': pair[x]['V'],  # Keep old volume
-                  'BV': pair[x]['BV'],  # keep too
-                  # But replace O,H,L,C
-                  'O': math.sin(x * hz) / 1000 + base,
-                  'H': math.sin(x * hz) / 1000 + base + 0.0001,
-                  'L': math.sin(x * hz) / 1000 + base - 0.0001,
-                  'C': math.sin(x * hz) / 1000 + base} for x in range(0, datalen)]}
+        return {'UNITTEST/BTC': [
+            [
+                pair[x][0],  # Keep old dates
+                math.sin(x * hz) / 1000 + base,  # But replace O,H,L,C
+                math.sin(x * hz) / 1000 + base + 0.0001,
+                math.sin(x * hz) / 1000 + base - 0.0001,
+                math.sin(x * hz) / 1000 + base,
+                pair[x][5]  # Keep old volume
+            ] for x in range(0, datalen)
+        ]}
     return data
 
 
-def simple_backtest(config, contour, num_results) -> None:
-    backtesting = _BACKTESTING
+def simple_backtest(config, contour, num_results, mocker) -> None:
+    patch_exchange(mocker)
+    backtesting = Backtesting(config)
 
     data = load_data_test(contour)
     processed = backtesting.tickerdata_to_dataframe(data)
@@ -86,35 +96,38 @@ def simple_backtest(config, contour, num_results) -> None:
             'stake_amount': config['stake_amount'],
             'processed': processed,
             'max_open_trades': 1,
-            'realistic': True
+            'position_stacking': False
         }
     )
     # results :: <class 'pandas.core.frame.DataFrame'>
     assert len(results) == num_results
 
 
-def mocked_load_data(datadir, pairs=[], ticker_interval=0, refresh_pairs=False, timerange=None):
-    tickerdata = optimize.load_tickerdata_file(datadir, 'BTC_UNITEST', 1, timerange=timerange)
-    pairdata = {'BTC_UNITEST': tickerdata}
+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}
     return pairdata
 
 
-# use for mock freqtrade.exchange.get_ticker_history'
+# use for mock freqtrade.exchange.get_candle_history'
 def _load_pair_as_ticks(pair, tickfreq):
     ticks = optimize.load_data(None, ticker_interval=tickfreq, pairs=[pair])
-    ticks = trim_dictlist(ticks, -200)
+    ticks = trim_dictlist(ticks, -201)
     return ticks[pair]
 
 
 # FIX: fixturize this?
-def _make_backtest_conf(conf=None, pair='BTC_UNITEST', record=None):
-    data = optimize.load_data(None, ticker_interval=8, pairs=[pair])
-    data = trim_dictlist(data, -200)
+def _make_backtest_conf(mocker, conf=None, pair='UNITTEST/BTC', record=None):
+    data = optimize.load_data(None, ticker_interval='8m', pairs=[pair])
+    data = trim_dictlist(data, -201)
+    patch_exchange(mocker)
+    backtesting = Backtesting(conf)
     return {
         'stake_amount': conf['stake_amount'],
-        'processed': _BACKTESTING.tickerdata_to_dataframe(data),
+        'processed': backtesting.tickerdata_to_dataframe(data),
         'max_open_trades': 10,
-        'realistic': True,
+        'position_stacking': False,
         'record': record
     }
 
@@ -132,7 +145,7 @@ def _trend(signals, buy_value, sell_value):
     return signals
 
 
-def _trend_alternate(dataframe=None):
+def _trend_alternate(dataframe=None, metadata=None):
     signals = dataframe
     low = signals['low']
     n = len(low)
@@ -148,26 +161,8 @@ def _trend_alternate(dataframe=None):
     return dataframe
 
 
-def _run_backtest_1(fun, backtest_conf):
-    # strategy is a global (hidden as a singleton), so we
-    # emulate strategy being pure, by override/restore here
-    # if we dont do this, the override in strategy will carry over
-    # to other tests
-    old_buy = _BACKTESTING.populate_buy_trend
-    old_sell = _BACKTESTING.populate_sell_trend
-    _BACKTESTING.populate_buy_trend = fun  # Override
-    _BACKTESTING.populate_sell_trend = fun  # Override
-    results = _BACKTESTING.backtest(backtest_conf)
-    _BACKTESTING.populate_buy_trend = old_buy  # restore override
-    _BACKTESTING.populate_sell_trend = old_sell  # restore override
-    return results
-
-
 # Unit tests
 def test_setup_configuration_without_arguments(mocker, default_conf, caplog) -> None:
-    """
-    Test setup_configuration() function
-    """
     mocker.patch('freqtrade.configuration.open', mocker.mock_open(
         read_data=json.dumps(default_conf)
     ))
@@ -186,7 +181,7 @@ def test_setup_configuration_without_arguments(mocker, default_conf, caplog) ->
     assert 'pair_whitelist' in config['exchange']
     assert 'datadir' in config
     assert log_has(
-        'Parameter --datadir detected: {} ...'.format(config['datadir']),
+        'Using data folder: {} ...'.format(config['datadir']),
         caplog.record_tuples
     )
     assert 'ticker_interval' in config
@@ -195,8 +190,8 @@ def test_setup_configuration_without_arguments(mocker, default_conf, caplog) ->
     assert 'live' not in config
     assert not log_has('Parameter -l/--live detected ...', caplog.record_tuples)
 
-    assert 'realistic_simulation' not in config
-    assert not log_has('Parameter --realistic-simulation detected ...', caplog.record_tuples)
+    assert 'position_stacking' not in config
+    assert not log_has('Parameter --enable-position-stacking detected ...', caplog.record_tuples)
 
     assert 'refresh_pairs' not in config
     assert not log_has('Parameter -r/--refresh-pairs-cached detected ...', caplog.record_tuples)
@@ -206,9 +201,6 @@ def test_setup_configuration_without_arguments(mocker, default_conf, caplog) ->
 
 
 def test_setup_configuration_with_arguments(mocker, default_conf, caplog) -> None:
-    """
-    Test setup_configuration() function
-    """
     mocker.patch('freqtrade.configuration.open', mocker.mock_open(
         read_data=json.dumps(default_conf)
     ))
@@ -218,12 +210,14 @@ def test_setup_configuration_with_arguments(mocker, default_conf, caplog) -> Non
         '--strategy', 'DefaultStrategy',
         '--datadir', '/foo/bar',
         'backtesting',
-        '--ticker-interval', '1',
+        '--ticker-interval', '1m',
         '--live',
-        '--realistic-simulation',
+        '--enable-position-stacking',
+        '--disable-max-market-positions',
         '--refresh-pairs-cached',
         '--timerange', ':100',
-        '--export', '/bar/foo'
+        '--export', '/bar/foo',
+        '--export-filename', 'foo_bar.json'
     ]
 
     config = setup_configuration(get_args(args))
@@ -234,24 +228,27 @@ def test_setup_configuration_with_arguments(mocker, default_conf, caplog) -> Non
     assert 'pair_whitelist' in config['exchange']
     assert 'datadir' in config
     assert log_has(
-        'Parameter --datadir detected: {} ...'.format(config['datadir']),
+        '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: 1 ...',
+        'Using ticker_interval: 1m ...',
         caplog.record_tuples
     )
 
     assert 'live' in config
     assert log_has('Parameter -l/--live detected ...', caplog.record_tuples)
 
-    assert 'realistic_simulation'in config
-    assert log_has('Parameter --realistic-simulation detected ...', caplog.record_tuples)
-    assert log_has('Using max_open_trades: 1 ...', caplog.record_tuples)
+    assert 'position_stacking' in config
+    assert log_has('Parameter --enable-position-stacking detected ...', caplog.record_tuples)
 
-    assert 'refresh_pairs'in config
+    assert 'use_max_market_positions' in config
+    assert log_has('Parameter --disable-max-market-positions detected ...', caplog.record_tuples)
+    assert log_has('max_open_trades set to unlimited ...', 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(
@@ -264,13 +261,34 @@ def test_setup_configuration_with_arguments(mocker, default_conf, caplog) -> Non
         'Parameter --export detected: {} ...'.format(config['export']),
         caplog.record_tuples
     )
+    assert 'exportfilename' in config
+    assert log_has(
+        'Storing backtest results to {} ...'.format(config['exportfilename']),
+        caplog.record_tuples
+    )
 
 
-def test_start(mocker, default_conf, caplog) -> None:
-    """
-    Test start() function
-    """
+def test_setup_configuration_unlimited_stake_amount(mocker, default_conf, caplog) -> None:
+    default_conf['stake_amount'] = constants.UNLIMITED_STAKE_AMOUNT
+
+    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
+        read_data=json.dumps(default_conf)
+    ))
+
+    args = [
+        '--config', 'config.json',
+        '--strategy', 'DefaultStrategy',
+        'backtesting'
+    ]
+
+    with pytest.raises(DependencyException, match=r'.*stake amount.*'):
+        setup_configuration(get_args(args))
+
+
+def test_start(mocker, fee, default_conf, caplog) -> None:
     start_mock = MagicMock()
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
+    patch_exchange(mocker)
     mocker.patch('freqtrade.optimize.backtesting.Backtesting.start', start_mock)
     mocker.patch('freqtrade.configuration.open', mocker.mock_open(
         read_data=json.dumps(default_conf)
@@ -289,114 +307,156 @@ def test_start(mocker, default_conf, caplog) -> None:
     assert start_mock.call_count == 1
 
 
-def test_backtesting__init__(mocker, default_conf) -> None:
-    """
-    Test Backtesting.__init__() method
-    """
-    init_mock = MagicMock()
-    mocker.patch('freqtrade.optimize.backtesting.Backtesting._init', init_mock)
-
+def test_backtesting_init(mocker, default_conf) -> None:
+    patch_exchange(mocker)
+    get_fee = mocker.patch('freqtrade.exchange.Exchange.get_fee', MagicMock(return_value=0.5))
     backtesting = Backtesting(default_conf)
     assert backtesting.config == default_conf
-    assert backtesting.analyze is None
-    assert backtesting.ticker_interval is None
-    assert backtesting.tickerdata_to_dataframe is None
-    assert backtesting.populate_buy_trend is None
-    assert backtesting.populate_sell_trend is None
-    assert init_mock.call_count == 1
-
-
-def test_backtesting_init(default_conf) -> None:
-    """
-    Test Backtesting._init() method
-    """
-    backtesting = Backtesting(default_conf)
-    assert backtesting.config == default_conf
-    assert isinstance(backtesting.analyze, Analyze)
-    assert backtesting.ticker_interval == 5
+    assert backtesting.ticker_interval == '5m'
     assert callable(backtesting.tickerdata_to_dataframe)
-    assert callable(backtesting.populate_buy_trend)
-    assert callable(backtesting.populate_sell_trend)
+    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) -> None:
-    """
-    Test Backtesting.tickerdata_to_dataframe() method
-    """
+def test_tickerdata_to_dataframe(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}
 
-    timerange = ((None, 'line'), None, -100)
-    tick = optimize.load_tickerdata_file(None, 'BTC_UNITEST', 1, timerange=timerange)
-    tickerlist = {'BTC_UNITEST': tick}
-
-    backtesting = _BACKTESTING
+    backtesting = Backtesting(default_conf)
     data = backtesting.tickerdata_to_dataframe(tickerlist)
-    assert len(data['BTC_UNITEST']) == 100
+    assert len(data['UNITTEST/BTC']) == 99
 
-    # Load Analyze to compare the result between Backtesting function and Analyze are the same
-    analyze = Analyze(default_conf)
-    data2 = analyze.tickerdata_to_dataframe(tickerlist)
-    assert data['BTC_UNITEST'].equals(data2['BTC_UNITEST'])
+    # Load strategy to compare the result between Backtesting function and strategy are the same
+    strategy = DefaultStrategy(default_conf)
+    data2 = strategy.tickerdata_to_dataframe(tickerlist)
+    assert data['UNITTEST/BTC'].equals(data2['UNITTEST/BTC'])
 
 
-def test_get_timeframe() -> None:
-    """
-    Test Backtesting.get_timeframe() method
-    """
-    backtesting = _BACKTESTING
+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=1,
-            pairs=['BTC_UNITEST']
+            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:59:00+00:00'
+    assert max_date.isoformat() == '2017-11-14T22:58:00+00:00'
 
 
-def test_generate_text_table():
-    """
-    Test Backtesting.generate_text_table() method
-    """
-    backtesting = _BACKTESTING
+def test_generate_text_table(default_conf, mocker):
+    patch_exchange(mocker)
+    backtesting = Backtesting(default_conf)
 
     results = pd.DataFrame(
         {
-            'currency': ['BTC_ETH', 'BTC_ETH'],
+            'pair': ['ETH/BTC', 'ETH/BTC'],
             'profit_percent': [0.1, 0.2],
-            'profit_BTC': [0.2, 0.4],
-            'duration': [10, 30],
+            'profit_abs': [0.2, 0.4],
+            'trade_duration': [10, 30],
             'profit': [2, 0],
             'loss': [0, 0]
         }
     )
 
     result_str = (
-        'pair       buy count    avg profit %    '
-        'total profit BTC    avg duration    profit    loss\n'
-        '-------  -----------  --------------  '
-        '------------------  --------------  --------  ------\n'
-        'BTC_ETH            2           15.00          '
-        '0.60000000            20.0         2       0\n'
-        'TOTAL              2           15.00          '
-        '0.60000000            20.0         2       0'
+        '| pair    |   buy count |   avg profit % |   cum profit % |   '
+        'total profit BTC | 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 |'
+    )
+    assert backtesting._generate_text_table(data={'ETH/BTC': {}}, results=results) == result_str
+
+
+def test_generate_text_table_sell_reason(default_conf, mocker):
+    patch_exchange(mocker)
+    backtesting = Backtesting(default_conf)
+
+    results = pd.DataFrame(
+        {
+            'pair': ['ETH/BTC', 'ETH/BTC', 'ETH/BTC'],
+            'profit_percent': [0.1, 0.2, 0.3],
+            'profit_abs': [0.2, 0.4, 0.5],
+            'trade_duration': [10, 30, 10],
+            'profit': [2, 0, 0],
+            'loss': [0, 0, 1],
+            'sell_reason': [SellType.ROI, SellType.ROI, SellType.STOP_LOSS]
+        }
     )
 
-    assert backtesting._generate_text_table(data={'BTC_ETH': {}}, results=results) == result_str
+    result_str = (
+        '| Sell Reason   |   Count |\n'
+        '|:--------------|--------:|\n'
+        '| roi           |       2 |\n'
+        '| stop_loss     |       1 |'
+    )
+    assert backtesting._generate_text_table_sell_reason(
+        data={'ETH/BTC': {}}, results=results) == result_str
+
+
+def test_generate_text_table_strategyn(default_conf, mocker):
+    """
+    Test Backtesting.generate_text_table_sell_reason() method
+    """
+    patch_exchange(mocker)
+    backtesting = Backtesting(default_conf)
+    results = {}
+    results['ETH/BTC'] = pd.DataFrame(
+        {
+            'pair': ['ETH/BTC', 'ETH/BTC', 'ETH/BTC'],
+            'profit_percent': [0.1, 0.2, 0.3],
+            'profit_abs': [0.2, 0.4, 0.5],
+            'trade_duration': [10, 30, 10],
+            'profit': [2, 0, 0],
+            'loss': [0, 0, 1],
+            'sell_reason': [SellType.ROI, SellType.ROI, SellType.STOP_LOSS]
+        }
+    )
+    results['LTC/BTC'] = pd.DataFrame(
+        {
+            'pair': ['LTC/BTC', 'LTC/BTC', 'LTC/BTC'],
+            'profit_percent': [0.4, 0.2, 0.3],
+            'profit_abs': [0.4, 0.4, 0.5],
+            'trade_duration': [15, 30, 15],
+            'profit': [4, 1, 0],
+            'loss': [0, 0, 1],
+            'sell_reason': [SellType.ROI, SellType.ROI, SellType.STOP_LOSS]
+        }
+    )
+
+    result_str = (
+        '| Strategy   |   buy count |   avg profit % |   cum profit % '
+        '|   total profit BTC | avg duration   |   profit |   loss |\n'
+        '|:-----------|------------:|---------------:|---------------:'
+        '|-------------------:|:---------------|---------:|-------:|\n'
+        '| ETH/BTC    |           3 |          20.00 |          60.00 '
+        '|         1.10000000 | 0:17:00        |        3 |      0 |\n'
+        '| LTC/BTC    |           3 |          30.00 |          90.00 '
+        '|         1.30000000 | 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:
-    """
-    Test Backtesting.start() method
-    """
     def get_timeframe(input1, input2):
         return Arrow(2017, 11, 14, 21, 17), Arrow(2017, 11, 14, 22, 59)
 
-    mocker.patch('freqtrade.freqtradebot.Analyze', MagicMock())
     mocker.patch('freqtrade.optimize.load_data', mocked_load_data)
-    mocker.patch('freqtrade.exchange.get_ticker_history')
+    mocker.patch('freqtrade.exchange.Exchange.get_candle_history')
+    patch_exchange(mocker)
     mocker.patch.multiple(
         'freqtrade.optimize.backtesting.Backtesting',
         backtest=MagicMock(),
@@ -404,15 +464,14 @@ def test_backtesting_start(default_conf, mocker, caplog) -> None:
         get_timeframe=get_timeframe,
     )
 
-    conf = deepcopy(default_conf)
-    conf['exchange']['pair_whitelist'] = ['BTC_UNITEST']
-    conf['ticker_interval'] = 1
-    conf['live'] = False
-    conf['datadir'] = None
-    conf['export'] = None
-    conf['timerange'] = '-100'
+    default_conf['exchange']['pair_whitelist'] = ['UNITTEST/BTC']
+    default_conf['ticker_interval'] = 1
+    default_conf['live'] = False
+    default_conf['datadir'] = None
+    default_conf['export'] = None
+    default_conf['timerange'] = '-100'
 
-    backtesting = Backtesting(conf)
+    backtesting = Backtesting(default_conf)
     backtesting.start()
     # check the logs, that will contain the backtest result
     exists = [
@@ -426,54 +485,108 @@ def test_backtesting_start(default_conf, mocker, caplog) -> None:
         assert log_has(line, caplog.record_tuples)
 
 
-def test_backtest(default_conf) -> None:
-    """
-    Test Backtesting.backtest() method
-    """
-    backtesting = _BACKTESTING
+def test_backtesting_start_no_data(default_conf, mocker, caplog) -> None:
+    def get_timeframe(input1, input2):
+        return Arrow(2017, 11, 14, 21, 17), Arrow(2017, 11, 14, 22, 59)
 
-    data = optimize.load_data(None, ticker_interval=5, pairs=['BTC_ETH'])
+    mocker.patch('freqtrade.optimize.load_data', MagicMock(return_value={}))
+    mocker.patch('freqtrade.exchange.Exchange.get_candle_history')
+    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'] = "1m"
+    default_conf['live'] = False
+    default_conf['datadir'] = None
+    default_conf['export'] = None
+    default_conf['timerange'] = '20180101-20180102'
+
+    backtesting = Backtesting(default_conf)
+    backtesting.start()
+    # check the logs, that will contain the backtest result
+
+    assert log_has('No data found. Terminating.', caplog.record_tuples)
+
+
+def test_backtest(default_conf, fee, mocker) -> None:
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
+    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)
     results = backtesting.backtest(
         {
             'stake_amount': default_conf['stake_amount'],
-            'processed': backtesting.tickerdata_to_dataframe(data),
+            'processed': data_processed,
             'max_open_trades': 10,
-            'realistic': True
+            'position_stacking': False
         }
     )
     assert not results.empty
+    assert len(results) == 2
+
+    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],
+         'open_at_end': [False, False],
+         'open_rate': [0.104445, 0.10302485],
+         'close_rate': [0.105, 0.10359999],
+         'sell_reason': [SellType.ROI, SellType.ROI]
+         })
+    pd.testing.assert_frame_equal(results, expected)
+    data_pair = data_processed[pair]
+    for _, t in results.iterrows():
+        ln = data_pair.loc[data_pair["date"] == t["open_time"]]
+        # 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
+        ln = data_pair.loc[data_pair["date"] == t["close_time"]]
+        assert round(ln.iloc[0]["open"], 6) == round(t["close_rate"], 6)
 
 
-def test_backtest_1min_ticker_interval(default_conf) -> None:
-    """
-    Test Backtesting.backtest() method with 1 min ticker
-    """
-    backtesting = _BACKTESTING
+def test_backtest_1min_ticker_interval(default_conf, fee, mocker) -> None:
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
+    patch_exchange(mocker)
+    backtesting = Backtesting(default_conf)
 
     # Run a backtesting for an exiting 5min ticker_interval
-    data = optimize.load_data(None, ticker_interval=1, pairs=['BTC_UNITEST'])
+    data = optimize.load_data(None, ticker_interval='1m', pairs=['UNITTEST/BTC'])
     data = trim_dictlist(data, -200)
     results = backtesting.backtest(
         {
             'stake_amount': default_conf['stake_amount'],
             'processed': backtesting.tickerdata_to_dataframe(data),
             'max_open_trades': 1,
-            'realistic': True
+            'position_stacking': False
         }
     )
     assert not results.empty
+    assert len(results) == 1
 
 
-def test_processed() -> None:
-    """
-    Test Backtesting.backtest() method with offline data
-    """
-    backtesting = _BACKTESTING
+def test_processed(default_conf, mocker) -> None:
+    patch_exchange(mocker)
+    backtesting = Backtesting(default_conf)
 
     dict_of_tickerrows = load_data_test('raise')
     dataframes = backtesting.tickerdata_to_dataframe(dict_of_tickerrows)
-    dataframe = dataframes['BTC_UNITEST']
+    dataframe = dataframes['UNITTEST/BTC']
     cols = dataframe.columns
     # assert the dataframe got some of the indicator columns
     for col in ['close', 'high', 'low', 'open', 'date',
@@ -481,80 +594,136 @@ def test_processed() -> None:
         assert col in cols
 
 
-def test_backtest_pricecontours(default_conf) -> None:
-    tests = [['raise', 17], ['lower', 0], ['sine', 17]]
+def test_backtest_pricecontours(default_conf, fee, mocker) -> None:
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
+    tests = [['raise', 18], ['lower', 0], ['sine', 16]]
     for [contour, numres] in tests:
-        simple_backtest(default_conf, contour, numres)
+        simple_backtest(default_conf, contour, numres, mocker)
 
 
 # Test backtest using offline data (testdata directory)
-def test_backtest_ticks(default_conf):
+def test_backtest_ticks(default_conf, fee, mocker):
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
+    patch_exchange(mocker)
     ticks = [1, 5]
-    fun = _BACKTESTING.populate_buy_trend
-    for tick in ticks:
-        backtest_conf = _make_backtest_conf(conf=default_conf)
-        results = _run_backtest_1(fun, backtest_conf)
+    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(default_conf):
-    # Override the default buy trend function in our DefaultStrategy
-    def fun(dataframe=None):
+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):
         buy_value = 1
         sell_value = 1
         return _trend(dataframe, buy_value, sell_value)
 
-    backtest_conf = _make_backtest_conf(conf=default_conf)
-    results = _run_backtest_1(fun, backtest_conf)
+    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 results.empty
 
 
-def test_backtest_only_sell(default_conf):
-    # Override the default buy trend function in our DefaultStrategy
-    def fun(dataframe=None):
+def test_backtest_only_sell(mocker, default_conf):
+    # Override the default buy trend function in our default_strategy
+    def fun(dataframe=None, pair=None):
         buy_value = 0
         sell_value = 1
         return _trend(dataframe, buy_value, sell_value)
 
-    backtest_conf = _make_backtest_conf(conf=default_conf)
-    results = _run_backtest_1(fun, backtest_conf)
+    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 results.empty
 
 
-def test_backtest_alternate_buy_sell(default_conf):
-    backtest_conf = _make_backtest_conf(conf=default_conf, pair='BTC_UNITEST')
-    results = _run_backtest_1(_trend_alternate, backtest_conf)
-    assert len(results) == 3
+def test_backtest_alternate_buy_sell(default_conf, fee, mocker):
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
+    backtest_conf = _make_backtest_conf(mocker, conf=default_conf, pair='UNITTEST/BTC')
+    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
+    # One trade was force-closed at the end
+    assert len(results.loc[results.open_at_end]) == 1
 
 
-def test_backtest_record(default_conf, mocker):
+def test_backtest_record(default_conf, fee, mocker):
     names = []
     records = []
+    patch_exchange(mocker)
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
     mocker.patch(
         'freqtrade.optimize.backtesting.file_dump_json',
         new=lambda n, r: (names.append(n), records.append(r))
     )
-    backtest_conf = _make_backtest_conf(
-        conf=default_conf,
-        pair='BTC_UNITEST',
-        record="trades"
-    )
-    results = _run_backtest_1(_trend_alternate, backtest_conf)
-    assert len(results) == 3
+
+    backtesting = Backtesting(default_conf)
+    results = pd.DataFrame({"pair": ["UNITTEST/BTC", "UNITTEST/BTC",
+                                     "UNITTEST/BTC", "UNITTEST/BTC"],
+                            "profit_percent": [0.003312, 0.010801, 0.013803, 0.002780],
+                            "profit_abs": [0.000003, 0.000011, 0.000014, 0.000003],
+                            "open_time": [Arrow(2017, 11, 14, 19, 32, 00).datetime,
+                                          Arrow(2017, 11, 14, 21, 36, 00).datetime,
+                                          Arrow(2017, 11, 14, 22, 12, 00).datetime,
+                                          Arrow(2017, 11, 14, 22, 44, 00).datetime],
+                            "close_time": [Arrow(2017, 11, 14, 21, 35, 00).datetime,
+                                           Arrow(2017, 11, 14, 22, 10, 00).datetime,
+                                           Arrow(2017, 11, 14, 22, 43, 00).datetime,
+                                           Arrow(2017, 11, 14, 22, 58, 00).datetime],
+                            "open_rate": [0.002543, 0.003003, 0.003089, 0.003214],
+                            "close_rate": [0.002546, 0.003014, 0.003103, 0.003217],
+                            "open_index": [1, 119, 153, 185],
+                            "close_index": [118, 151, 184, 199],
+                            "trade_duration": [123, 34, 31, 14],
+                            "open_at_end": [False, False, False, True],
+                            "sell_reason": [SellType.ROI, SellType.STOP_LOSS,
+                                            SellType.ROI, SellType.FORCE_SELL]
+                            })
+    backtesting._store_backtest_result("backtest-result.json", results)
+    assert len(results) == 4
     # Assert file_dump_json was only called once
     assert names == ['backtest-result.json']
     records = records[0]
     # Ensure records are of correct type
-    assert len(records) == 3
-    # ('BTC_UNITEST', 0.00331158, '1510684320', '1510691700', 0, 117)
+    assert len(records) == 4
+
+    # reset test to test with strategy name
+    names = []
+    records = []
+    backtesting._store_backtest_result("backtest-result.json", results, "DefStrat")
+    assert len(results) == 4
+    # Assert file_dump_json was only called once
+    assert names == ['backtest-result-DefStrat.json']
+    records = records[0]
+    # Ensure records are of correct type
+    assert len(records) == 4
+
+    # ('UNITTEST/BTC', 0.00331158, '1510684320', '1510691700', 0, 117)
     # Below follows just a typecheck of the schema/type of trade-records
     oix = None
-    for (pair, profit, date_buy, date_sell, buy_index, dur) in records:
-        assert pair == 'BTC_UNITEST'
-        isinstance(profit, float)
+    for (pair, profit, date_buy, date_sell, buy_index, dur,
+         openr, closer, open_at_end, sell_reason) in records:
+        assert pair == 'UNITTEST/BTC'
+        assert isinstance(profit, float)
         # FIX: buy/sell should be converted to ints
-        isinstance(date_buy, str)
-        isinstance(date_sell, str)
+        assert isinstance(date_buy, float)
+        assert isinstance(date_sell, float)
+        assert isinstance(openr, float)
+        assert isinstance(closer, float)
+        assert isinstance(open_at_end, bool)
+        assert isinstance(sell_reason, str)
         isinstance(buy_index, pd._libs.tslib.Timestamp)
         if oix:
             assert buy_index > oix
@@ -563,47 +732,100 @@ def test_backtest_record(default_conf, mocker):
 
 
 def test_backtest_start_live(default_conf, mocker, caplog):
-    default_conf['exchange']['pair_whitelist'] = ['BTC_UNITEST']
-    mocker.patch('freqtrade.exchange.get_ticker_history',
-                 new=lambda n, i: _load_pair_as_ticks(n, i))
+    default_conf['exchange']['pair_whitelist'] = ['UNITTEST/BTC']
+    mocker.patch('freqtrade.exchange.Exchange.get_candle_history',
+                 new=lambda s, n, i: _load_pair_as_ticks(n, i))
+    patch_exchange(mocker)
     mocker.patch('freqtrade.optimize.backtesting.Backtesting.backtest', MagicMock())
     mocker.patch('freqtrade.optimize.backtesting.Backtesting._generate_text_table', MagicMock())
     mocker.patch('freqtrade.configuration.open', mocker.mock_open(
         read_data=json.dumps(default_conf)
     ))
 
-    args = MagicMock()
-    args.ticker_interval = 1
-    args.level = 10
-    args.live = True
-    args.datadir = None
-    args.export = None
-    args.strategy = 'DefaultStrategy'
-    args.timerange = '-100'  # needed due to MagicMock malleability
-
     args = [
         '--config', 'config.json',
         '--strategy', 'DefaultStrategy',
+        '--datadir', 'freqtrade/tests/testdata',
         'backtesting',
-        '--ticker-interval', '1',
+        '--ticker-interval', '1m',
         '--live',
-        '--timerange', '-100'
+        '--timerange', '-100',
+        '--enable-position-stacking',
+        '--disable-max-market-positions'
     ]
     args = get_args(args)
     start(args)
     # check the logs, that will contain the backtest result
     exists = [
         'Parameter -i/--ticker-interval detected ...',
-        'Using ticker_interval: 1 ...',
+        'Using ticker_interval: 1m ...',
         'Parameter -l/--live detected ...',
-        'Using max_open_trades: 1 ...',
-        'Parameter --timerange detected: -100 ..',
-        'Parameter --datadir detected: freqtrade/tests/testdata ...',
+        'Ignoring max_open_trades (--disable-max-market-positions was used) ...',
+        'Parameter --timerange detected: -100 ...',
+        'Using data folder: freqtrade/tests/testdata ...',
         'Using stake_currency: BTC ...',
         'Using stake_amount: 0.001 ...',
         'Downloading data for all pairs in whitelist ...',
-        'Measuring data from 2017-11-14T19:32:00+00:00 up to 2017-11-14T22:59:00+00:00 (0 days)..'
+        'Measuring data from 2017-11-14T19:31:00+00:00 up to 2017-11-14T22:58:00+00:00 (0 days)..',
+        'Parameter --enable-position-stacking detected ...'
     ]
 
     for line in exists:
-        log_has(line, caplog.record_tuples)
+        assert log_has(line, caplog.record_tuples)
+
+
+def test_backtest_start_multi_strat(default_conf, mocker, caplog):
+    default_conf['exchange']['pair_whitelist'] = ['UNITTEST/BTC']
+    mocker.patch('freqtrade.exchange.Exchange.get_candle_history',
+                 new=lambda s, n, i: _load_pair_as_ticks(n, i))
+    patch_exchange(mocker)
+    backtestmock = MagicMock()
+    mocker.patch('freqtrade.optimize.backtesting.Backtesting.backtest', backtestmock)
+    gen_table_mock = MagicMock()
+    mocker.patch('freqtrade.optimize.backtesting.Backtesting._generate_text_table', gen_table_mock)
+    gen_strattable_mock = MagicMock()
+    mocker.patch('freqtrade.optimize.backtesting.Backtesting._generate_text_table_strategy',
+                 gen_strattable_mock)
+    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
+        read_data=json.dumps(default_conf)
+    ))
+
+    args = [
+        '--config', 'config.json',
+        '--datadir', 'freqtrade/tests/testdata',
+        'backtesting',
+        '--ticker-interval', '1m',
+        '--live',
+        '--timerange', '-100',
+        '--enable-position-stacking',
+        '--disable-max-market-positions',
+        '--strategy-list',
+        'DefaultStrategy',
+        'TestStrategy',
+    ]
+    args = get_args(args)
+    start(args)
+    # 2 backtests, 4 tables
+    assert backtestmock.call_count == 2
+    assert gen_table_mock.call_count == 4
+    assert gen_strattable_mock.call_count == 1
+
+    # check the logs, that will contain the backtest result
+    exists = [
+        'Parameter -i/--ticker-interval detected ...',
+        'Using ticker_interval: 1m ...',
+        'Parameter -l/--live detected ...',
+        'Ignoring max_open_trades (--disable-max-market-positions was used) ...',
+        'Parameter --timerange detected: -100 ...',
+        'Using data folder: freqtrade/tests/testdata ...',
+        'Using stake_currency: BTC ...',
+        'Using stake_amount: 0.001 ...',
+        'Downloading data for all pairs in whitelist ...',
+        'Measuring data from 2017-11-14T19:31:00+00:00 up to 2017-11-14T22:58:00+00:00 (0 days)..',
+        'Parameter --enable-position-stacking detected ...',
+        'Running backtesting for Strategy DefaultStrategy',
+        'Running backtesting for Strategy TestStrategy',
+    ]
+
+    for line in exists:
+        assert log_has(line, caplog.record_tuples)

freqtrade/tests/optimize/test_hyperopt.py

@@ -1,59 +1,50 @@
 # pragma pylint: disable=missing-docstring,W0212,C0103
-import json
 import os
-from copy import deepcopy
 from unittest.mock import MagicMock
 
 import pandas as pd
+import pytest
 
 from freqtrade.optimize.__init__ import load_tickerdata_file
 from freqtrade.optimize.hyperopt import Hyperopt, start
 from freqtrade.strategy.resolver import StrategyResolver
-from freqtrade.tests.conftest import default_conf, log_has
+from freqtrade.tests.conftest import log_has, patch_exchange
 from freqtrade.tests.optimize.test_backtesting import get_args
 
 
-# Avoid to reinit the same object again and again
-_HYPEROPT = Hyperopt(default_conf())
+@pytest.fixture(scope='function')
+def hyperopt(default_conf, mocker):
+    patch_exchange(mocker)
+    return Hyperopt(default_conf)
 
 
 # Functions for recurrent object patching
-def create_trials(mocker) -> None:
+def create_trials(mocker, hyperopt) -> None:
     """
     When creating trials, mock the hyperopt Trials so that *by default*
       - we don't create any pickle'd files in the filesystem
       - we might have a pickle'd file so make sure that we return
         false when looking for it
     """
-    _HYPEROPT.trials_file = os.path.join('freqtrade', 'tests', 'optimize', 'ut_trials.pickle')
+    hyperopt.trials_file = os.path.join('freqtrade', 'tests', 'optimize', 'ut_trials.pickle')
 
     mocker.patch('freqtrade.optimize.hyperopt.os.path.exists', return_value=False)
     mocker.patch('freqtrade.optimize.hyperopt.os.path.getsize', return_value=1)
     mocker.patch('freqtrade.optimize.hyperopt.os.remove', return_value=True)
-    mocker.patch('freqtrade.optimize.hyperopt.pickle.dump', return_value=None)
+    mocker.patch('freqtrade.optimize.hyperopt.dump', return_value=None)
 
-    return mocker.Mock(
-        results=[
-            {
-                'loss': 1,
-                'result': 'foo',
-                'status': 'ok'
-            }
-        ],
-        best_trial={'misc': {'vals': {'adx': 999}}}
-    )
+    return [{'loss': 1, 'result': 'foo', 'params': {}}]
 
 
-# Unit tests
 def test_start(mocker, default_conf, caplog) -> None:
-    """
-    Test start() function
-    """
     start_mock = MagicMock()
+    mocker.patch(
+        'freqtrade.configuration.Configuration._load_config_file',
+        lambda *args, **kwargs: default_conf
+    )
     mocker.patch('freqtrade.optimize.hyperopt.Hyperopt.start', start_mock)
-    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
-        read_data=json.dumps(default_conf)
-    ))
+    patch_exchange(mocker)
+
     args = [
         '--config', 'config.json',
         '--strategy', 'DefaultStrategy',
@@ -74,11 +65,7 @@ def test_start(mocker, default_conf, caplog) -> None:
     assert start_mock.call_count == 1
 
 
-def test_loss_calculation_prefer_correct_trade_count() -> None:
-    """
-    Test Hyperopt.calculate_loss()
-    """
-    hyperopt = _HYPEROPT
+def test_loss_calculation_prefer_correct_trade_count(hyperopt) -> None:
     StrategyResolver({'strategy': 'DefaultStrategy'})
 
     correct = hyperopt.calculate_loss(1, hyperopt.target_trades, 20)
@@ -88,20 +75,13 @@ def test_loss_calculation_prefer_correct_trade_count() -> None:
     assert under > correct
 
 
-def test_loss_calculation_prefer_shorter_trades() -> None:
-    """
-    Test Hyperopt.calculate_loss()
-    """
-    hyperopt = _HYPEROPT
-
+def test_loss_calculation_prefer_shorter_trades(hyperopt) -> None:
     shorter = hyperopt.calculate_loss(1, 100, 20)
     longer = hyperopt.calculate_loss(1, 100, 30)
     assert shorter < longer
 
 
-def test_loss_calculation_has_limited_profit() -> None:
-    hyperopt = _HYPEROPT
-
+def test_loss_calculation_has_limited_profit(hyperopt) -> None:
     correct = hyperopt.calculate_loss(hyperopt.expected_max_profit, hyperopt.target_trades, 20)
     over = hyperopt.calculate_loss(hyperopt.expected_max_profit * 2, hyperopt.target_trades, 20)
     under = hyperopt.calculate_loss(hyperopt.expected_max_profit / 2, hyperopt.target_trades, 20)
@@ -109,8 +89,7 @@ def test_loss_calculation_has_limited_profit() -> None:
     assert under > correct
 
 
-def test_log_results_if_loss_improves(capsys) -> None:
-    hyperopt = _HYPEROPT
+def test_log_results_if_loss_improves(hyperopt, capsys) -> None:
     hyperopt.current_best_loss = 2
     hyperopt.log_results(
         {
@@ -121,11 +100,10 @@ def test_log_results_if_loss_improves(capsys) -> None:
         }
     )
     out, err = capsys.readouterr()
-    assert '    1/2: foo. Loss 1.00000'in out
+    assert '    1/2: foo. Loss 1.00000' in out
 
 
-def test_no_log_if_loss_does_not_improve(caplog) -> None:
-    hyperopt = _HYPEROPT
+def test_no_log_if_loss_does_not_improve(hyperopt, caplog) -> None:
     hyperopt.current_best_loss = 2
     hyperopt.log_results(
         {
@@ -135,176 +113,34 @@ def test_no_log_if_loss_does_not_improve(caplog) -> None:
     assert caplog.record_tuples == []
 
 
-def test_fmin_best_results(mocker, default_conf, caplog) -> None:
-    fmin_result = {
-        "macd_below_zero": 0,
-        "adx": 1,
-        "adx-value": 15.0,
-        "fastd": 1,
-        "fastd-value": 40.0,
-        "green_candle": 1,
-        "mfi": 0,
-        "over_sar": 0,
-        "rsi": 1,
-        "rsi-value": 37.0,
-        "trigger": 2,
-        "uptrend_long_ema": 1,
-        "uptrend_short_ema": 0,
-        "uptrend_sma": 0,
-        "stoploss": -0.1,
-        "roi_t1": 1,
-        "roi_t2": 2,
-        "roi_t3": 3,
-        "roi_p1": 1,
-        "roi_p2": 2,
-        "roi_p3": 3,
-    }
-
-    conf = deepcopy(default_conf)
-    conf.update({'config': 'config.json.example'})
-    conf.update({'epochs': 1})
-    conf.update({'timerange': None})
-    conf.update({'spaces': 'all'})
-
-    mocker.patch('freqtrade.optimize.hyperopt.load_data', MagicMock())
-    mocker.patch('freqtrade.optimize.hyperopt.fmin', return_value=fmin_result)
-    mocker.patch('freqtrade.optimize.hyperopt.hyperopt_optimize_conf', return_value=conf)
-
-    StrategyResolver({'strategy': 'DefaultStrategy'})
-    hyperopt = Hyperopt(conf)
-    hyperopt.trials = create_trials(mocker)
-    hyperopt.tickerdata_to_dataframe = MagicMock()
-    hyperopt.start()
-
-    exists = [
-        'Best parameters:',
-        '"adx": {\n        "enabled": true,\n        "value": 15.0\n    },',
-        '"fastd": {\n        "enabled": true,\n        "value": 40.0\n    },',
-        '"green_candle": {\n        "enabled": true\n    },',
-        '"macd_below_zero": {\n        "enabled": false\n    },',
-        '"mfi": {\n        "enabled": false\n    },',
-        '"over_sar": {\n        "enabled": false\n    },',
-        '"roi_p1": 1.0,',
-        '"roi_p2": 2.0,',
-        '"roi_p3": 3.0,',
-        '"roi_t1": 1.0,',
-        '"roi_t2": 2.0,',
-        '"roi_t3": 3.0,',
-        '"rsi": {\n        "enabled": true,\n        "value": 37.0\n    },',
-        '"stoploss": -0.1,',
-        '"trigger": {\n        "type": "faststoch10"\n    },',
-        '"uptrend_long_ema": {\n        "enabled": true\n    },',
-        '"uptrend_short_ema": {\n        "enabled": false\n    },',
-        '"uptrend_sma": {\n        "enabled": false\n    }',
-        'ROI table:\n{0: 6.0, 3.0: 3.0, 5.0: 1.0, 6.0: 0}',
-        'Best Result:\nfoo'
-    ]
-    for line in exists:
-        assert line in caplog.text
-
-
-def test_fmin_throw_value_error(mocker, default_conf, caplog) -> None:
-    mocker.patch('freqtrade.optimize.hyperopt.load_data', MagicMock())
-    mocker.patch('freqtrade.optimize.hyperopt.fmin', side_effect=ValueError())
-
-    conf = deepcopy(default_conf)
-    conf.update({'config': 'config.json.example'})
-    conf.update({'epochs': 1})
-    conf.update({'timerange': None})
-    conf.update({'spaces': 'all'})
-    mocker.patch('freqtrade.optimize.hyperopt.hyperopt_optimize_conf', return_value=conf)
-    StrategyResolver({'strategy': 'DefaultStrategy'})
-    hyperopt = Hyperopt(conf)
-    hyperopt.trials = create_trials(mocker)
-    hyperopt.tickerdata_to_dataframe = MagicMock()
-
-    hyperopt.start()
-
-    exists = [
-        'Best Result:',
-        'Sorry, Hyperopt was not able to find good parameters. Please try with more epochs '
-        '(param: -e).',
-    ]
-
-    for line in exists:
-        assert line in caplog.text
-
-
-def test_resuming_previous_hyperopt_results_succeeds(mocker, default_conf) -> None:
-    trials = create_trials(mocker)
-
-    conf = deepcopy(default_conf)
-    conf.update({'config': 'config.json.example'})
-    conf.update({'epochs': 1})
-    conf.update({'mongodb': False})
-    conf.update({'timerange': None})
-    conf.update({'spaces': 'all'})
-
-    mocker.patch('freqtrade.optimize.hyperopt.os.path.exists', return_value=True)
-    mocker.patch('freqtrade.optimize.hyperopt.len', return_value=len(trials.results))
-    mock_read = mocker.patch(
-        'freqtrade.optimize.hyperopt.Hyperopt.read_trials',
-        return_value=trials
-    )
-    mock_save = mocker.patch(
-        'freqtrade.optimize.hyperopt.Hyperopt.save_trials',
-        return_value=None
-    )
-    mocker.patch('freqtrade.optimize.hyperopt.sorted', return_value=trials.results)
-    mocker.patch('freqtrade.optimize.hyperopt.load_data', MagicMock())
-    mocker.patch('freqtrade.optimize.hyperopt.fmin', return_value={})
-    mocker.patch('freqtrade.optimize.hyperopt.hyperopt_optimize_conf', return_value=conf)
-
-    StrategyResolver({'strategy': 'DefaultStrategy'})
-    hyperopt = Hyperopt(conf)
+def test_save_trials_saves_trials(mocker, hyperopt, caplog) -> None:
+    trials = create_trials(mocker, hyperopt)
+    mock_dump = mocker.patch('freqtrade.optimize.hyperopt.dump', return_value=None)
     hyperopt.trials = trials
-    hyperopt.tickerdata_to_dataframe = MagicMock()
-
-    hyperopt.start()
-
-    mock_read.assert_called_once()
-    mock_save.assert_called_once()
-
-    current_tries = hyperopt.current_tries
-    total_tries = hyperopt.total_tries
-
-    assert current_tries == len(trials.results)
-    assert total_tries == (current_tries + len(trials.results))
-
-
-def test_save_trials_saves_trials(mocker, caplog) -> None:
-    create_trials(mocker)
-    mock_dump = mocker.patch('freqtrade.optimize.hyperopt.pickle.dump', return_value=None)
-
-    hyperopt = _HYPEROPT
-    mocker.patch('freqtrade.optimize.hyperopt.open', return_value=hyperopt.trials_file)
-
     hyperopt.save_trials()
 
+    trials_file = os.path.join('freqtrade', 'tests', 'optimize', 'ut_trials.pickle')
     assert log_has(
-        'Saving Trials to \'freqtrade/tests/optimize/ut_trials.pickle\'',
+        'Saving 1 evaluations to \'{}\''.format(trials_file),
         caplog.record_tuples
     )
     mock_dump.assert_called_once()
 
 
-def test_read_trials_returns_trials_file(mocker, caplog) -> None:
-    trials = create_trials(mocker)
-    mock_load = mocker.patch('freqtrade.optimize.hyperopt.pickle.load', return_value=trials)
-    mock_open = mocker.patch('freqtrade.optimize.hyperopt.open', return_value=mock_load)
-
-    hyperopt = _HYPEROPT
+def test_read_trials_returns_trials_file(mocker, hyperopt, caplog) -> None:
+    trials = create_trials(mocker, hyperopt)
+    mock_load = mocker.patch('freqtrade.optimize.hyperopt.load', return_value=trials)
     hyperopt_trial = hyperopt.read_trials()
+    trials_file = os.path.join('freqtrade', 'tests', 'optimize', 'ut_trials.pickle')
     assert log_has(
-        'Reading Trials from \'freqtrade/tests/optimize/ut_trials.pickle\'',
+        'Reading Trials from \'{}\''.format(trials_file),
         caplog.record_tuples
     )
     assert hyperopt_trial == trials
-    mock_open.assert_called_once()
     mock_load.assert_called_once()
 
 
-def test_roi_table_generation() -> None:
+def test_roi_table_generation(hyperopt) -> None:
     params = {
         'roi_t1': 5,
         'roi_t2': 10,
@@ -314,221 +150,150 @@ def test_roi_table_generation() -> None:
         'roi_p3': 3,
     }
 
-    hyperopt = _HYPEROPT
     assert hyperopt.generate_roi_table(params) == {0: 6, 15: 3, 25: 1, 30: 0}
 
 
-def test_start_calls_fmin(mocker, default_conf) -> None:
-    trials = create_trials(mocker)
-    mocker.patch('freqtrade.optimize.hyperopt.sorted', return_value=trials.results)
+def test_start_calls_optimizer(mocker, default_conf, caplog) -> None:
+    dumper = mocker.patch('freqtrade.optimize.hyperopt.dump', MagicMock())
     mocker.patch('freqtrade.optimize.hyperopt.load_data', MagicMock())
-    mock_fmin = mocker.patch('freqtrade.optimize.hyperopt.fmin', return_value={})
-
-    conf = deepcopy(default_conf)
-    conf.update({'config': 'config.json.example'})
-    conf.update({'epochs': 1})
-    conf.update({'mongodb': False})
-    conf.update({'timerange': None})
-    conf.update({'spaces': 'all'})
-
-    hyperopt = Hyperopt(conf)
-    hyperopt.trials = trials
-    hyperopt.tickerdata_to_dataframe = MagicMock()
-
-    hyperopt.start()
-    mock_fmin.assert_called_once()
-
-
-def test_start_uses_mongotrials(mocker, default_conf) -> None:
-    mocker.patch('freqtrade.optimize.hyperopt.load_data', MagicMock())
-    mock_fmin = mocker.patch('freqtrade.optimize.hyperopt.fmin', return_value={})
-    mock_mongotrials = mocker.patch(
-        'freqtrade.optimize.hyperopt.MongoTrials',
-        return_value=create_trials(mocker)
+    mocker.patch('freqtrade.optimize.hyperopt.multiprocessing.cpu_count', MagicMock(return_value=1))
+    parallel = mocker.patch(
+        'freqtrade.optimize.hyperopt.Hyperopt.run_optimizer_parallel',
+        MagicMock(return_value=[{'loss': 1, 'result': 'foo result', 'params': {}}])
     )
+    patch_exchange(mocker)
 
-    conf = deepcopy(default_conf)
-    conf.update({'config': 'config.json.example'})
-    conf.update({'epochs': 1})
-    conf.update({'mongodb': True})
-    conf.update({'timerange': None})
-    conf.update({'spaces': 'all'})
-    mocker.patch('freqtrade.optimize.hyperopt.hyperopt_optimize_conf', return_value=conf)
+    default_conf.update({'config': 'config.json.example'})
+    default_conf.update({'epochs': 1})
+    default_conf.update({'timerange': None})
+    default_conf.update({'spaces': 'all'})
 
-    hyperopt = Hyperopt(conf)
+    hyperopt = Hyperopt(default_conf)
     hyperopt.tickerdata_to_dataframe = MagicMock()
 
     hyperopt.start()
-    mock_mongotrials.assert_called_once()
-    mock_fmin.assert_called_once()
+    parallel.assert_called_once()
+
+    assert 'Best result:\nfoo result\nwith values:\n{}' in caplog.text
+    assert dumper.called
 
 
-# test log_trials_result
-# test buy_strategy_generator def populate_buy_trend
-# test optimizer if 'ro_t1' in params
-
-def test_format_results():
-    """
-    Test Hyperopt.format_results()
-    """
+def test_format_results(hyperopt):
+    # Test with BTC as stake_currency
     trades = [
-        ('BTC_ETH', 2, 2, 123),
-        ('BTC_LTC', 1, 1, 123),
-        ('BTC_XRP', -1, -2, -246)
+        ('ETH/BTC', 2, 2, 123),
+        ('LTC/BTC', 1, 1, 123),
+        ('XPR/BTC', -1, -2, -246)
     ]
-    labels = ['currency', 'profit_percent', 'profit_BTC', 'duration']
+    labels = ['currency', 'profit_percent', 'profit_abs', 'trade_duration']
     df = pd.DataFrame.from_records(trades, columns=labels)
-    x = Hyperopt.format_results(df)
-    assert x.find(' 66.67%')
+
+    result = hyperopt.format_results(df)
+    assert result.find(' 66.67%')
+    assert result.find('Total profit 1.00000000 BTC')
+    assert result.find('2.0000Σ %')
+
+    # Test with EUR as stake_currency
+    trades = [
+        ('ETH/EUR', 2, 2, 123),
+        ('LTC/EUR', 1, 1, 123),
+        ('XPR/EUR', -1, -2, -246)
+    ]
+    df = pd.DataFrame.from_records(trades, columns=labels)
+    result = hyperopt.format_results(df)
+    assert result.find('Total profit 1.00000000 EUR')
 
 
-def test_signal_handler(mocker):
-    """
-    Test Hyperopt.signal_handler()
-    """
-    m = MagicMock()
-    mocker.patch('sys.exit', m)
-    mocker.patch('freqtrade.optimize.hyperopt.Hyperopt.save_trials', m)
-    mocker.patch('freqtrade.optimize.hyperopt.Hyperopt.log_trials_result', m)
+def test_has_space(hyperopt):
+    hyperopt.config.update({'spaces': ['buy', 'roi']})
+    assert hyperopt.has_space('roi')
+    assert hyperopt.has_space('buy')
+    assert not hyperopt.has_space('stoploss')
 
-    hyperopt = _HYPEROPT
-    hyperopt.signal_handler(9, None)
-    assert m.call_count == 3
+    hyperopt.config.update({'spaces': ['all']})
+    assert hyperopt.has_space('buy')
 
 
-def test_has_space():
-    """
-    Test Hyperopt.has_space() method
-    """
-    _HYPEROPT.config.update({'spaces': ['buy', 'roi']})
-    assert _HYPEROPT.has_space('roi')
-    assert _HYPEROPT.has_space('buy')
-    assert not _HYPEROPT.has_space('stoploss')
-
-    _HYPEROPT.config.update({'spaces': ['all']})
-    assert _HYPEROPT.has_space('buy')
-
-
-def test_populate_indicators() -> None:
-    """
-    Test Hyperopt.populate_indicators()
-    """
-    tick = load_tickerdata_file(None, 'BTC_UNITEST', 1)
-    tickerlist = {'BTC_UNITEST': tick}
-    dataframes = _HYPEROPT.tickerdata_to_dataframe(tickerlist)
-    dataframe = _HYPEROPT.populate_indicators(dataframes['BTC_UNITEST'])
+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'})
 
     # Check if some indicators are generated. We will not test all of them
     assert 'adx' in dataframe
-    assert 'ao' in dataframe
-    assert 'cci' in dataframe
+    assert 'mfi' in dataframe
+    assert 'rsi' in dataframe
 
 
-def test_buy_strategy_generator() -> None:
-    """
-    Test Hyperopt.buy_strategy_generator()
-    """
-    tick = load_tickerdata_file(None, 'BTC_UNITEST', 1)
-    tickerlist = {'BTC_UNITEST': tick}
-    dataframes = _HYPEROPT.tickerdata_to_dataframe(tickerlist)
-    dataframe = _HYPEROPT.populate_indicators(dataframes['BTC_UNITEST'])
+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'})
 
-    populate_buy_trend = _HYPEROPT.buy_strategy_generator(
+    populate_buy_trend = hyperopt.buy_strategy_generator(
         {
-            'uptrend_long_ema': {
-                'enabled': True
-            },
-            'macd_below_zero': {
-                'enabled': True
-            },
-            'uptrend_short_ema': {
-                'enabled': True
-            },
-            'mfi': {
-                'enabled': True,
-                'value': 20
-            },
-            'fastd': {
-                'enabled': True,
-                'value': 20
-            },
-            'adx': {
-                'enabled': True,
-                'value': 20
-            },
-            'rsi': {
-                'enabled': True,
-                'value': 20
-            },
-            'over_sar': {
-                'enabled': True,
-            },
-            'green_candle': {
-                'enabled': True,
-            },
-            'uptrend_sma': {
-                'enabled': True,
-            },
-
-            'trigger': {
-                'type': 'lower_bb'
-            }
+            'adx-value': 20,
+            'fastd-value': 20,
+            'mfi-value': 20,
+            'rsi-value': 20,
+            'adx-enabled': True,
+            'fastd-enabled': True,
+            'mfi-enabled': True,
+            'rsi-enabled': True,
+            'trigger': 'bb_lower'
         }
     )
-    result = populate_buy_trend(dataframe)
+    result = populate_buy_trend(dataframe, {'pair': 'UNITTEST/BTC'})
     # Check if some indicators are generated. We will not test all of them
     assert 'buy' in result
     assert 1 in result['buy']
 
 
 def test_generate_optimizer(mocker, default_conf) -> None:
-    """
-    Test Hyperopt.generate_optimizer() function
-    """
-    conf = deepcopy(default_conf)
-    conf.update({'config': 'config.json.example'})
-    conf.update({'timerange': None})
-    conf.update({'spaces': 'all'})
+    default_conf.update({'config': 'config.json.example'})
+    default_conf.update({'timerange': None})
+    default_conf.update({'spaces': 'all'})
 
     trades = [
-        ('BTC_POWR', 0.023117, 0.000233, 100)
+        ('POWR/BTC', 0.023117, 0.000233, 100)
     ]
-    labels = ['currency', 'profit_percent', 'profit_BTC', 'duration']
+    labels = ['currency', 'profit_percent', 'profit_abs', 'trade_duration']
     backtest_result = pd.DataFrame.from_records(trades, columns=labels)
 
     mocker.patch(
         'freqtrade.optimize.hyperopt.Hyperopt.backtest',
         MagicMock(return_value=backtest_result)
     )
+    patch_exchange(mocker)
+    mocker.patch('freqtrade.optimize.hyperopt.load', MagicMock())
 
     optimizer_param = {
-        'adx': {'enabled': False},
-        'fastd': {'enabled': True, 'value': 35.0},
-        'green_candle': {'enabled': True},
-        'macd_below_zero': {'enabled': True},
-        'mfi': {'enabled': False},
-        'over_sar': {'enabled': False},
-        'roi_p1': 0.01,
-        'roi_p2': 0.01,
-        'roi_p3': 0.1,
+        'adx-value': 0,
+        'fastd-value': 35,
+        'mfi-value': 0,
+        'rsi-value': 0,
+        'adx-enabled': False,
+        'fastd-enabled': True,
+        'mfi-enabled': False,
+        'rsi-enabled': False,
+        'trigger': 'macd_cross_signal',
         'roi_t1': 60.0,
         'roi_t2': 30.0,
         'roi_t3': 20.0,
-        'rsi': {'enabled': False},
+        'roi_p1': 0.01,
+        'roi_p2': 0.01,
+        'roi_p3': 0.1,
         'stoploss': -0.4,
-        'trigger': {'type': 'macd_cross_signal'},
-        'uptrend_long_ema': {'enabled': False},
-        'uptrend_short_ema': {'enabled': True},
-        'uptrend_sma': {'enabled': True}
     }
-
     response_expected = {
         'loss': 1.9840569076926293,
         'result': '     1 trades. Avg profit  2.31%. Total profit  0.00023300 BTC '
                   '(0.0231Σ%). Avg duration 100.0 mins.',
-        'status': 'ok'
+        'params': optimizer_param
     }
 
-    hyperopt = Hyperopt(conf)
-    generate_optimizer_value = hyperopt.generate_optimizer(optimizer_param)
+    hyperopt = Hyperopt(default_conf)
+    generate_optimizer_value = hyperopt.generate_optimizer(list(optimizer_param.values()))
     assert generate_optimizer_value == response_expected

freqtrade/tests/optimize/test_hyperopt_config.py

@@ -1,16 +0,0 @@
-# pragma pylint: disable=missing-docstring,W0212
-
-from user_data.hyperopt_conf import hyperopt_optimize_conf
-
-
-def test_hyperopt_optimize_conf():
-    hyperopt_conf = hyperopt_optimize_conf()
-
-    assert "max_open_trades" in hyperopt_conf
-    assert "stake_currency" in hyperopt_conf
-    assert "stake_amount" in hyperopt_conf
-    assert "minimal_roi" in hyperopt_conf
-    assert "stoploss" in hyperopt_conf
-    assert "bid_strategy" in hyperopt_conf
-    assert "exchange" in hyperopt_conf
-    assert "pair_whitelist" in hyperopt_conf['exchange']

freqtrade/tests/optimize/test_optimize.py

@@ -5,13 +5,19 @@ import os
 import uuid
 from shutil import copyfile
 
-from freqtrade import optimize
-from freqtrade.misc import file_dump_json
-from freqtrade.optimize.__init__ import make_testdata_path, download_pairs, \
-    download_backtesting_testdata, load_tickerdata_file, trim_tickerlist
-from freqtrade.tests.conftest import log_has
+import arrow
 
-# Change this if modifying BTC_UNITEST testdatafile
+from freqtrade import optimize
+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
 
 
@@ -46,59 +52,64 @@ def _clean_test_file(file: str) -> None:
         os.rename(file_swp, file)
 
 
-def test_load_data_30min_ticker(ticker_history, mocker, caplog) -> None:
-    """
-    Test load_data() with 30 min ticker
-    """
-    mocker.patch('freqtrade.optimize.get_ticker_history', return_value=ticker_history)
-
-    file = 'freqtrade/tests/testdata/BTC_UNITTEST-30.json'
+def test_load_data_30min_ticker(ticker_history, mocker, caplog, default_conf) -> None:
+    mocker.patch('freqtrade.exchange.Exchange.get_candle_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=['BTC_UNITTEST'], ticker_interval=30)
+    optimize.load_data(None, pairs=['UNITTEST/BTC'], ticker_interval='30m')
     assert os.path.isfile(file) is True
-    assert not log_has('Download the pair: "BTC_ETH", Interval: 30 min', caplog.record_tuples)
+    assert not log_has('Download the pair: "UNITTEST/BTC", Interval: 30m', caplog.record_tuples)
     _clean_test_file(file)
 
 
-def test_load_data_5min_ticker(ticker_history, mocker, caplog) -> None:
-    """
-    Test load_data() with 5 min ticker
-    """
-    mocker.patch('freqtrade.optimize.get_ticker_history', return_value=ticker_history)
+def test_load_data_5min_ticker(ticker_history, mocker, caplog, default_conf) -> None:
+    mocker.patch('freqtrade.exchange.Exchange.get_candle_history', return_value=ticker_history)
 
-    file = 'freqtrade/tests/testdata/BTC_ETH-5.json'
+    file = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'UNITTEST_BTC-5m.json')
     _backup_file(file, copy_file=True)
-    optimize.load_data(None, pairs=['BTC_ETH'], ticker_interval=5)
+    optimize.load_data(None, pairs=['UNITTEST/BTC'], ticker_interval='5m')
     assert os.path.isfile(file) is True
-    assert not log_has('Download the pair: "BTC_ETH", Interval: 5 min', caplog.record_tuples)
+    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:
-    """
-    Test load_data() with 1 min ticker
-    """
-    mocker.patch('freqtrade.optimize.get_ticker_history', return_value=ticker_history)
-
-    file = 'freqtrade/tests/testdata/BTC_ETH-1.json'
+    mocker.patch('freqtrade.exchange.Exchange.get_candle_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=1, pairs=['BTC_ETH'])
+    optimize.load_data(None, ticker_interval='1m', pairs=['UNITTEST/BTC'])
     assert os.path.isfile(file) is True
-    assert not log_has('Download the pair: "BTC_ETH", Interval: 1 min', caplog.record_tuples)
+    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) -> None:
+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.optimize.get_ticker_history', return_value=ticker_history)
+    mocker.patch('freqtrade.exchange.Exchange.get_candle_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')
 
-    file = 'freqtrade/tests/testdata/BTC_MEME-1.json'
     _backup_file(file)
-    optimize.load_data(None, ticker_interval=1, pairs=['BTC_MEME'])
+    # 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: "BTC_MEME", Interval: 1 min', caplog.record_tuples)
+    assert log_has('Download the pair: "MEME/BTC", Interval: 1m', caplog.record_tuples)
     _clean_test_file(file)
 
 
@@ -106,13 +117,13 @@ def test_testdata_path() -> None:
     assert os.path.join('freqtrade', 'tests', 'testdata') in make_testdata_path(None)
 
 
-def test_download_pairs(ticker_history, mocker) -> None:
-    mocker.patch('freqtrade.optimize.__init__.get_ticker_history', return_value=ticker_history)
-
-    file1_1 = 'freqtrade/tests/testdata/BTC_MEME-1.json'
-    file1_5 = 'freqtrade/tests/testdata/BTC_MEME-5.json'
-    file2_1 = 'freqtrade/tests/testdata/BTC_CFI-1.json'
-    file2_5 = 'freqtrade/tests/testdata/BTC_CFI-5.json'
+def test_download_pairs(ticker_history, mocker, default_conf) -> None:
+    mocker.patch('freqtrade.exchange.Exchange.get_candle_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)
@@ -122,7 +133,8 @@ def test_download_pairs(ticker_history, mocker) -> None:
     assert os.path.isfile(file1_1) is False
     assert os.path.isfile(file2_1) is False
 
-    assert download_pairs(None, pairs=['BTC-MEME', 'BTC-CFI'], ticker_interval=1) is True
+    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
@@ -134,7 +146,8 @@ def test_download_pairs(ticker_history, mocker) -> None:
     assert os.path.isfile(file1_5) is False
     assert os.path.isfile(file2_5) is False
 
-    assert download_pairs(None, pairs=['BTC-MEME', 'BTC-CFI'], ticker_interval=5) is True
+    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
@@ -144,91 +157,201 @@ def test_download_pairs(ticker_history, mocker) -> None:
     _clean_test_file(file2_5)
 
 
-def test_download_pairs_exception(ticker_history, mocker, caplog) -> None:
-    mocker.patch('freqtrade.optimize.__init__.get_ticker_history', return_value=ticker_history)
+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_candle_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 = 'freqtrade/tests/testdata/BTC_MEME-1.json'
-    file1_5 = 'freqtrade/tests/testdata/BTC_MEME-5.json'
+    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, pairs=['BTC-MEME'], ticker_interval=1)
+    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: "BTC-MEME", Interval: 1 min', caplog.record_tuples)
+    assert log_has('Failed to download the pair: "MEME/BTC", Interval: 1m', caplog.record_tuples)
 
 
-def test_download_backtesting_testdata(ticker_history, mocker) -> None:
-    mocker.patch('freqtrade.optimize.__init__.get_ticker_history', return_value=ticker_history)
+def test_download_backtesting_testdata(ticker_history, mocker, default_conf) -> None:
+    mocker.patch('freqtrade.exchange.Exchange.get_candle_history', return_value=ticker_history)
+    exchange = get_patched_exchange(mocker, default_conf)
 
     # Download a 1 min ticker file
-    file1 = 'freqtrade/tests/testdata/BTC_XEL-1.json'
+    file1 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'XEL_BTC-1m.json')
     _backup_file(file1)
-    download_backtesting_testdata(None, pair="BTC-XEL", interval=1)
+    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 = 'freqtrade/tests/testdata/BTC_STORJ-5.json'
+    file2 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'STORJ_BTC-5m.json')
     _backup_file(file2)
 
-    download_backtesting_testdata(None, pair="BTC-STORJ", interval=5)
+    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) -> None:
-    tick = [{'T': 'bar'}, {'T': 'foo'}]
+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.optimize.__init__.get_ticker_history', return_value=tick)
-    download_backtesting_testdata(None, pair="BTC-UNITEST", interval=1)
-    download_backtesting_testdata(None, pair="BTC-UNITEST", interval=3)
+    mocker.patch('freqtrade.exchange.Exchange.get_candle_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, 'BTC_UNITEST', 7)
+    assert not load_tickerdata_file(None, 'UNITTEST/BTC', '7m')
     # 1 exists only as a .json
-    tickerdata = load_tickerdata_file(None, 'BTC_UNITEST', 1)
+    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, 'BTC_UNITEST', 8)
+    tickerdata = load_tickerdata_file(None, 'UNITTEST/BTC', '8m')
     assert _BTC_UNITTEST_LENGTH == len(tickerdata)
 
 
 def test_init(default_conf, mocker) -> None:
-    conf = {'exchange': {'pair_whitelist': []}}
-    mocker.patch('freqtrade.optimize.hyperopt_optimize_conf', return_value=conf)
+    exchange = get_patched_exchange(mocker, default_conf)
     assert {} == optimize.load_data(
         '',
+        exchange=exchange,
         pairs=[],
         refresh_pairs=True,
-        ticker_interval=int(default_conf['ticker_interval'])
+        ticker_interval=default_conf['ticker_interval']
     )
 
 
 def test_trim_tickerlist() -> None:
-    with open('freqtrade/tests/testdata/BTC_ETH-1.json') as data_file:
+    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 remove X element from the beginning
-    timerange = ((None, 'line'), None, 5)
+    # 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_list_len == ticker_len + 5
+    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 = (('line', None), 5, None)
+    timerange = TimeRange('line', None, 5, 0)
     ticker = trim_tickerlist(ticker_list, timerange)
     ticker_len = len(ticker)
 
@@ -238,7 +361,7 @@ def test_trim_tickerlist() -> None:
 
     # Test the pattern ^(\d+)-(\d+)$
     # This pattern extract a window
-    timerange = (('index', 'index'), 5, 10)
+    timerange = TimeRange('index', 'index', 5, 10)
     ticker = trim_tickerlist(ticker_list, timerange)
     ticker_len = len(ticker)
 
@@ -247,9 +370,40 @@ def test_trim_tickerlist() -> None:
     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 = ((None, None), None, 5)
+    timerange = TimeRange(None, None, None, 5)
     ticker = trim_tickerlist(ticker_list, timerange)
     ticker_len = len(ticker)
 
@@ -257,11 +411,8 @@ def test_trim_tickerlist() -> None:
 
 
 def test_file_dump_json() -> None:
-    """
-    Test file_dump_json()
-    :return: None
-    """
-    file = 'freqtrade/tests/testdata/test_{id}.json'.format(id=str(uuid.uuid4()))
+    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

freqtrade/tests/rpc/test_rpc.py

@@ -1,19 +1,18 @@
+# pragma pylint: disable=missing-docstring, C0103
 # pragma pylint: disable=invalid-sequence-index, invalid-name, too-many-arguments
 
-"""
-Unit test file for rpc/rpc.py
-"""
-
 from datetime import datetime
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, ANY
 
-from sqlalchemy import create_engine
+import pytest
 
+from freqtrade.fiat_convert import CryptoToFiatConverter
 from freqtrade.freqtradebot import FreqtradeBot
 from freqtrade.persistence import Trade
-from freqtrade.rpc.rpc import RPC
+from freqtrade.rpc import RPC, RPCException
 from freqtrade.state import State
-from freqtrade.tests.test_freqtradebot import patch_get_signal, patch_coinmarketcap
+from freqtrade.tests.test_freqtradebot import patch_get_signal
+from freqtrade.tests.conftest import patch_coinmarketcap
 
 
 # Functions for recurrent object patching
@@ -25,107 +24,96 @@ def prec_satoshi(a, b) -> float:
 
 
 # Unit tests
-def test_rpc_trade_status(default_conf, ticker, mocker) -> None:
-    """
-    Test rpc_trade_status() method
-    """
-    patch_get_signal(mocker, (True, False))
+def test_rpc_trade_status(default_conf, ticker, fee, markets, mocker) -> None:
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
-        get_ticker=ticker
+        get_ticker=ticker,
+        get_fee=fee,
+        get_markets=markets
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
+    patch_get_signal(freqtradebot, (True, False))
     rpc = RPC(freqtradebot)
 
     freqtradebot.state = State.STOPPED
-    (error, result) = rpc.rpc_trade_status()
-    assert error
-    assert 'trader is not running' in result
+    with pytest.raises(RPCException, match=r'.*trader is not running*'):
+        rpc._rpc_trade_status()
 
     freqtradebot.state = State.RUNNING
-    (error, result) = rpc.rpc_trade_status()
-    assert error
-    assert 'no active trade' in result
+    with pytest.raises(RPCException, match=r'.*no active trade*'):
+        rpc._rpc_trade_status()
 
     freqtradebot.create_trade()
-    (error, result) = rpc.rpc_trade_status()
-    assert not error
-    trade = result[0]
+    results = rpc._rpc_trade_status()
 
-    result_message = [
-        '*Trade ID:* `1`\n'
-        '*Current Pair:* '
-        '[BTC_ETH](https://www.bittrex.com/Market/Index?MarketName=BTC-ETH)\n'
-        '*Open Since:* `just now`\n'
-        '*Amount:* `90.99181074`\n'
-        '*Open Rate:* `0.00001099`\n'
-        '*Close Rate:* `None`\n'
-        '*Current Rate:* `0.00001098`\n'
-        '*Close Profit:* `None`\n'
-        '*Current Profit:* `-0.59%`\n'
-        '*Open Order:* `(LIMIT_BUY rem=0.00000000)`'
-    ]
-    assert result == result_message
-    assert trade.find('[BTC_ETH]') >= 0
+    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': 1.098e-05,
+        'amount': 90.99181074,
+        'close_profit': None,
+        'current_profit': -0.59,
+        'open_order': '(limit buy rem=0.00000000)'
+    } == results[0]
 
 
-def test_rpc_status_table(default_conf, ticker, mocker) -> None:
-    """
-    Test rpc_status_table() method
-    """
-    patch_get_signal(mocker, (True, False))
+def test_rpc_status_table(default_conf, ticker, fee, markets, mocker) -> None:
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
-        get_ticker=ticker
+        get_ticker=ticker,
+        get_fee=fee,
+        get_markets=markets
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
+    patch_get_signal(freqtradebot, (True, False))
     rpc = RPC(freqtradebot)
 
     freqtradebot.state = State.STOPPED
-    (error, result) = rpc.rpc_status_table()
-    assert error
-    assert '*Status:* `trader is not running`' in result
+    with pytest.raises(RPCException, match=r'.*trader is not running*'):
+        rpc._rpc_status_table()
 
     freqtradebot.state = State.RUNNING
-    (error, result) = rpc.rpc_status_table()
-    assert error
-    assert '*Status:* `no active order`' in result
+    with pytest.raises(RPCException, match=r'.*no active order*'):
+        rpc._rpc_status_table()
 
     freqtradebot.create_trade()
-    (error, result) = rpc.rpc_status_table()
+    result = rpc._rpc_status_table()
     assert 'just now' in result['Since'].all()
-    assert 'BTC_ETH' in result['Pair'].all()
+    assert 'ETH/BTC' in result['Pair'].all()
     assert '-0.59%' in result['Profit'].all()
 
 
-def test_rpc_daily_profit(default_conf, update, ticker, limit_buy_order, limit_sell_order, mocker)\
-        -> None:
-    """
-    Test rpc_daily_profit() method
-    """
-    patch_get_signal(mocker, (True, False))
+def test_rpc_daily_profit(default_conf, update, ticker, fee,
+                          limit_buy_order, limit_sell_order, markets, mocker) -> None:
     patch_coinmarketcap(mocker, value={'price_usd': 15000.0})
-    mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
-        get_ticker=ticker
+        get_ticker=ticker,
+        get_fee=fee,
+        get_markets=markets
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
+    patch_get_signal(freqtradebot, (True, False))
     stake_currency = default_conf['stake_currency']
     fiat_display_currency = default_conf['fiat_display_currency']
 
     rpc = RPC(freqtradebot)
-
+    rpc._fiat_converter = CryptoToFiatConverter()
     # Create some test data
     freqtradebot.create_trade()
     trade = Trade.query.first()
@@ -139,8 +127,7 @@ def test_rpc_daily_profit(default_conf, update, ticker, limit_buy_order, limit_s
 
     # Try valid data
     update.message.text = '/daily 2'
-    (error, days) = rpc.rpc_daily_profit(7, stake_currency, fiat_display_currency)
-    assert not error
+    days = rpc._rpc_daily_profit(7, stake_currency, fiat_display_currency)
     assert len(days) == 7
     for day in days:
         # [datetime.date(2018, 1, 11), '0.00000000 BTC', '0.000 USD']
@@ -153,38 +140,37 @@ def test_rpc_daily_profit(default_conf, update, ticker, limit_buy_order, limit_s
     assert str(days[0][0]) == str(datetime.utcnow().date())
 
     # Try invalid data
-    (error, days) = rpc.rpc_daily_profit(0, stake_currency, fiat_display_currency)
-    assert error
-    assert days.find('must be an integer greater than 0') >= 0
+    with pytest.raises(RPCException, match=r'.*must be an integer greater than 0*'):
+        rpc._rpc_daily_profit(0, stake_currency, fiat_display_currency)
 
 
-def test_rpc_trade_statistics(
-        default_conf, ticker, ticker_sell_up, limit_buy_order, limit_sell_order, mocker) -> None:
-    """
-    Test rpc_trade_statistics() method
-    """
-    patch_get_signal(mocker, (True, False))
+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',
         ticker=MagicMock(return_value={'price_usd': 15000.0}),
     )
-    mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
-    mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock())
+    patch_coinmarketcap(mocker)
+    mocker.patch('freqtrade.rpc.rpc.CryptoToFiatConverter._find_price', return_value=15000.0)
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
-        get_ticker=ticker
+        get_ticker=ticker,
+        get_fee=fee,
+        get_markets=markets
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
+    patch_get_signal(freqtradebot, (True, False))
     stake_currency = default_conf['stake_currency']
     fiat_display_currency = default_conf['fiat_display_currency']
 
     rpc = RPC(freqtradebot)
+    rpc._fiat_converter = CryptoToFiatConverter()
 
-    (error, stats) = rpc.rpc_trade_statistics(stake_currency, fiat_display_currency)
-    assert error
-    assert stats.find('no closed trade') >= 0
+    with pytest.raises(RPCException, match=r'.*no closed trade*'):
+        rpc._rpc_trade_statistics(stake_currency, fiat_display_currency)
 
     # Create some test data
     freqtradebot.create_trade()
@@ -194,7 +180,7 @@ def test_rpc_trade_statistics(
 
     # Update the ticker with a market going up
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker_sell_up
     )
@@ -202,43 +188,56 @@ def test_rpc_trade_statistics(
     trade.close_date = datetime.utcnow()
     trade.is_open = False
 
-    (error, stats) = rpc.rpc_trade_statistics(stake_currency, fiat_display_currency)
-    assert not error
+    freqtradebot.create_trade()
+    trade = Trade.query.first()
+    # Simulate fulfilled LIMIT_BUY order for trade
+    trade.update(limit_buy_order)
+
+    # Update the ticker with a market going up
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        validate_pairs=MagicMock(),
+        get_ticker=ticker_sell_up
+    )
+    trade.update(limit_sell_order)
+    trade.close_date = datetime.utcnow()
+    trade.is_open = False
+
+    stats = rpc._rpc_trade_statistics(stake_currency, fiat_display_currency)
     assert prec_satoshi(stats['profit_closed_coin'], 6.217e-05)
     assert prec_satoshi(stats['profit_closed_percent'], 6.2)
     assert prec_satoshi(stats['profit_closed_fiat'], 0.93255)
-    assert prec_satoshi(stats['profit_all_coin'], 6.217e-05)
-    assert prec_satoshi(stats['profit_all_percent'], 6.2)
-    assert prec_satoshi(stats['profit_all_fiat'], 0.93255)
-    assert stats['trade_count'] == 1
+    assert prec_satoshi(stats['profit_all_coin'], 5.632e-05)
+    assert prec_satoshi(stats['profit_all_percent'], 2.81)
+    assert prec_satoshi(stats['profit_all_fiat'], 0.8448)
+    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'] == 'BTC_ETH'
+    assert stats['best_pair'] == 'ETH/BTC'
     assert prec_satoshi(stats['best_rate'], 6.2)
 
 
 # Test that rpc_trade_statistics can handle trades that lacks
 # trade.open_rate (it is set to None)
-def test_rpc_trade_statistics_closed(mocker, default_conf, ticker, ticker_sell_up, limit_buy_order,
-                                     limit_sell_order):
-    """
-    Test rpc_trade_statistics() method
-    """
-    patch_get_signal(mocker, (True, False))
+def test_rpc_trade_statistics_closed(mocker, default_conf, ticker, fee, markets,
+                                     ticker_sell_up, limit_buy_order, limit_sell_order):
     mocker.patch.multiple(
         'freqtrade.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.rpc_manager.Telegram', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
-        get_ticker=ticker
+        get_ticker=ticker,
+        get_fee=fee,
+        get_markets=markets
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
+    patch_get_signal(freqtradebot, (True, False))
     stake_currency = default_conf['stake_currency']
     fiat_display_currency = default_conf['fiat_display_currency']
 
@@ -251,9 +250,10 @@ def test_rpc_trade_statistics_closed(mocker, default_conf, ticker, ticker_sell_u
     trade.update(limit_buy_order)
     # Update the ticker with a market going up
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
-        get_ticker=ticker_sell_up
+        get_ticker=ticker_sell_up,
+        get_fee=fee
     )
     trade.update(limit_sell_order)
     trade.close_date = datetime.utcnow()
@@ -262,8 +262,7 @@ def test_rpc_trade_statistics_closed(mocker, default_conf, ticker, ticker_sell_u
     for trade in Trade.query.order_by(Trade.id).all():
         trade.open_rate = None
 
-    (error, stats) = rpc.rpc_trade_statistics(stake_currency, fiat_display_currency)
-    assert not error
+    stats = rpc._rpc_trade_statistics(stake_currency, fiat_display_currency)
     assert prec_satoshi(stats['profit_closed_coin'], 0)
     assert prec_satoshi(stats['profit_closed_percent'], 0)
     assert prec_satoshi(stats['profit_closed_fiat'], 0)
@@ -274,223 +273,217 @@ def test_rpc_trade_statistics_closed(mocker, default_conf, ticker, ticker_sell_u
     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'] == 'BTC_ETH'
+    assert stats['best_pair'] == 'ETH/BTC'
     assert prec_satoshi(stats['best_rate'], 6.2)
 
 
 def test_rpc_balance_handle(default_conf, mocker):
-    """
-    Test rpc_balance() method
-    """
-    mock_balance = [
-        {
-            'Currency': 'BTC',
-            'Balance': 10.0,
-            'Available': 12.0,
-            'Pending': 0.0,
-            'CryptoAddress': 'XXXX',
+    mock_balance = {
+        'BTC': {
+            'free': 10.0,
+            'total': 12.0,
+            'used': 2.0,
         },
-        {
-            'Currency': 'ETH',
-            'Balance': 0.0,
-            'Available': 0.0,
-            'Pending': 0.0,
-            'CryptoAddress': 'XXXX',
+        'ETH': {
+            'free': 0.0,
+            'total': 0.0,
+            'used': 0.0,
+        }
     }
-    ]
 
-    patch_get_signal(mocker, (True, False))
     mocker.patch.multiple(
         'freqtrade.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.rpc_manager.Telegram', MagicMock())
+    patch_coinmarketcap(mocker)
+    mocker.patch('freqtrade.rpc.rpc.CryptoToFiatConverter._find_price', return_value=15000.0)
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_balances=MagicMock(return_value=mock_balance)
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
+    patch_get_signal(freqtradebot, (True, False))
     rpc = RPC(freqtradebot)
+    rpc._fiat_converter = CryptoToFiatConverter()
 
-    (error, res) = rpc.rpc_balance(default_conf['fiat_display_currency'])
-    assert not error
-    (trade, x, y, z) = res
-    assert prec_satoshi(x, 10)
-    assert prec_satoshi(z, 150000)
-    assert 'USD' in y
-    assert len(trade) == 1
-    assert 'BTC' in trade[0]['currency']
-    assert prec_satoshi(trade[0]['available'], 12)
-    assert prec_satoshi(trade[0]['balance'], 10)
-    assert prec_satoshi(trade[0]['pending'], 0)
-    assert prec_satoshi(trade[0]['est_btc'], 10)
+    result = rpc._rpc_balance(default_conf['fiat_display_currency'])
+    assert prec_satoshi(result['total'], 12)
+    assert prec_satoshi(result['value'], 180000)
+    assert 'USD' == result['symbol']
+    assert result['currencies'] == [{
+        'currency': 'BTC',
+        'available': 10.0,
+        'balance': 12.0,
+        'pending': 2.0,
+        'est_btc': 12.0,
+    }]
 
 
 def test_rpc_start(mocker, default_conf) -> None:
-    """
-    Test rpc_start() method
-    """
-    patch_get_signal(mocker, (True, False))
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=MagicMock()
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
+    patch_get_signal(freqtradebot, (True, False))
     rpc = RPC(freqtradebot)
     freqtradebot.state = State.STOPPED
 
-    (error, result) = rpc.rpc_start()
-    assert not error
-    assert '`Starting trader ...`' in result
+    result = rpc._rpc_start()
+    assert {'status': 'starting trader ...'} == result
     assert freqtradebot.state == State.RUNNING
 
-    (error, result) = rpc.rpc_start()
-    assert error
-    assert '*Status:* `already running`' in result
+    result = rpc._rpc_start()
+    assert {'status': 'already running'} == result
     assert freqtradebot.state == State.RUNNING
 
 
 def test_rpc_stop(mocker, default_conf) -> None:
-    """
-    Test rpc_stop() method
-    """
-    patch_get_signal(mocker, (True, False))
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=MagicMock()
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
+    patch_get_signal(freqtradebot, (True, False))
     rpc = RPC(freqtradebot)
     freqtradebot.state = State.RUNNING
 
-    (error, result) = rpc.rpc_stop()
-    assert not error
-    assert '`Stopping trader ...`' in result
+    result = rpc._rpc_stop()
+    assert {'status': 'stopping trader ...'} == result
     assert freqtradebot.state == State.STOPPED
 
-    (error, result) = rpc.rpc_stop()
-    assert error
-    assert '*Status:* `already stopped`' in result
+    result = rpc._rpc_stop()
+
+    assert {'status': 'already stopped'} == result
     assert freqtradebot.state == State.STOPPED
 
 
-def test_rpc_forcesell(default_conf, ticker, mocker) -> None:
-    """
-    Test rpc_forcesell() method
-    """
-    patch_get_signal(mocker, (True, False))
+def test_rpc_forcesell(default_conf, ticker, fee, mocker, markets) -> None:
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
 
     cancel_order_mock = MagicMock()
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_ticker=ticker,
         cancel_order=cancel_order_mock,
         get_order=MagicMock(
             return_value={
-                'closed': True,
-                'type': 'LIMIT_BUY',
+                'status': 'closed',
+                'type': 'limit',
+                'side': 'buy'
             }
-        )
+        ),
+        get_fee=fee,
+        get_markets=markets
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
+    patch_get_signal(freqtradebot, (True, False))
     rpc = RPC(freqtradebot)
 
     freqtradebot.state = State.STOPPED
-    (error, res) = rpc.rpc_forcesell(None)
-    assert error
-    assert res == '`trader is not running`'
+    with pytest.raises(RPCException, match=r'.*trader is not running*'):
+        rpc._rpc_forcesell(None)
 
     freqtradebot.state = State.RUNNING
-    (error, res) = rpc.rpc_forcesell(None)
-    assert error
-    assert res == 'Invalid argument.'
+    with pytest.raises(RPCException, match=r'.*invalid argument*'):
+        rpc._rpc_forcesell(None)
 
-    (error, res) = rpc.rpc_forcesell('all')
-    assert not error
-    assert res == ''
+    rpc._rpc_forcesell('all')
 
     freqtradebot.create_trade()
-    (error, res) = rpc.rpc_forcesell('all')
-    assert not error
-    assert res == ''
+    rpc._rpc_forcesell('all')
 
-    (error, res) = rpc.rpc_forcesell('1')
-    assert not error
-    assert res == ''
+    rpc._rpc_forcesell('1')
 
     freqtradebot.state = State.STOPPED
-    (error, res) = rpc.rpc_forcesell(None)
-    assert error
-    assert res == '`trader is not running`'
+    with pytest.raises(RPCException, match=r'.*trader is not running*'):
+        rpc._rpc_forcesell(None)
 
-    (error, res) = rpc.rpc_forcesell('all')
-    assert error
-    assert res == '`trader is not running`'
+    with pytest.raises(RPCException, match=r'.*trader is not running*'):
+        rpc._rpc_forcesell('all')
 
     freqtradebot.state = State.RUNNING
     assert cancel_order_mock.call_count == 0
     # make an limit-buy open trade
+    trade = Trade.query.filter(Trade.id == '1').first()
+    filled_amount = trade.amount / 2
     mocker.patch(
-        'freqtrade.freqtradebot.exchange.get_order',
+        'freqtrade.exchange.Exchange.get_order',
         return_value={
-            'closed': None,
-            'type': 'LIMIT_BUY'
+            'status': 'open',
+            'type': 'limit',
+            'side': 'buy',
+            'filled': filled_amount
         }
     )
-    # check that the trade is called, which is done
-    # by ensuring exchange.cancel_order is called
-    (error, res) = rpc.rpc_forcesell('1')
-    assert not error
-    assert res == ''
+    # check that the trade is called, which is done by ensuring exchange.cancel_order is called
+    # and trade amount is updated
+    rpc._rpc_forcesell('1')
     assert cancel_order_mock.call_count == 1
+    assert trade.amount == filled_amount
+
+    freqtradebot.create_trade()
+    trade = Trade.query.filter(Trade.id == '2').first()
+    amount = trade.amount
+    # make an limit-buy open trade, if there is no 'filled', don't sell it
+    mocker.patch(
+        'freqtrade.exchange.Exchange.get_order',
+        return_value={
+            'status': 'open',
+            'type': 'limit',
+            'side': 'buy',
+            'filled': None
+        }
+    )
+    # check that the trade is called, which is done by ensuring exchange.cancel_order is called
+    rpc._rpc_forcesell('2')
+    assert cancel_order_mock.call_count == 2
+    assert trade.amount == amount
 
     freqtradebot.create_trade()
     # make an limit-sell open trade
     mocker.patch(
-        'freqtrade.freqtradebot.exchange.get_order',
+        'freqtrade.exchange.Exchange.get_order',
         return_value={
-            'closed': None,
-            'type': 'LIMIT_SELL'
+            'status': 'open',
+            'type': 'limit',
+            'side': 'sell'
         }
     )
-    (error, res) = rpc.rpc_forcesell('2')
-    assert not error
-    assert res == ''
+    rpc._rpc_forcesell('3')
     # status quo, no exchange calls
-    assert cancel_order_mock.call_count == 1
+    assert cancel_order_mock.call_count == 2
 
 
-def test_performance_handle(default_conf, ticker, limit_buy_order,
-                            limit_sell_order, mocker) -> None:
-    """
-    Test rpc_performance() method
-    """
-    patch_get_signal(mocker, (True, False))
+def test_performance_handle(default_conf, ticker, limit_buy_order, fee,
+                            limit_sell_order, markets, mocker) -> None:
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_balances=MagicMock(return_value=ticker),
-        get_ticker=ticker
+        get_ticker=ticker,
+        get_fee=fee,
+        get_markets=markets
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
+    patch_get_signal(freqtradebot, (True, False))
     rpc = RPC(freqtradebot)
 
     # Create some test data
@@ -506,39 +499,35 @@ def test_performance_handle(default_conf, ticker, limit_buy_order,
 
     trade.close_date = datetime.utcnow()
     trade.is_open = False
-    (error, res) = rpc.rpc_performance()
-    assert not error
+    res = rpc._rpc_performance()
     assert len(res) == 1
-    assert res[0]['pair'] == 'BTC_ETH'
+    assert res[0]['pair'] == 'ETH/BTC'
     assert res[0]['count'] == 1
     assert prec_satoshi(res[0]['profit'], 6.2)
 
 
-def test_rpc_count(mocker, default_conf, ticker) -> None:
-    """
-    Test rpc_count() method
-    """
-    patch_get_signal(mocker, (True, False))
+def test_rpc_count(mocker, default_conf, ticker, fee, markets) -> None:
     patch_coinmarketcap(mocker)
-    mocker.patch('freqtrade.rpc.rpc_manager.Telegram', MagicMock())
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
+        'freqtrade.exchange.Exchange',
         validate_pairs=MagicMock(),
         get_balances=MagicMock(return_value=ticker),
-        get_ticker=ticker
+        get_ticker=ticker,
+        get_fee=fee,
+        get_markets=markets
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
+    patch_get_signal(freqtradebot, (True, False))
     rpc = RPC(freqtradebot)
 
-    (error, trades) = rpc.rpc_count()
+    trades = rpc._rpc_count()
     nb_trades = len(trades)
-    assert not error
     assert nb_trades == 0
 
     # Create some test data
     freqtradebot.create_trade()
-    (error, trades) = rpc.rpc_count()
+    trades = rpc._rpc_count()
     nb_trades = len(trades)
-    assert not error
     assert nb_trades == 1

freqtrade/tests/rpc/test_rpc_manager.py

@@ -1,85 +1,45 @@
-"""
-Unit test file for rpc/rpc_manager.py
-"""
+# pragma pylint: disable=missing-docstring, C0103
 
 import logging
-from copy import deepcopy
 from unittest.mock import MagicMock
 
-from freqtrade.rpc.rpc_manager import RPCManager
-from freqtrade.rpc.telegram import Telegram
+from freqtrade.rpc import RPCMessageType, RPCManager
 from freqtrade.tests.conftest import log_has, get_patched_freqtradebot
 
 
-def test_rpc_manager_object() -> None:
-    """
-    Test the Arguments object has the mandatory methods
-    :return: None
-    """
-    assert hasattr(RPCManager, '_init')
-    assert hasattr(RPCManager, 'send_msg')
-    assert hasattr(RPCManager, 'cleanup')
-
-
 def test__init__(mocker, default_conf) -> None:
-    """
-    Test __init__() method
-    """
-    init_mock = mocker.patch('freqtrade.rpc.rpc_manager.RPCManager._init', MagicMock())
-    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
+    default_conf['telegram']['enabled'] = False
 
-    rpc_manager = RPCManager(freqtradebot)
-    assert rpc_manager.freqtrade == freqtradebot
+    rpc_manager = RPCManager(get_patched_freqtradebot(mocker, default_conf))
     assert rpc_manager.registered_modules == []
-    assert rpc_manager.telegram is None
-    assert init_mock.call_count == 1
 
 
 def test_init_telegram_disabled(mocker, default_conf, caplog) -> None:
-    """
-    Test _init() method with Telegram disabled
-    """
     caplog.set_level(logging.DEBUG)
-
-    conf = deepcopy(default_conf)
-    conf['telegram']['enabled'] = False
-
-    freqtradebot = get_patched_freqtradebot(mocker, conf)
-    rpc_manager = RPCManager(freqtradebot)
+    default_conf['telegram']['enabled'] = False
+    rpc_manager = RPCManager(get_patched_freqtradebot(mocker, default_conf))
 
     assert not log_has('Enabling rpc.telegram ...', caplog.record_tuples)
     assert rpc_manager.registered_modules == []
-    assert rpc_manager.telegram is None
 
 
 def test_init_telegram_enabled(mocker, default_conf, caplog) -> None:
-    """
-    Test _init() method with Telegram enabled
-    """
     caplog.set_level(logging.DEBUG)
     mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock())
-
-    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
-    rpc_manager = RPCManager(freqtradebot)
+    rpc_manager = RPCManager(get_patched_freqtradebot(mocker, default_conf))
 
     assert log_has('Enabling rpc.telegram ...', caplog.record_tuples)
     len_modules = len(rpc_manager.registered_modules)
     assert len_modules == 1
-    assert 'telegram' in rpc_manager.registered_modules
-    assert isinstance(rpc_manager.telegram, Telegram)
+    assert 'telegram' in [mod.name for mod in rpc_manager.registered_modules]
 
 
 def test_cleanup_telegram_disabled(mocker, default_conf, caplog) -> None:
-    """
-    Test cleanup() method with Telegram disabled
-    """
     caplog.set_level(logging.DEBUG)
     telegram_mock = mocker.patch('freqtrade.rpc.telegram.Telegram.cleanup', MagicMock())
+    default_conf['telegram']['enabled'] = False
 
-    conf = deepcopy(default_conf)
-    conf['telegram']['enabled'] = False
-
-    freqtradebot = get_patched_freqtradebot(mocker, conf)
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
     rpc_manager = RPCManager(freqtradebot)
     rpc_manager.cleanup()
 
@@ -88,9 +48,6 @@ def test_cleanup_telegram_disabled(mocker, default_conf, caplog) -> None:
 
 
 def test_cleanup_telegram_enabled(mocker, default_conf, caplog) -> None:
-    """
-    Test cleanup() method with Telegram enabled
-    """
     caplog.set_level(logging.DEBUG)
     mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock())
     telegram_mock = mocker.patch('freqtrade.rpc.telegram.Telegram.cleanup', MagicMock())
@@ -99,41 +56,60 @@ def test_cleanup_telegram_enabled(mocker, default_conf, caplog) -> None:
     rpc_manager = RPCManager(freqtradebot)
 
     # Check we have Telegram as a registered modules
-    assert 'telegram' in rpc_manager.registered_modules
+    assert 'telegram' in [mod.name for mod in rpc_manager.registered_modules]
 
     rpc_manager.cleanup()
     assert log_has('Cleaning up rpc.telegram ...', caplog.record_tuples)
-    assert 'telegram' not in rpc_manager.registered_modules
+    assert 'telegram' not in [mod.name for mod in rpc_manager.registered_modules]
     assert telegram_mock.call_count == 1
 
 
 def test_send_msg_telegram_disabled(mocker, default_conf, caplog) -> None:
-    """
-    Test send_msg() method with Telegram disabled
-    """
     telegram_mock = mocker.patch('freqtrade.rpc.telegram.Telegram.send_msg', MagicMock())
+    default_conf['telegram']['enabled'] = False
 
-    conf = deepcopy(default_conf)
-    conf['telegram']['enabled'] = False
-
-    freqtradebot = get_patched_freqtradebot(mocker, conf)
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
     rpc_manager = RPCManager(freqtradebot)
-    rpc_manager.send_msg('test')
+    rpc_manager.send_msg({
+        'type': RPCMessageType.STATUS_NOTIFICATION,
+        'status': 'test'
+    })
 
-    assert log_has('test', caplog.record_tuples)
+    assert log_has("Sending rpc message: {'type': status, 'status': 'test'}", caplog.record_tuples)
     assert telegram_mock.call_count == 0
 
 
 def test_send_msg_telegram_enabled(mocker, default_conf, caplog) -> None:
-    """
-    Test send_msg() method with Telegram disabled
-    """
     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.send_msg('test')
+    rpc_manager.send_msg({
+        'type': RPCMessageType.STATUS_NOTIFICATION,
+        'status': 'test'
+    })
 
-    assert log_has('test', caplog.record_tuples)
+    assert log_has("Sending rpc message: {'type': status, 'status': 'test'}", caplog.record_tuples)
     assert telegram_mock.call_count == 1
+
+
+def test_init_webhook_disabled(mocker, default_conf, caplog) -> None:
+    caplog.set_level(logging.DEBUG)
+    default_conf['telegram']['enabled'] = False
+    default_conf['webhook'] = {'enabled': False}
+    rpc_manager = RPCManager(get_patched_freqtradebot(mocker, default_conf))
+
+    assert not log_has('Enabling rpc.webhook ...', caplog.record_tuples)
+    assert rpc_manager.registered_modules == []
+
+
+def test_init_webhook_enabled(mocker, default_conf, caplog) -> None:
+    caplog.set_level(logging.DEBUG)
+    default_conf['telegram']['enabled'] = False
+    default_conf['webhook'] = {'enabled': True, 'url': "https://DEADBEEF.com"}
+    rpc_manager = RPCManager(get_patched_freqtradebot(mocker, default_conf))
+
+    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]

freqtrade/tests/rpc/test_rpc_webhook.py

@@ -0,0 +1,166 @@
+# pragma pylint: disable=missing-docstring, C0103, protected-access
+
+from unittest.mock import MagicMock
+
+import pytest
+from requests import RequestException
+
+from freqtrade.rpc import RPCMessageType
+from freqtrade.rpc.webhook import Webhook
+from freqtrade.tests.conftest import get_patched_freqtradebot, log_has
+
+
+def get_webhook_dict() -> dict:
+    return {
+          "enabled": True,
+          "url": "https://maker.ifttt.com/trigger/freqtrade_test/with/key/c764udvJ5jfSlswVRukZZ2/",
+          "webhookbuy": {
+              "value1": "Buying {pair}",
+              "value2": "limit {limit:8f}",
+              "value3": "{stake_amount:8f} {stake_currency}"
+          },
+          "webhooksell": {
+              "value1": "Selling {pair}",
+              "value2": "limit {limit:8f}",
+              "value3": "profit: {profit_amount:8f} {stake_currency}"
+          },
+          "webhookstatus": {
+              "value1": "Status: {status}",
+              "value2": "",
+              "value3": ""
+          }
+      }
+
+
+def test__init__(mocker, default_conf):
+    default_conf['webhook'] = {'enabled': True, 'url': "https://DEADBEEF.com"}
+    webhook = Webhook(get_patched_freqtradebot(mocker, default_conf))
+    assert webhook._config == default_conf
+
+
+def test_send_msg(default_conf, mocker):
+    default_conf["webhook"] = get_webhook_dict()
+    msg_mock = MagicMock()
+    mocker.patch("freqtrade.rpc.webhook.Webhook._send_msg", msg_mock)
+    webhook = Webhook(get_patched_freqtradebot(mocker, default_conf))
+    msg = {
+        'type': RPCMessageType.BUY_NOTIFICATION,
+        'exchange': 'Bittrex',
+        'pair': 'ETH/BTC',
+        'market_url': "http://mockedurl/ETH_BTC",
+        'limit': 0.005,
+        'stake_amount': 0.8,
+        'stake_amount_fiat': 500,
+        'stake_currency': 'BTC',
+        'fiat_currency': 'EUR'
+    }
+    msg_mock = MagicMock()
+    mocker.patch("freqtrade.rpc.webhook.Webhook._send_msg", msg_mock)
+    webhook.send_msg(msg=msg)
+    assert msg_mock.call_count == 1
+    assert (msg_mock.call_args[0][0]["value1"] ==
+            default_conf["webhook"]["webhookbuy"]["value1"].format(**msg))
+    assert (msg_mock.call_args[0][0]["value2"] ==
+            default_conf["webhook"]["webhookbuy"]["value2"].format(**msg))
+    assert (msg_mock.call_args[0][0]["value3"] ==
+            default_conf["webhook"]["webhookbuy"]["value3"].format(**msg))
+    # Test sell
+    msg_mock = MagicMock()
+    mocker.patch("freqtrade.rpc.webhook.Webhook._send_msg", msg_mock)
+    msg = {
+        'type': RPCMessageType.SELL_NOTIFICATION,
+        'exchange': 'Bittrex',
+        'pair': 'ETH/BTC',
+        'gain': "profit",
+        'market_url': "http://mockedurl/ETH_BTC",
+        'limit': 0.005,
+        'amount': 0.8,
+        'open_rate': 0.004,
+        'current_rate': 0.005,
+        'profit_amount': 0.001,
+        'profit_percent': 0.20,
+        'stake_currency': 'BTC',
+    }
+    webhook.send_msg(msg=msg)
+    assert msg_mock.call_count == 1
+    assert (msg_mock.call_args[0][0]["value1"] ==
+            default_conf["webhook"]["webhooksell"]["value1"].format(**msg))
+    assert (msg_mock.call_args[0][0]["value2"] ==
+            default_conf["webhook"]["webhooksell"]["value2"].format(**msg))
+    assert (msg_mock.call_args[0][0]["value3"] ==
+            default_conf["webhook"]["webhooksell"]["value3"].format(**msg))
+
+    # Test notification
+    msg = {
+        'type': RPCMessageType.STATUS_NOTIFICATION,
+        'status': 'Unfilled sell order for BTC cancelled due to timeout'
+    }
+    msg_mock = MagicMock()
+    mocker.patch("freqtrade.rpc.webhook.Webhook._send_msg", msg_mock)
+    webhook.send_msg(msg)
+    assert msg_mock.call_count == 1
+    assert (msg_mock.call_args[0][0]["value1"] ==
+            default_conf["webhook"]["webhookstatus"]["value1"].format(**msg))
+    assert (msg_mock.call_args[0][0]["value2"] ==
+            default_conf["webhook"]["webhookstatus"]["value2"].format(**msg))
+    assert (msg_mock.call_args[0][0]["value3"] ==
+            default_conf["webhook"]["webhookstatus"]["value3"].format(**msg))
+
+
+def test_exception_send_msg(default_conf, mocker, caplog):
+    default_conf["webhook"] = get_webhook_dict()
+    default_conf["webhook"]["webhookbuy"] = None
+
+    webhook = Webhook(get_patched_freqtradebot(mocker, default_conf))
+    webhook.send_msg({'type': RPCMessageType.BUY_NOTIFICATION})
+    assert log_has(f"Message type {RPCMessageType.BUY_NOTIFICATION} not configured for webhooks",
+                   caplog.record_tuples)
+
+    default_conf["webhook"] = get_webhook_dict()
+    default_conf["webhook"]["webhookbuy"]["value1"] = "{DEADBEEF:8f}"
+    msg_mock = MagicMock()
+    mocker.patch("freqtrade.rpc.webhook.Webhook._send_msg", msg_mock)
+    webhook = Webhook(get_patched_freqtradebot(mocker, default_conf))
+    msg = {
+        'type': RPCMessageType.BUY_NOTIFICATION,
+        'exchange': 'Bittrex',
+        'pair': 'ETH/BTC',
+        'market_url': "http://mockedurl/ETH_BTC",
+        'limit': 0.005,
+        'stake_amount': 0.8,
+        'stake_amount_fiat': 500,
+        'stake_currency': 'BTC',
+        'fiat_currency': 'EUR'
+    }
+    webhook.send_msg(msg)
+    assert log_has("Problem calling Webhook. Please check your webhook configuration. "
+                   "Exception: 'DEADBEEF'", caplog.record_tuples)
+
+    msg_mock = MagicMock()
+    mocker.patch("freqtrade.rpc.webhook.Webhook._send_msg", msg_mock)
+    msg = {
+        'type': 'DEADBEEF',
+        'status': 'whatever'
+    }
+    with pytest.raises(NotImplementedError):
+        webhook.send_msg(msg)
+
+
+def test__send_msg(default_conf, mocker, caplog):
+    default_conf["webhook"] = get_webhook_dict()
+    webhook = Webhook(get_patched_freqtradebot(mocker, default_conf))
+    msg = {'value1': 'DEADBEEF',
+           'value2': 'ALIVEBEEF',
+           'value3': 'FREQTRADE'}
+    post = MagicMock()
+    mocker.patch("freqtrade.rpc.webhook.post", post)
+    webhook._send_msg(msg)
+
+    assert post.call_count == 1
+    assert post.call_args[1] == {'data': msg}
+    assert post.call_args[0] == (default_conf['webhook']['url'], )
+
+    post = MagicMock(side_effect=RequestException)
+    mocker.patch("freqtrade.rpc.webhook.post", post)
+    webhook._send_msg(msg)
+    assert log_has('Could not call webhook url. Exception: ', caplog.record_tuples)

freqtrade/tests/strategy/legacy_strategy.py

@@ -0,0 +1,235 @@
+
+# --- Do not remove these libs ---
+from freqtrade.strategy.interface import IStrategy
+from pandas import DataFrame
+# --------------------------------
+
+# Add your lib to import here
+import talib.abstract as ta
+import freqtrade.vendor.qtpylib.indicators as qtpylib
+import numpy  # noqa
+
+
+# This class is a sample. Feel free to customize it.
+class TestStrategyLegacy(IStrategy):
+    """
+    This is a test strategy using the legacy function headers, which will be
+    removed in a future update.
+    Please do not use this as a template, but refer to user_data/strategy/TestStrategy.py
+    for a uptodate version of this template.
+
+    """
+
+    # Minimal ROI designed for the strategy.
+    # This attribute will be overridden if the config file contains "minimal_roi"
+    minimal_roi = {
+        "40": 0.0,
+        "30": 0.01,
+        "20": 0.02,
+        "0": 0.04
+    }
+
+    # Optimal stoploss designed for the strategy
+    # This attribute will be overridden if the config file contains "stoploss"
+    stoploss = -0.10
+
+    # Optimal ticker interval for the strategy
+    ticker_interval = '5m'
+
+    def populate_indicators(self, dataframe: DataFrame) -> DataFrame:
+        """
+        Adds several different TA indicators to the given DataFrame
+
+        Performance Note: For the best performance be frugal on the number of indicators
+        you are using. Let uncomment only the indicator you are using in your strategies
+        or your hyperopt configuration, otherwise you will waste your memory and CPU usage.
+        """
+
+        # Momentum Indicator
+        # ------------------------------------
+
+        # ADX
+        dataframe['adx'] = ta.ADX(dataframe)
+
+        """
+        # Awesome oscillator
+        dataframe['ao'] = qtpylib.awesome_oscillator(dataframe)
+
+        # Commodity Channel Index: values Oversold:<-100, Overbought:>100
+        dataframe['cci'] = ta.CCI(dataframe)
+
+        # MACD
+        macd = ta.MACD(dataframe)
+        dataframe['macd'] = macd['macd']
+        dataframe['macdsignal'] = macd['macdsignal']
+        dataframe['macdhist'] = macd['macdhist']
+
+        # MFI
+        dataframe['mfi'] = ta.MFI(dataframe)
+
+        # Minus Directional Indicator / Movement
+        dataframe['minus_dm'] = ta.MINUS_DM(dataframe)
+        dataframe['minus_di'] = ta.MINUS_DI(dataframe)
+
+        # Plus Directional Indicator / Movement
+        dataframe['plus_dm'] = ta.PLUS_DM(dataframe)
+        dataframe['plus_di'] = ta.PLUS_DI(dataframe)
+        dataframe['minus_di'] = ta.MINUS_DI(dataframe)
+
+        # ROC
+        dataframe['roc'] = ta.ROC(dataframe)
+
+        # RSI
+        dataframe['rsi'] = ta.RSI(dataframe)
+
+        # Inverse Fisher transform on RSI, values [-1.0, 1.0] (https://goo.gl/2JGGoy)
+        rsi = 0.1 * (dataframe['rsi'] - 50)
+        dataframe['fisher_rsi'] = (numpy.exp(2 * rsi) - 1) / (numpy.exp(2 * rsi) + 1)
+
+        # Inverse Fisher transform on RSI normalized, value [0.0, 100.0] (https://goo.gl/2JGGoy)
+        dataframe['fisher_rsi_norma'] = 50 * (dataframe['fisher_rsi'] + 1)
+
+        # Stoch
+        stoch = ta.STOCH(dataframe)
+        dataframe['slowd'] = stoch['slowd']
+        dataframe['slowk'] = stoch['slowk']
+
+        # Stoch fast
+        stoch_fast = ta.STOCHF(dataframe)
+        dataframe['fastd'] = stoch_fast['fastd']
+        dataframe['fastk'] = stoch_fast['fastk']
+
+        # Stoch RSI
+        stoch_rsi = ta.STOCHRSI(dataframe)
+        dataframe['fastd_rsi'] = stoch_rsi['fastd']
+        dataframe['fastk_rsi'] = stoch_rsi['fastk']
+        """
+
+        # Overlap Studies
+        # ------------------------------------
+
+        # Bollinger bands
+        bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2)
+        dataframe['bb_lowerband'] = bollinger['lower']
+        dataframe['bb_middleband'] = bollinger['mid']
+        dataframe['bb_upperband'] = bollinger['upper']
+
+        """
+        # EMA - Exponential Moving Average
+        dataframe['ema3'] = ta.EMA(dataframe, timeperiod=3)
+        dataframe['ema5'] = ta.EMA(dataframe, timeperiod=5)
+        dataframe['ema10'] = ta.EMA(dataframe, timeperiod=10)
+        dataframe['ema50'] = ta.EMA(dataframe, timeperiod=50)
+        dataframe['ema100'] = ta.EMA(dataframe, timeperiod=100)
+
+        # SAR Parabol
+        dataframe['sar'] = ta.SAR(dataframe)
+
+        # SMA - Simple Moving Average
+        dataframe['sma'] = ta.SMA(dataframe, timeperiod=40)
+        """
+
+        # TEMA - Triple Exponential Moving Average
+        dataframe['tema'] = ta.TEMA(dataframe, timeperiod=9)
+
+        # Cycle Indicator
+        # ------------------------------------
+        # Hilbert Transform Indicator - SineWave
+        hilbert = ta.HT_SINE(dataframe)
+        dataframe['htsine'] = hilbert['sine']
+        dataframe['htleadsine'] = hilbert['leadsine']
+
+        # Pattern Recognition - Bullish candlestick patterns
+        # ------------------------------------
+        """
+        # Hammer: values [0, 100]
+        dataframe['CDLHAMMER'] = ta.CDLHAMMER(dataframe)
+        # Inverted Hammer: values [0, 100]
+        dataframe['CDLINVERTEDHAMMER'] = ta.CDLINVERTEDHAMMER(dataframe)
+        # Dragonfly Doji: values [0, 100]
+        dataframe['CDLDRAGONFLYDOJI'] = ta.CDLDRAGONFLYDOJI(dataframe)
+        # Piercing Line: values [0, 100]
+        dataframe['CDLPIERCING'] = ta.CDLPIERCING(dataframe) # values [0, 100]
+        # Morningstar: values [0, 100]
+        dataframe['CDLMORNINGSTAR'] = ta.CDLMORNINGSTAR(dataframe) # values [0, 100]
+        # Three White Soldiers: values [0, 100]
+        dataframe['CDL3WHITESOLDIERS'] = ta.CDL3WHITESOLDIERS(dataframe) # values [0, 100]
+        """
+
+        # Pattern Recognition - Bearish candlestick patterns
+        # ------------------------------------
+        """
+        # Hanging Man: values [0, 100]
+        dataframe['CDLHANGINGMAN'] = ta.CDLHANGINGMAN(dataframe)
+        # Shooting Star: values [0, 100]
+        dataframe['CDLSHOOTINGSTAR'] = ta.CDLSHOOTINGSTAR(dataframe)
+        # Gravestone Doji: values [0, 100]
+        dataframe['CDLGRAVESTONEDOJI'] = ta.CDLGRAVESTONEDOJI(dataframe)
+        # Dark Cloud Cover: values [0, 100]
+        dataframe['CDLDARKCLOUDCOVER'] = ta.CDLDARKCLOUDCOVER(dataframe)
+        # Evening Doji Star: values [0, 100]
+        dataframe['CDLEVENINGDOJISTAR'] = ta.CDLEVENINGDOJISTAR(dataframe)
+        # Evening Star: values [0, 100]
+        dataframe['CDLEVENINGSTAR'] = ta.CDLEVENINGSTAR(dataframe)
+        """
+
+        # Pattern Recognition - Bullish/Bearish candlestick patterns
+        # ------------------------------------
+        """
+        # Three Line Strike: values [0, -100, 100]
+        dataframe['CDL3LINESTRIKE'] = ta.CDL3LINESTRIKE(dataframe)
+        # Spinning Top: values [0, -100, 100]
+        dataframe['CDLSPINNINGTOP'] = ta.CDLSPINNINGTOP(dataframe) # values [0, -100, 100]
+        # Engulfing: values [0, -100, 100]
+        dataframe['CDLENGULFING'] = ta.CDLENGULFING(dataframe) # values [0, -100, 100]
+        # Harami: values [0, -100, 100]
+        dataframe['CDLHARAMI'] = ta.CDLHARAMI(dataframe) # values [0, -100, 100]
+        # Three Outside Up/Down: values [0, -100, 100]
+        dataframe['CDL3OUTSIDE'] = ta.CDL3OUTSIDE(dataframe) # values [0, -100, 100]
+        # Three Inside Up/Down: values [0, -100, 100]
+        dataframe['CDL3INSIDE'] = ta.CDL3INSIDE(dataframe) # values [0, -100, 100]
+        """
+
+        # Chart type
+        # ------------------------------------
+        """
+        # Heikinashi stategy
+        heikinashi = qtpylib.heikinashi(dataframe)
+        dataframe['ha_open'] = heikinashi['open']
+        dataframe['ha_close'] = heikinashi['close']
+        dataframe['ha_high'] = heikinashi['high']
+        dataframe['ha_low'] = heikinashi['low']
+        """
+
+        return dataframe
+
+    def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
+        """
+        Based on TA indicators, populates the buy signal for the given dataframe
+        :param dataframe: DataFrame
+        :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
+
+    def populate_sell_trend(self, dataframe: DataFrame) -> DataFrame:
+        """
+        Based on TA indicators, populates the sell signal for the given dataframe
+        :param dataframe: DataFrame
+        :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

freqtrade/tests/strategy/test_default_strategy.py

@@ -3,14 +3,14 @@ import json
 import pytest
 from pandas import DataFrame
 
-from freqtrade.analyze import Analyze
+from freqtrade.exchange.exchange_helpers import parse_ticker_dataframe
 from freqtrade.strategy.default_strategy import DefaultStrategy
 
 
 @pytest.fixture
 def result():
-    with open('freqtrade/tests/testdata/BTC_ETH-1.json') as data_file:
-        return Analyze.parse_ticker_dataframe(json.load(data_file))
+    with open('freqtrade/tests/testdata/ETH_BTC-1m.json') as data_file:
+        return parse_ticker_dataframe(json.load(data_file))
 
 
 def test_default_strategy_structure():
@@ -23,12 +23,13 @@ def test_default_strategy_structure():
 
 
 def test_default_strategy(result):
-    strategy = DefaultStrategy()
+    strategy = DefaultStrategy({})
 
+    metadata = {'pair': 'ETH/BTC'}
     assert type(strategy.minimal_roi) is dict
     assert type(strategy.stoploss) is float
-    assert type(strategy.ticker_interval) is int
-    indicators = strategy.populate_indicators(result)
+    assert type(strategy.ticker_interval) is str
+    indicators = strategy.populate_indicators(result, metadata)
     assert type(indicators) is DataFrame
-    assert type(strategy.populate_buy_trend(indicators)) is DataFrame
-    assert type(strategy.populate_sell_trend(indicators)) is DataFrame
+    assert type(strategy.populate_buy_trend(indicators, metadata)) is DataFrame
+    assert type(strategy.populate_sell_trend(indicators, metadata)) is DataFrame

freqtrade/tests/strategy/test_interface.py

@@ -0,0 +1,107 @@
+# pragma pylint: disable=missing-docstring, C0103
+
+import logging
+from unittest.mock import MagicMock
+
+import arrow
+from pandas import DataFrame
+
+from freqtrade.arguments import TimeRange
+from freqtrade.optimize.__init__ import load_tickerdata_file
+from freqtrade.tests.conftest import get_patched_exchange, log_has
+from freqtrade.strategy.default_strategy import DefaultStrategy
+
+# Avoid to reinit the same object again and again
+_STRATEGY = DefaultStrategy(config={})
+
+
+def test_returns_latest_buy_signal(mocker, default_conf):
+    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)
+
+    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)
+
+
+def test_returns_latest_sell_signal(mocker, default_conf):
+    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)
+
+    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)
+
+
+def test_get_signal_empty(default_conf, mocker, caplog):
+    assert (False, False) == _STRATEGY.get_signal('foo', default_conf['ticker_interval'],
+                                                  None)
+    assert log_has('Empty ticker history for pair foo', caplog.record_tuples)
+
+
+def test_get_signal_exception_valueerror(default_conf, mocker, caplog):
+    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 log_has('Unable to analyze ticker for pair foo: xyz', caplog.record_tuples)
+
+
+def test_get_signal_empty_dataframe(default_conf, mocker, caplog):
+    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 log_has('Empty dataframe for pair xyz', caplog.record_tuples)
+
+
+def test_get_signal_old_dataframe(default_conf, mocker, caplog):
+    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
+    oldtime = arrow.utcnow().shift(minutes=-16)
+    ticks = DataFrame([{'buy': 1, 'date': oldtime}])
+    mocker.patch.object(
+        _STRATEGY, 'analyze_ticker',
+        return_value=DataFrame(ticks)
+    )
+    assert (False, False) == _STRATEGY.get_signal('xyz', default_conf['ticker_interval'], 1)
+    assert log_has(
+        'Outdated history for pair xyz. Last tick is 16 minutes old',
+        caplog.record_tuples
+    )
+
+
+def test_get_signal_handles_exceptions(mocker, default_conf):
+    mocker.patch('freqtrade.exchange.Exchange.get_candle_history', return_value=MagicMock())
+    exchange = get_patched_exchange(mocker, default_conf)
+    mocker.patch.object(
+        _STRATEGY, 'analyze_ticker',
+        side_effect=Exception('invalid ticker history ')
+    )
+    assert _STRATEGY.get_signal(exchange, 'ETH/BTC', '5m') == (False, False)
+
+
+def test_tickerdata_to_dataframe(default_conf) -> None:
+    strategy = DefaultStrategy(default_conf)
+
+    timerange = TimeRange(None, 'line', 0, -100)
+    tick = load_tickerdata_file(None, 'UNITTEST/BTC', '1m', timerange=timerange)
+    tickerlist = {'UNITTEST/BTC': tick}
+    data = strategy.tickerdata_to_dataframe(tickerlist)
+    assert len(data['UNITTEST/BTC']) == 99       # partial candle was removed

freqtrade/tests/strategy/test_strategy.py

@@ -1,41 +1,88 @@
 # pragma pylint: disable=missing-docstring, protected-access, C0103
-
 import logging
-import os
+from base64 import urlsafe_b64encode
+from os import path
+import warnings
 
 import pytest
+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
 
 
+def test_import_strategy(caplog):
+    caplog.set_level(logging.DEBUG)
+    default_config = {}
+
+    strategy = DefaultStrategy(default_config)
+    strategy.some_method = lambda *args, **kwargs: 42
+
+    assert strategy.__module__ == 'freqtrade.strategy.default_strategy'
+    assert strategy.some_method() == 42
+
+    imported_strategy = import_strategy(strategy, default_config)
+
+    assert dir(strategy) == dir(imported_strategy)
+
+    assert imported_strategy.__module__ == 'freqtrade.strategy'
+    assert imported_strategy.some_method() == 42
+
+    assert (
+        'freqtrade.strategy',
+        logging.DEBUG,
+        'Imported strategy freqtrade.strategy.default_strategy.DefaultStrategy '
+        'as freqtrade.strategy.DefaultStrategy',
+    ) in caplog.record_tuples
+
+
 def test_search_strategy():
-    default_location = os.path.join(os.path.dirname(
-        os.path.realpath(__file__)), '..', '..', 'strategy'
+    default_config = {}
+    default_location = path.join(path.dirname(
+        path.realpath(__file__)), '..', '..', 'strategy'
     )
     assert isinstance(
-        StrategyResolver._search_strategy(default_location, 'DefaultStrategy'), IStrategy
+        StrategyResolver._search_strategy(
+            default_location,
+            config=default_config,
+            strategy_name='DefaultStrategy'
+        ),
+        IStrategy
     )
-    assert StrategyResolver._search_strategy(default_location, 'NotFoundStrategy') is None
+    assert StrategyResolver._search_strategy(
+        default_location,
+        config=default_config,
+        strategy_name='NotFoundStrategy'
+    ) is None
 
 
 def test_load_strategy(result):
+    resolver = StrategyResolver({'strategy': 'TestStrategy'})
+    metadata = {'pair': 'ETH/BTC'}
+    assert 'adx' in resolver.strategy.advise_indicators(result, metadata=metadata)
+
+
+def test_load_strategy_byte64(result):
+    with open("freqtrade/tests/strategy/test_strategy.py", "r") as file:
+        encoded_string = urlsafe_b64encode(file.read().encode("utf-8")).decode("utf-8")
+    resolver = StrategyResolver({'strategy': 'TestStrategy:{}'.format(encoded_string)})
+    assert 'adx' in resolver.strategy.advise_indicators(result, 'ETH/BTC')
+
+
+def test_load_strategy_invalid_directory(result, caplog):
     resolver = StrategyResolver()
-    resolver._load_strategy('TestStrategy')
-    assert hasattr(resolver.strategy, 'populate_indicators')
-    assert 'adx' in resolver.strategy.populate_indicators(result)
+    extra_dir = path.join('some', 'path')
+    resolver._load_strategy('TestStrategy', config={}, extra_dir=extra_dir)
 
+    assert (
+        'freqtrade.strategy.resolver',
+        logging.WARNING,
+        'Path "{}" does not exist'.format(extra_dir),
+    ) in caplog.record_tuples
 
-def test_load_strategy_custom_directory(result):
-    resolver = StrategyResolver()
-    extra_dir = os.path.join('some', 'path')
-    with pytest.raises(
-            FileNotFoundError,
-            match=r".*No such file or directory: '{}'".format(extra_dir)):
-        resolver._load_strategy('TestStrategy', extra_dir)
-
-    assert hasattr(resolver.strategy, 'populate_indicators')
-    assert 'adx' in resolver.strategy.populate_indicators(result)
+    assert 'adx' in resolver.strategy.advise_indicators(result, {'pair': 'ETH/BTC'})
 
 
 def test_load_not_found_strategy():
@@ -43,27 +90,30 @@ def test_load_not_found_strategy():
     with pytest.raises(ImportError,
                        match=r'Impossible to load Strategy \'NotFoundStrategy\'.'
                              r' This class does not exist or contains Python code errors'):
-        strategy._load_strategy('NotFoundStrategy')
+        strategy._load_strategy(strategy_name='NotFoundStrategy', config={})
 
 
 def test_strategy(result):
-    resolver = StrategyResolver({'strategy': 'DefaultStrategy'})
+    config = {'strategy': 'DefaultStrategy'}
 
-    assert hasattr(resolver.strategy, 'minimal_roi')
+    resolver = StrategyResolver(config)
+    metadata = {'pair': 'ETH/BTC'}
     assert resolver.strategy.minimal_roi[0] == 0.04
+    assert config["minimal_roi"]['0'] == 0.04
 
-    assert hasattr(resolver.strategy, 'stoploss')
     assert resolver.strategy.stoploss == -0.10
+    assert config['stoploss'] == -0.10
 
-    assert hasattr(resolver.strategy, 'populate_indicators')
-    assert 'adx' in resolver.strategy.populate_indicators(result)
+    assert resolver.strategy.ticker_interval == '5m'
+    assert config['ticker_interval'] == '5m'
 
-    assert hasattr(resolver.strategy, 'populate_buy_trend')
-    dataframe = resolver.strategy.populate_buy_trend(resolver.strategy.populate_indicators(result))
+    df_indicators = resolver.strategy.advise_indicators(result, metadata=metadata)
+    assert 'adx' in df_indicators
+
+    dataframe = resolver.strategy.advise_buy(df_indicators, metadata=metadata)
     assert 'buy' in dataframe.columns
 
-    assert hasattr(resolver.strategy, 'populate_sell_trend')
-    dataframe = resolver.strategy.populate_sell_trend(resolver.strategy.populate_indicators(result))
+    dataframe = resolver.strategy.advise_sell(df_indicators, metadata=metadata)
     assert 'sell' in dataframe.columns
 
 
@@ -77,7 +127,6 @@ def test_strategy_override_minimal_roi(caplog):
     }
     resolver = StrategyResolver(config)
 
-    assert hasattr(resolver.strategy, 'minimal_roi')
     assert resolver.strategy.minimal_roi[0] == 0.5
     assert ('freqtrade.strategy.resolver',
             logging.INFO,
@@ -93,7 +142,6 @@ def test_strategy_override_stoploss(caplog):
     }
     resolver = StrategyResolver(config)
 
-    assert hasattr(resolver.strategy, 'stoploss')
     assert resolver.strategy.stoploss == -0.5
     assert ('freqtrade.strategy.resolver',
             logging.INFO,
@@ -110,9 +158,64 @@ def test_strategy_override_ticker_interval(caplog):
     }
     resolver = StrategyResolver(config)
 
-    assert hasattr(resolver.strategy, 'ticker_interval')
     assert resolver.strategy.ticker_interval == 60
     assert ('freqtrade.strategy.resolver',
             logging.INFO,
             'Override strategy \'ticker_interval\' with value in config file: 60.'
             ) in caplog.record_tuples
+
+
+def test_deprecate_populate_indicators(result):
+    default_location = path.join(path.dirname(path.realpath(__file__)))
+    resolver = StrategyResolver({'strategy': 'TestStrategyLegacy',
+                                 'strategy_path': default_location})
+    with warnings.catch_warnings(record=True) as w:
+        # Cause all warnings to always be triggered.
+        warnings.simplefilter("always")
+        indicators = resolver.strategy.advise_indicators(result, 'ETH/BTC')
+        assert len(w) == 1
+        assert issubclass(w[-1].category, DeprecationWarning)
+        assert "deprecated - check out the Sample strategy to see the current function headers!" \
+            in str(w[-1].message)
+
+    with warnings.catch_warnings(record=True) as w:
+            # Cause all warnings to always be triggered.
+        warnings.simplefilter("always")
+        resolver.strategy.advise_buy(indicators, 'ETH/BTC')
+        assert len(w) == 1
+        assert issubclass(w[-1].category, DeprecationWarning)
+        assert "deprecated - check out the Sample strategy to see the current function headers!" \
+            in str(w[-1].message)
+
+    with warnings.catch_warnings(record=True) as w:
+        # Cause all warnings to always be triggered.
+        warnings.simplefilter("always")
+        resolver.strategy.advise_sell(indicators, 'ETH_BTC')
+        assert len(w) == 1
+        assert issubclass(w[-1].category, DeprecationWarning)
+        assert "deprecated - check out the Sample strategy to see the current function headers!" \
+            in str(w[-1].message)
+
+
+def test_call_deprecated_function(result, monkeypatch):
+    default_location = path.join(path.dirname(path.realpath(__file__)))
+    resolver = StrategyResolver({'strategy': 'TestStrategyLegacy',
+                                 'strategy_path': default_location})
+    metadata = {'pair': 'ETH/BTC'}
+
+    # Make sure we are using a legacy function
+    assert resolver.strategy._populate_fun_len == 2
+    assert resolver.strategy._buy_fun_len == 2
+    assert resolver.strategy._sell_fun_len == 2
+
+    indicator_df = resolver.strategy.advise_indicators(result, metadata=metadata)
+    assert type(indicator_df) is DataFrame
+    assert 'adx' in indicator_df.columns
+
+    buydf = resolver.strategy.advise_buy(result, metadata=metadata)
+    assert type(buydf) is DataFrame
+    assert 'buy' in buydf.columns
+
+    selldf = resolver.strategy.advise_sell(result, metadata=metadata)
+    assert type(selldf) is DataFrame
+    assert 'sell' in selldf

freqtrade/tests/test_acl_pair.py

@@ -1,5 +1,7 @@
 # pragma pylint: disable=missing-docstring,C0103,protected-access
 
+from unittest.mock import MagicMock
+
 import freqtrade.tests.conftest as tt  # test tools
 
 # whitelist, blacklist, filtering, all of that will
@@ -9,121 +11,61 @@ import freqtrade.tests.conftest as tt  # test tools
 
 def whitelist_conf():
     config = tt.default_conf()
-
     config['stake_currency'] = 'BTC'
     config['exchange']['pair_whitelist'] = [
-        'BTC_ETH',
-        'BTC_TKN',
-        'BTC_TRST',
-        'BTC_SWT',
-        'BTC_BCC'
+        'ETH/BTC',
+        'TKN/BTC',
+        'TRST/BTC',
+        'SWT/BTC',
+        'BCC/BTC'
     ]
-
     config['exchange']['pair_blacklist'] = [
-        'BTC_BLK'
+        'BLK/BTC'
     ]
 
     return config
 
 
-def get_market_summaries():
-    return [{
-        'MarketName': 'BTC-TKN',
-        'High': 0.00000919,
-        'Low': 0.00000820,
-        'Volume': 74339.61396015,
-        'Last': 0.00000820,
-        'BaseVolume': 1664,
-        'TimeStamp': '2014-07-09T07:19:30.15',
-        'Bid': 0.00000820,
-        'Ask': 0.00000831,
-        'OpenBuyOrders': 15,
-        'OpenSellOrders': 15,
-        'PrevDay': 0.00000821,
-        'Created': '2014-03-20T06:00:00',
-        'DisplayMarketName': ''
-    }, {
-        'MarketName': 'BTC-ETH',
-        'High': 0.00000072,
-        'Low': 0.00000001,
-        'Volume': 166340678.42280999,
-        'Last': 0.00000005,
-        'BaseVolume': 42,
-        'TimeStamp': '2014-07-09T07:21:40.51',
-        'Bid': 0.00000004,
-        'Ask': 0.00000005,
-        'OpenBuyOrders': 18,
-        'OpenSellOrders': 18,
-        'PrevDay': 0.00000002,
-        'Created': '2014-05-30T07:57:49.637',
-        'DisplayMarketName': ''
-    }, {
-        'MarketName': 'BTC-BLK',
-        'High': 0.00000072,
-        'Low': 0.00000001,
-        'Volume': 166340678.42280999,
-        'Last': 0.00000005,
-        'BaseVolume': 3,
-        'TimeStamp': '2014-07-09T07:21:40.51',
-        'Bid': 0.00000004,
-        'Ask': 0.00000005,
-        'OpenBuyOrders': 18,
-        'OpenSellOrders': 18,
-        'PrevDay': 0.00000002,
-        'Created': '2014-05-30T07:57:49.637',
-        'DisplayMarketName': ''
-    }]
-
-
-def get_health():
-    return [{'Currency': 'ETH', 'IsActive': True},
-            {'Currency': 'TKN', 'IsActive': True},
-            {'Currency': 'BLK', 'IsActive': True}]
-
-
-def get_health_empty():
-    return []
-
-
-def test_refresh_market_pair_not_in_whitelist(mocker):
+def test_refresh_market_pair_not_in_whitelist(mocker, markets):
     conf = whitelist_conf()
 
     freqtradebot = tt.get_patched_freqtradebot(mocker, conf)
 
-    mocker.patch('freqtrade.freqtradebot.exchange.get_wallet_health', get_health)
+    mocker.patch('freqtrade.exchange.Exchange.get_markets', markets)
     refreshedwhitelist = freqtradebot._refresh_whitelist(
-        conf['exchange']['pair_whitelist'] + ['BTC_XXX']
+        conf['exchange']['pair_whitelist'] + ['XXX/BTC']
     )
     # List ordered by BaseVolume
-    whitelist = ['BTC_ETH', 'BTC_TKN']
+    whitelist = ['ETH/BTC', 'TKN/BTC']
     # Ensure all except those in whitelist are removed
     assert whitelist == refreshedwhitelist
 
 
-def test_refresh_whitelist(mocker):
+def test_refresh_whitelist(mocker, markets):
     conf = whitelist_conf()
     freqtradebot = tt.get_patched_freqtradebot(mocker, conf)
 
-    mocker.patch('freqtrade.freqtradebot.exchange.get_wallet_health', get_health)
+    mocker.patch('freqtrade.exchange.Exchange.get_markets', markets)
     refreshedwhitelist = freqtradebot._refresh_whitelist(conf['exchange']['pair_whitelist'])
 
     # List ordered by BaseVolume
-    whitelist = ['BTC_ETH', 'BTC_TKN']
+    whitelist = ['ETH/BTC', 'TKN/BTC']
     # Ensure all except those in whitelist are removed
     assert whitelist == refreshedwhitelist
 
 
-def test_refresh_whitelist_dynamic(mocker):
+def test_refresh_whitelist_dynamic(mocker, markets, tickers):
     conf = whitelist_conf()
     freqtradebot = tt.get_patched_freqtradebot(mocker, conf)
     mocker.patch.multiple(
-        'freqtrade.freqtradebot.exchange',
-        get_wallet_health=get_health,
-        get_market_summaries=get_market_summaries
+        'freqtrade.exchange.Exchange',
+        get_markets=markets,
+        get_tickers=tickers,
+        exchange_has=MagicMock(return_value=True)
     )
 
     # argument: use the whitelist dynamically by exchange-volume
-    whitelist = ['BTC_TKN', 'BTC_ETH']
+    whitelist = ['ETH/BTC', 'TKN/BTC']
 
     refreshedwhitelist = freqtradebot._refresh_whitelist(
         freqtradebot._gen_pair_whitelist(conf['stake_currency'])
@@ -132,10 +74,10 @@ def test_refresh_whitelist_dynamic(mocker):
     assert whitelist == refreshedwhitelist
 
 
-def test_refresh_whitelist_dynamic_empty(mocker):
+def test_refresh_whitelist_dynamic_empty(mocker, markets_empty):
     conf = whitelist_conf()
     freqtradebot = tt.get_patched_freqtradebot(mocker, conf)
-    mocker.patch('freqtrade.freqtradebot.exchange.get_wallet_health', get_health_empty)
+    mocker.patch('freqtrade.exchange.Exchange.get_markets', markets_empty)
 
     # argument: use the whitelist dynamically by exchange-volume
     whitelist = []

freqtrade/tests/test_analyze.py

@@ -1,194 +0,0 @@
-# pragma pylint: disable=missing-docstring, C0103
-
-"""
-Unit test file for analyse.py
-"""
-
-import datetime
-import logging
-from unittest.mock import MagicMock
-
-import arrow
-from pandas import DataFrame
-
-from freqtrade.analyze import Analyze, SignalType
-from freqtrade.optimize.__init__ import load_tickerdata_file
-from freqtrade.tests.conftest import log_has
-
-# Avoid to reinit the same object again and again
-_ANALYZE = Analyze({'strategy': 'DefaultStrategy'})
-
-
-def test_signaltype_object() -> None:
-    """
-    Test the SignalType object has the mandatory Constants
-    :return: None
-    """
-    assert hasattr(SignalType, 'BUY')
-    assert hasattr(SignalType, 'SELL')
-
-
-def test_analyze_object() -> None:
-    """
-    Test the Analyze object has the mandatory methods
-    :return: None
-    """
-    assert hasattr(Analyze, 'parse_ticker_dataframe')
-    assert hasattr(Analyze, 'populate_indicators')
-    assert hasattr(Analyze, 'populate_buy_trend')
-    assert hasattr(Analyze, 'populate_sell_trend')
-    assert hasattr(Analyze, 'analyze_ticker')
-    assert hasattr(Analyze, 'get_signal')
-    assert hasattr(Analyze, 'should_sell')
-    assert hasattr(Analyze, 'min_roi_reached')
-
-
-def test_dataframe_correct_length(result):
-    dataframe = Analyze.parse_ticker_dataframe(result)
-    assert len(result.index) == len(dataframe.index)
-
-
-def test_dataframe_correct_columns(result):
-    assert result.columns.tolist() == \
-        ['date', 'close', 'high', 'low', 'open', 'volume']
-
-
-def test_populates_buy_trend(result):
-    # Load the default strategy for the unit test, because this logic is done in main.py
-    dataframe = _ANALYZE.populate_buy_trend(_ANALYZE.populate_indicators(result))
-    assert 'buy' in dataframe.columns
-
-
-def test_populates_sell_trend(result):
-    # Load the default strategy for the unit test, because this logic is done in main.py
-    dataframe = _ANALYZE.populate_sell_trend(_ANALYZE.populate_indicators(result))
-    assert 'sell' in dataframe.columns
-
-
-def test_returns_latest_buy_signal(mocker):
-    mocker.patch('freqtrade.analyze.get_ticker_history', return_value=MagicMock())
-
-    mocker.patch.multiple(
-        'freqtrade.analyze.Analyze',
-        analyze_ticker=MagicMock(
-            return_value=DataFrame([{'buy': 1, 'sell': 0, 'date': arrow.utcnow()}])
-        )
-    )
-    assert _ANALYZE.get_signal('BTC-ETH', 5) == (True, False)
-
-    mocker.patch.multiple(
-        'freqtrade.analyze.Analyze',
-        analyze_ticker=MagicMock(
-            return_value=DataFrame([{'buy': 0, 'sell': 1, 'date': arrow.utcnow()}])
-        )
-    )
-    assert _ANALYZE.get_signal('BTC-ETH', 5) == (False, True)
-
-
-def test_returns_latest_sell_signal(mocker):
-    mocker.patch('freqtrade.analyze.get_ticker_history', return_value=MagicMock())
-    mocker.patch.multiple(
-        'freqtrade.analyze.Analyze',
-        analyze_ticker=MagicMock(
-            return_value=DataFrame([{'sell': 1, 'buy': 0, 'date': arrow.utcnow()}])
-        )
-    )
-
-    assert _ANALYZE.get_signal('BTC-ETH', 5) == (False, True)
-
-    mocker.patch.multiple(
-        'freqtrade.analyze.Analyze',
-        analyze_ticker=MagicMock(
-            return_value=DataFrame([{'sell': 0, 'buy': 1, 'date': arrow.utcnow()}])
-        )
-    )
-    assert _ANALYZE.get_signal('BTC-ETH', 5) == (True, False)
-
-
-def test_get_signal_empty(default_conf, mocker, caplog):
-    caplog.set_level(logging.INFO)
-    mocker.patch('freqtrade.analyze.get_ticker_history', return_value=None)
-    assert (False, False) == _ANALYZE.get_signal('foo', int(default_conf['ticker_interval']))
-    assert log_has('Empty ticker history for pair foo', caplog.record_tuples)
-
-
-def test_get_signal_exception_valueerror(default_conf, mocker, caplog):
-    caplog.set_level(logging.INFO)
-    mocker.patch('freqtrade.analyze.get_ticker_history', return_value=1)
-    mocker.patch.multiple(
-        'freqtrade.analyze.Analyze',
-        analyze_ticker=MagicMock(
-            side_effect=ValueError('xyz')
-        )
-    )
-    assert (False, False) == _ANALYZE.get_signal('foo', int(default_conf['ticker_interval']))
-    assert log_has('Unable to analyze ticker for pair foo: xyz', caplog.record_tuples)
-
-
-def test_get_signal_empty_dataframe(default_conf, mocker, caplog):
-    caplog.set_level(logging.INFO)
-    mocker.patch('freqtrade.analyze.get_ticker_history', return_value=1)
-    mocker.patch.multiple(
-        'freqtrade.analyze.Analyze',
-        analyze_ticker=MagicMock(
-            return_value=DataFrame([])
-        )
-    )
-    assert (False, False) == _ANALYZE.get_signal('xyz', int(default_conf['ticker_interval']))
-    assert log_has('Empty dataframe for pair xyz', caplog.record_tuples)
-
-
-def test_get_signal_old_dataframe(default_conf, mocker, caplog):
-    caplog.set_level(logging.INFO)
-    mocker.patch('freqtrade.analyze.get_ticker_history', return_value=1)
-    # FIX: The get_signal function has hardcoded 10, which we must inturn hardcode
-    oldtime = arrow.utcnow() - datetime.timedelta(minutes=11)
-    ticks = DataFrame([{'buy': 1, 'date': oldtime}])
-    mocker.patch.multiple(
-        'freqtrade.analyze.Analyze',
-        analyze_ticker=MagicMock(
-            return_value=DataFrame(ticks)
-        )
-    )
-    assert (False, False) == _ANALYZE.get_signal('xyz', int(default_conf['ticker_interval']))
-    assert log_has(
-        'Outdated history for pair xyz. Last tick is 11 minutes old',
-        caplog.record_tuples
-    )
-
-
-def test_get_signal_handles_exceptions(mocker):
-    mocker.patch('freqtrade.analyze.get_ticker_history', return_value=MagicMock())
-    mocker.patch.multiple(
-        'freqtrade.analyze.Analyze',
-        analyze_ticker=MagicMock(
-            side_effect=Exception('invalid ticker history ')
-        )
-    )
-
-    assert _ANALYZE.get_signal('BTC-ETH', 5) == (False, False)
-
-
-def test_parse_ticker_dataframe(ticker_history, ticker_history_without_bv):
-    columns = ['date', 'close', 'high', 'low', 'open', 'volume']
-
-    # Test file with BV data
-    dataframe = Analyze.parse_ticker_dataframe(ticker_history)
-    assert dataframe.columns.tolist() == columns
-
-    # Test file without BV data
-    dataframe = Analyze.parse_ticker_dataframe(ticker_history_without_bv)
-    assert dataframe.columns.tolist() == columns
-
-
-def test_tickerdata_to_dataframe(default_conf) -> None:
-    """
-    Test Analyze.tickerdata_to_dataframe() method
-    """
-    analyze = Analyze(default_conf)
-
-    timerange = ((None, 'line'), None, -100)
-    tick = load_tickerdata_file(None, 'BTC_UNITEST', 1, timerange=timerange)
-    tickerlist = {'BTC_UNITEST': tick}
-    data = analyze.tickerdata_to_dataframe(tickerlist)
-    assert len(data['BTC_UNITEST']) == 100

freqtrade/tests/test_arguments.py

@@ -1,26 +1,10 @@
 # pragma pylint: disable=missing-docstring, C0103
 
-"""
-Unit test file for arguments.py
-"""
-
 import argparse
-import logging
 
 import pytest
 
-from freqtrade.arguments import Arguments
-
-
-def test_arguments_object() -> None:
-    """
-    Test the Arguments object has the mandatory methods
-    :return: None
-    """
-    assert hasattr(Arguments, 'get_parsed_arg')
-    assert hasattr(Arguments, 'parse_args')
-    assert hasattr(Arguments, 'parse_timerange')
-    assert hasattr(Arguments, 'scripts_options')
+from freqtrade.arguments import Arguments, TimeRange
 
 
 # Parse common command-line-arguments. Used for all tools
@@ -28,14 +12,13 @@ def test_parse_args_none() -> None:
     arguments = Arguments([], '')
     assert isinstance(arguments, Arguments)
     assert isinstance(arguments.parser, argparse.ArgumentParser)
-    assert isinstance(arguments.parser, argparse.ArgumentParser)
 
 
 def test_parse_args_defaults() -> None:
     args = Arguments([], '').get_parsed_arg()
     assert args.config == 'config.json'
     assert args.dynamic_whitelist is None
-    assert args.loglevel == logging.INFO
+    assert args.loglevel == 0
 
 
 def test_parse_args_config() -> None:
@@ -46,19 +29,24 @@ def test_parse_args_config() -> None:
     assert args.config == '/dev/null'
 
 
+def test_parse_args_db_url() -> None:
+    args = Arguments(['--db-url', 'sqlite:///test.sqlite'], '').get_parsed_arg()
+    assert args.db_url == 'sqlite:///test.sqlite'
+
+
 def test_parse_args_verbose() -> None:
     args = Arguments(['-v'], '').get_parsed_arg()
-    assert args.loglevel == logging.DEBUG
+    assert args.loglevel == 1
 
     args = Arguments(['--verbose'], '').get_parsed_arg()
-    assert args.loglevel == logging.DEBUG
+    assert args.loglevel == 1
 
 
 def test_scripts_options() -> None:
-    arguments = Arguments(['-p', 'BTC_ETH'], '')
+    arguments = Arguments(['-p', 'ETH/BTC'], '')
     arguments.scripts_options()
     args = arguments.get_parsed_arg()
-    assert args.pair == 'BTC_ETH'
+    assert args.pair == 'ETH/BTC'
 
 
 def test_parse_args_version() -> None:
@@ -107,8 +95,25 @@ def test_parse_args_dynamic_whitelist_invalid_values() -> None:
 
 
 def test_parse_timerange_incorrect() -> None:
-    assert ((None, 'line'), None, -200) == Arguments.parse_timerange('-200')
-    assert (('line', None), 200, None) == Arguments.parse_timerange('200-')
+    assert TimeRange(None, 'line', 0, -200) == Arguments.parse_timerange('-200')
+    assert TimeRange('line', None, 200, 0) == Arguments.parse_timerange('200-')
+    assert TimeRange('index', 'index', 200, 500) == Arguments.parse_timerange('200-500')
+
+    assert TimeRange('date', None, 1274486400, 0) == Arguments.parse_timerange('20100522-')
+    assert TimeRange(None, 'date', 0, 1274486400) == Arguments.parse_timerange('-20100522')
+    timerange = Arguments.parse_timerange('20100522-20150730')
+    assert timerange == TimeRange('date', 'date', 1274486400, 1438214400)
+
+    # Added test for unix timestamp - BTC genesis date
+    assert TimeRange('date', None, 1231006505, 0) == Arguments.parse_timerange('1231006505-')
+    assert TimeRange(None, 'date', 0, 1233360000) == Arguments.parse_timerange('-1233360000')
+    timerange = Arguments.parse_timerange('1231006505-1233360000')
+    assert TimeRange('date', 'date', 1231006505, 1233360000) == timerange
+
+    # TODO: Find solution for the following case (passing timestamp in ms)
+    timerange = Arguments.parse_timerange('1231006505000-1233360000000')
+    assert TimeRange('date', 'date', 1231006505, 1233360000) != timerange
+
     with pytest.raises(Exception, match=r'Incorrect syntax.*'):
         Arguments.parse_timerange('-')
 
@@ -126,16 +131,22 @@ def test_parse_args_backtesting_custom() -> None:
         '-c', 'test_conf.json',
         'backtesting',
         '--live',
-        '--ticker-interval', '1',
-        '--refresh-pairs-cached']
+        '--ticker-interval', '1m',
+        '--refresh-pairs-cached',
+        '--strategy-list',
+        'DefaultStrategy',
+        'TestStrategy'
+        ]
     call_args = Arguments(args, '').get_parsed_arg()
     assert call_args.config == 'test_conf.json'
     assert call_args.live is True
-    assert call_args.loglevel == logging.INFO
+    assert call_args.loglevel == 0
     assert call_args.subparser == 'backtesting'
     assert call_args.func is not None
-    assert call_args.ticker_interval == 1
+    assert call_args.ticker_interval == '1m'
     assert call_args.refresh_pairs is True
+    assert type(call_args.strategy_list) is list
+    assert len(call_args.strategy_list) == 2
 
 
 def test_parse_args_hyperopt_custom() -> None:
@@ -148,7 +159,23 @@ def test_parse_args_hyperopt_custom() -> None:
     call_args = Arguments(args, '').get_parsed_arg()
     assert call_args.config == 'test_conf.json'
     assert call_args.epochs == 20
-    assert call_args.loglevel == logging.INFO
+    assert call_args.loglevel == 0
     assert call_args.subparser == 'hyperopt'
     assert call_args.spaces == ['buy']
     assert call_args.func is not None
+
+
+def test_testdata_dl_options() -> None:
+    args = [
+        '--pairs-file', 'file_with_pairs',
+        '--export', 'export/folder',
+        '--days', '30',
+        '--exchange', 'binance'
+    ]
+    arguments = Arguments(args, '')
+    arguments.testdata_dl_options()
+    args = arguments.parse_args()
+    assert args.pairs_file == 'file_with_pairs'
+    assert args.export == 'export/folder'
+    assert args.days == 30
+    assert args.exchange == 'binance'

freqtrade/tests/test_configuration.py

@@ -1,66 +1,51 @@
-# pragma pylint: disable=protected-access, invalid-name
+# pragma pylint: disable=missing-docstring, protected-access, invalid-name
 
-"""
-Unit test file for configuration.py
-"""
 import json
-from copy import deepcopy
+from argparse import Namespace
+import logging
 from unittest.mock import MagicMock
 
 import pytest
-from jsonschema import ValidationError
+from jsonschema import validate, ValidationError
 
+from freqtrade import constants
+from freqtrade import OperationalException
 from freqtrade.arguments import Arguments
-from freqtrade.configuration import Configuration
+from freqtrade.configuration import Configuration, set_loggers
+from freqtrade.constants import DEFAULT_DB_DRYRUN_URL, DEFAULT_DB_PROD_URL
 from freqtrade.tests.conftest import log_has
 
 
-def test_configuration_object() -> None:
-    """
-    Test the Constants object has the mandatory Constants
-    """
-    assert hasattr(Configuration, 'load_config')
-    assert hasattr(Configuration, '_load_config_file')
-    assert hasattr(Configuration, '_validate_config')
-    assert hasattr(Configuration, '_load_common_config')
-    assert hasattr(Configuration, '_load_backtesting_config')
-    assert hasattr(Configuration, '_load_hyperopt_config')
-    assert hasattr(Configuration, 'get_config')
-
-
-def test_load_config_invalid_pair(default_conf, mocker) -> None:
-    """
-    Test the configuration validator with an invalid PAIR format
-    """
-    conf = deepcopy(default_conf)
-    conf['exchange']['pair_whitelist'].append('BTC-ETH')
+def test_load_config_invalid_pair(default_conf) -> None:
+    default_conf['exchange']['pair_whitelist'].append('ETH-BTC')
 
     with pytest.raises(ValidationError, match=r'.*does not match.*'):
-        configuration = Configuration([])
-        configuration._validate_config(conf)
+        configuration = Configuration(Namespace())
+        configuration._validate_config(default_conf)
 
 
-def test_load_config_missing_attributes(default_conf, mocker) -> None:
-    """
-    Test the configuration validator with a missing attribute
-    """
-    conf = deepcopy(default_conf)
-    conf.pop('exchange')
+def test_load_config_missing_attributes(default_conf) -> None:
+    default_conf.pop('exchange')
 
     with pytest.raises(ValidationError, match=r'.*\'exchange\' is a required property.*'):
-        configuration = Configuration([])
-        configuration._validate_config(conf)
+        configuration = Configuration(Namespace())
+        configuration._validate_config(default_conf)
+
+
+def test_load_config_incorrect_stake_amount(default_conf) -> None:
+    default_conf['stake_amount'] = 'fake'
+
+    with pytest.raises(ValidationError, match=r'.*\'fake\' does not match \'unlimited\'.*'):
+        configuration = Configuration(Namespace())
+        configuration._validate_config(default_conf)
 
 
 def test_load_config_file(default_conf, mocker, caplog) -> None:
-    """
-    Test Configuration._load_config_file() method
-    """
     file_mock = mocker.patch('freqtrade.configuration.open', mocker.mock_open(
         read_data=json.dumps(default_conf)
     ))
 
-    configuration = Configuration([])
+    configuration = Configuration(Namespace())
     validated_conf = configuration._load_config_file('somefile')
     assert file_mock.call_count == 1
     assert validated_conf.items() >= default_conf.items()
@@ -68,28 +53,29 @@ def test_load_config_file(default_conf, mocker, caplog) -> None:
     assert log_has('Validating configuration ...', caplog.record_tuples)
 
 
-def test_load_config_file_exception(mocker, caplog) -> None:
-    """
-    Test Configuration._load_config_file() method
-    """
+def test_load_config_max_open_trades_zero(default_conf, mocker, caplog) -> None:
+    default_conf['max_open_trades'] = 0
+    file_mock = mocker.patch('freqtrade.configuration.open', mocker.mock_open(
+        read_data=json.dumps(default_conf)
+    ))
+
+    Configuration(Namespace())._load_config_file('somefile')
+    assert file_mock.call_count == 1
+    assert log_has('Validating configuration ...', caplog.record_tuples)
+
+
+def test_load_config_file_exception(mocker) -> None:
     mocker.patch(
         'freqtrade.configuration.open',
         MagicMock(side_effect=FileNotFoundError('File not found'))
     )
-    configuration = Configuration([])
+    configuration = Configuration(Namespace())
 
-    with pytest.raises(SystemExit):
+    with pytest.raises(OperationalException, match=r'.*Config file "somefile" not found!*'):
         configuration._load_config_file('somefile')
-    assert log_has(
-        'Config file "somefile" not found. Please create your config file',
-        caplog.record_tuples
-    )
 
 
 def test_load_config(default_conf, mocker) -> None:
-    """
-    Test Configuration.load_config() without any cli params
-    """
     mocker.patch('freqtrade.configuration.open', mocker.mock_open(
         read_data=json.dumps(default_conf)
     ))
@@ -101,45 +87,72 @@ def test_load_config(default_conf, mocker) -> None:
     assert validated_conf.get('strategy') == 'DefaultStrategy'
     assert validated_conf.get('strategy_path') is None
     assert 'dynamic_whitelist' not in validated_conf
-    assert 'dry_run_db' not in validated_conf
 
 
 def test_load_config_with_params(default_conf, mocker) -> None:
-    """
-    Test Configuration.load_config() with cli params used
-    """
     mocker.patch('freqtrade.configuration.open', mocker.mock_open(
         read_data=json.dumps(default_conf)
     ))
-
-    args = [
+    arglist = [
         '--dynamic-whitelist', '10',
         '--strategy', 'TestStrategy',
         '--strategy-path', '/some/path',
-        '--dry-run-db',
+        '--db-url', 'sqlite:///someurl',
     ]
-    args = Arguments(args, '').get_parsed_arg()
-
+    args = Arguments(arglist, '').get_parsed_arg()
     configuration = Configuration(args)
     validated_conf = configuration.load_config()
 
     assert validated_conf.get('dynamic_whitelist') == 10
     assert validated_conf.get('strategy') == 'TestStrategy'
     assert validated_conf.get('strategy_path') == '/some/path'
-    assert validated_conf.get('dry_run_db') is True
+    assert validated_conf.get('db_url') == 'sqlite:///someurl'
+
+    conf = default_conf.copy()
+    conf["dry_run"] = False
+    del conf["db_url"]
+    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
+        read_data=json.dumps(conf)
+    ))
+
+    arglist = [
+        '--dynamic-whitelist', '10',
+        '--strategy', 'TestStrategy',
+        '--strategy-path', '/some/path'
+    ]
+    args = Arguments(arglist, '').get_parsed_arg()
+
+    configuration = Configuration(args)
+    validated_conf = configuration.load_config()
+    assert validated_conf.get('db_url') == DEFAULT_DB_PROD_URL
+
+    # Test dry=run with ProdURL
+    conf = default_conf.copy()
+    conf["dry_run"] = True
+    conf["db_url"] = DEFAULT_DB_PROD_URL
+    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
+        read_data=json.dumps(conf)
+    ))
+
+    arglist = [
+        '--dynamic-whitelist', '10',
+        '--strategy', 'TestStrategy',
+        '--strategy-path', '/some/path'
+    ]
+    args = Arguments(arglist, '').get_parsed_arg()
+
+    configuration = Configuration(args)
+    validated_conf = configuration.load_config()
+    assert validated_conf.get('db_url') == DEFAULT_DB_DRYRUN_URL
 
 
 def test_load_custom_strategy(default_conf, mocker) -> None:
-    """
-    Test Configuration.load_config() without any cli params
-    """
-    custom_conf = deepcopy(default_conf)
-    custom_conf.update({
+    default_conf.update({
         'strategy': 'CustomStrategy',
         'strategy_path': '/tmp/strategies',
     })
     mocker.patch('freqtrade.configuration.open', mocker.mock_open(
-        read_data=json.dumps(custom_conf)
+        read_data=json.dumps(default_conf)
     ))
 
     args = Arguments([], '').get_parsed_arg()
@@ -151,19 +164,15 @@ def test_load_custom_strategy(default_conf, mocker) -> None:
 
 
 def test_show_info(default_conf, mocker, caplog) -> None:
-    """
-    Test Configuration.show_info()
-    """
     mocker.patch('freqtrade.configuration.open', mocker.mock_open(
         read_data=json.dumps(default_conf)
     ))
-
-    args = [
+    arglist = [
         '--dynamic-whitelist', '10',
         '--strategy', 'TestStrategy',
-        '--dry-run-db'
+        '--db-url', 'sqlite:///tmp/testdb',
     ]
-    args = Arguments(args, '').get_parsed_arg()
+    args = Arguments(arglist, '').get_parsed_arg()
 
     configuration = Configuration(args)
     configuration.get_config()
@@ -174,41 +183,21 @@ def test_show_info(default_conf, mocker, caplog) -> None:
         '(not applicable with Backtesting and Hyperopt)',
         caplog.record_tuples
     )
-
-    assert log_has(
-        'Parameter --dry-run-db detected ...',
-        caplog.record_tuples
-    )
-
-    assert log_has(
-        'Dry_run will use the DB file: "tradesv3.dry_run.sqlite"',
-        caplog.record_tuples
-    )
-
-    # Test the Dry run condition
-    configuration.config.update({'dry_run': False})
-    configuration._load_common_config(configuration.config)
-    assert log_has(
-        'Dry run is disabled. (--dry_run_db ignored)',
-        caplog.record_tuples
-    )
+    assert log_has('Using DB: "sqlite:///tmp/testdb"', caplog.record_tuples)
+    assert log_has('Dry run is enabled', caplog.record_tuples)
 
 
 def test_setup_configuration_without_arguments(mocker, default_conf, caplog) -> None:
-    """
-    Test setup_configuration() function
-    """
     mocker.patch('freqtrade.configuration.open', mocker.mock_open(
         read_data=json.dumps(default_conf)
     ))
-
-    args = [
+    arglist = [
         '--config', 'config.json',
         '--strategy', 'DefaultStrategy',
         'backtesting'
     ]
 
-    args = Arguments(args, '').get_parsed_arg()
+    args = Arguments(arglist, '').get_parsed_arg()
 
     configuration = Configuration(args)
     config = configuration.get_config()
@@ -219,7 +208,7 @@ def test_setup_configuration_without_arguments(mocker, default_conf, caplog) ->
     assert 'pair_whitelist' in config['exchange']
     assert 'datadir' in config
     assert log_has(
-        'Parameter --datadir detected: {} ...'.format(config['datadir']),
+        'Using data folder: {} ...'.format(config['datadir']),
         caplog.record_tuples
     )
     assert 'ticker_interval' in config
@@ -228,8 +217,8 @@ def test_setup_configuration_without_arguments(mocker, default_conf, caplog) ->
     assert 'live' not in config
     assert not log_has('Parameter -l/--live detected ...', caplog.record_tuples)
 
-    assert 'realistic_simulation' not in config
-    assert not log_has('Parameter --realistic-simulation detected ...', caplog.record_tuples)
+    assert 'position_stacking' not in config
+    assert not log_has('Parameter --enable-position-stacking detected ...', caplog.record_tuples)
 
     assert 'refresh_pairs' not in config
     assert not log_has('Parameter -r/--refresh-pairs-cached detected ...', caplog.record_tuples)
@@ -239,27 +228,25 @@ def test_setup_configuration_without_arguments(mocker, default_conf, caplog) ->
 
 
 def test_setup_configuration_with_arguments(mocker, default_conf, caplog) -> None:
-    """
-    Test setup_configuration() function
-    """
     mocker.patch('freqtrade.configuration.open', mocker.mock_open(
         read_data=json.dumps(default_conf)
     ))
 
-    args = [
+    arglist = [
         '--config', 'config.json',
         '--strategy', 'DefaultStrategy',
         '--datadir', '/foo/bar',
         'backtesting',
-        '--ticker-interval', '1',
+        '--ticker-interval', '1m',
         '--live',
-        '--realistic-simulation',
+        '--enable-position-stacking',
+        '--disable-max-market-positions',
         '--refresh-pairs-cached',
         '--timerange', ':100',
         '--export', '/bar/foo'
     ]
 
-    args = Arguments(args, '').get_parsed_arg()
+    args = Arguments(arglist, '').get_parsed_arg()
 
     configuration = Configuration(args)
     config = configuration.get_config()
@@ -270,22 +257,25 @@ def test_setup_configuration_with_arguments(mocker, default_conf, caplog) -> Non
     assert 'pair_whitelist' in config['exchange']
     assert 'datadir' in config
     assert log_has(
-        'Parameter --datadir detected: {} ...'.format(config['datadir']),
+        '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: 1 ...',
+        'Using ticker_interval: 1m ...',
         caplog.record_tuples
     )
 
     assert 'live' in config
     assert log_has('Parameter -l/--live detected ...', caplog.record_tuples)
 
-    assert 'realistic_simulation'in config
-    assert log_has('Parameter --realistic-simulation detected ...', caplog.record_tuples)
-    assert log_has('Using max_open_trades: 1 ...', caplog.record_tuples)
+    assert 'position_stacking'in config
+    assert log_has('Parameter --enable-position-stacking detected ...', caplog.record_tuples)
+
+    assert 'use_max_market_positions' in config
+    assert log_has('Parameter --disable-max-market-positions detected ...', caplog.record_tuples)
+    assert log_has('max_open_trades set to unlimited ...', caplog.record_tuples)
 
     assert 'refresh_pairs'in config
     assert log_has('Parameter -r/--refresh-pairs-cached detected ...', caplog.record_tuples)
@@ -302,7 +292,7 @@ def test_setup_configuration_with_arguments(mocker, default_conf, caplog) -> Non
     )
 
 
-def test_hyperopt_with_arguments(mocker, default_conf, caplog) -> None:
+def test_setup_configuration_with_stratlist(mocker, default_conf, caplog) -> None:
     """
     Test setup_configuration() function
     """
@@ -310,14 +300,63 @@ def test_hyperopt_with_arguments(mocker, default_conf, caplog) -> None:
         read_data=json.dumps(default_conf)
     ))
 
-    args = [
-        'hyperopt',
-        '--epochs', '10',
-        '--use-mongodb',
-        '--spaces', 'all',
+    arglist = [
+        '--config', 'config.json',
+        'backtesting',
+        '--ticker-interval', '1m',
+        '--export', '/bar/foo',
+        '--strategy-list',
+        'DefaultStrategy',
+        'TestStrategy'
     ]
 
-    args = Arguments(args, '').get_parsed_arg()
+    args = Arguments(arglist, '').get_parsed_arg()
+
+    configuration = Configuration(args)
+    config = configuration.get_config()
+    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 log_has('Parameter -i/--ticker-interval detected ...', caplog.record_tuples)
+    assert log_has(
+        'Using ticker_interval: 1m ...',
+        caplog.record_tuples
+    )
+
+    assert 'strategy_list' in config
+    assert log_has('Using strategy list of 2 Strategies', caplog.record_tuples)
+
+    assert 'position_stacking' not in config
+
+    assert 'use_max_market_positions' not in config
+
+    assert 'timerange' not in config
+
+    assert 'export' in config
+    assert log_has(
+        'Parameter --export detected: {} ...'.format(config['export']),
+        caplog.record_tuples
+    )
+
+
+def test_hyperopt_with_arguments(mocker, default_conf, caplog) -> None:
+    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
+        read_data=json.dumps(default_conf)
+    ))
+    arglist = [
+        'hyperopt',
+        '--epochs', '10',
+        '--spaces', 'all',
+    ]
+    args = Arguments(arglist, '').get_parsed_arg()
 
     configuration = Configuration(args)
     config = configuration.get_config()
@@ -327,10 +366,85 @@ def test_hyperopt_with_arguments(mocker, default_conf, caplog) -> None:
     assert log_has('Parameter --epochs detected ...', caplog.record_tuples)
     assert log_has('Will run Hyperopt with for 10 epochs ...', caplog.record_tuples)
 
-    assert 'mongodb' in config
-    assert config['mongodb'] is True
-    assert log_has('Parameter --use-mongodb detected ...', caplog.record_tuples)
-
     assert 'spaces' in config
     assert config['spaces'] == ['all']
     assert log_has('Parameter -s/--spaces detected: [\'all\']', caplog.record_tuples)
+
+
+def test_check_exchange(default_conf) -> None:
+    configuration = Configuration(Namespace())
+
+    # Test a valid exchange
+    default_conf.get('exchange').update({'name': 'BITTREX'})
+    assert configuration.check_exchange(default_conf)
+
+    # Test a valid exchange
+    default_conf.get('exchange').update({'name': 'binance'})
+    assert configuration.check_exchange(default_conf)
+
+    # Test a invalid exchange
+    default_conf.get('exchange').update({'name': 'unknown_exchange'})
+    configuration.config = default_conf
+
+    with pytest.raises(
+        OperationalException,
+        match=r'.*Exchange "unknown_exchange" not supported.*'
+    ):
+        configuration.check_exchange(default_conf)
+
+
+def test_cli_verbose_with_params(default_conf, mocker, caplog) -> None:
+    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
+        read_data=json.dumps(default_conf)))
+    # Prevent setting loggers
+    mocker.patch('freqtrade.configuration.set_loggers', MagicMock)
+    arglist = ['-vvv']
+    args = Arguments(arglist, '').get_parsed_arg()
+
+    configuration = Configuration(args)
+    validated_conf = configuration.load_config()
+
+    assert validated_conf.get('verbosity') == 3
+    assert log_has('Verbosity set to 3', caplog.record_tuples)
+
+
+def test_set_loggers() -> None:
+    # Reset Logging to Debug, otherwise this fails randomly as it's set globally
+    logging.getLogger('requests').setLevel(logging.DEBUG)
+    logging.getLogger("urllib3").setLevel(logging.DEBUG)
+    logging.getLogger('ccxt.base.exchange').setLevel(logging.DEBUG)
+    logging.getLogger('telegram').setLevel(logging.DEBUG)
+
+    previous_value1 = logging.getLogger('requests').level
+    previous_value2 = logging.getLogger('ccxt.base.exchange').level
+    previous_value3 = logging.getLogger('telegram').level
+
+    set_loggers()
+
+    value1 = logging.getLogger('requests').level
+    assert previous_value1 is not value1
+    assert value1 is logging.INFO
+
+    value2 = logging.getLogger('ccxt.base.exchange').level
+    assert previous_value2 is not value2
+    assert value2 is logging.INFO
+
+    value3 = logging.getLogger('telegram').level
+    assert previous_value3 is not value3
+    assert value3 is logging.INFO
+
+    set_loggers(log_level=2)
+
+    assert logging.getLogger('requests').level is logging.DEBUG
+    assert logging.getLogger('ccxt.base.exchange').level is logging.INFO
+    assert logging.getLogger('telegram').level is logging.INFO
+
+    set_loggers(log_level=3)
+
+    assert logging.getLogger('requests').level is logging.DEBUG
+    assert logging.getLogger('ccxt.base.exchange').level is logging.DEBUG
+    assert logging.getLogger('telegram').level is logging.INFO
+
+
+def test_validate_default_conf(default_conf) -> None:
+    validate(default_conf, constants.CONF_SCHEMA)

freqtrade/tests/test_constants.py

@@ -1,25 +0,0 @@
-"""
-Unit test file for constants.py
-"""
-
-from freqtrade import constants
-
-
-def test_constant_object() -> None:
-    """
-    Test the Constants object has the mandatory Constants
-    """
-    assert hasattr(constants, 'CONF_SCHEMA')
-    assert hasattr(constants, 'DYNAMIC_WHITELIST')
-    assert hasattr(constants, 'PROCESS_THROTTLE_SECS')
-    assert hasattr(constants, 'TICKER_INTERVAL')
-    assert hasattr(constants, 'HYPEROPT_EPOCH')
-    assert hasattr(constants, 'RETRY_TIMEOUT')
-    assert hasattr(constants, 'DEFAULT_STRATEGY')
-
-
-def test_conf_schema() -> None:
-    """
-    Test the CONF_SCHEMA is from the right type
-    """
-    assert isinstance(constants.CONF_SCHEMA, dict)

freqtrade/tests/test_dataframe.py

@@ -2,33 +2,31 @@
 
 import pandas
 
-from freqtrade.analyze import Analyze
 from freqtrade.optimize import load_data
 from freqtrade.strategy.resolver import StrategyResolver
 
-_pairs = ['BTC_ETH']
+_pairs = ['ETH/BTC']
 
 
-def load_dataframe_pair(pairs):
-    ld = load_data(None, ticker_interval=5, pairs=pairs)
+def load_dataframe_pair(pairs, strategy):
+    ld = load_data(None, ticker_interval='5m', pairs=pairs)
     assert isinstance(ld, dict)
     assert isinstance(pairs[0], str)
     dataframe = ld[pairs[0]]
 
-    analyze = Analyze({'strategy': 'DefaultStrategy'})
-    dataframe = analyze.analyze_ticker(dataframe)
+    dataframe = strategy.analyze_ticker(dataframe, {'pair': pairs[0]})
     return dataframe
 
 
 def test_dataframe_load():
-    StrategyResolver({'strategy': 'DefaultStrategy'})
-    dataframe = load_dataframe_pair(_pairs)
+    strategy = StrategyResolver({'strategy': 'DefaultStrategy'}).strategy
+    dataframe = load_dataframe_pair(_pairs, strategy)
     assert isinstance(dataframe, pandas.core.frame.DataFrame)
 
 
 def test_dataframe_columns_exists():
-    StrategyResolver({'strategy': 'DefaultStrategy'})
-    dataframe = load_dataframe_pair(_pairs)
+    strategy = StrategyResolver({'strategy': 'DefaultStrategy'}).strategy
+    dataframe = load_dataframe_pair(_pairs, strategy)
     assert 'high' in dataframe.columns
     assert 'low' in dataframe.columns
     assert 'close' in dataframe.columns

freqtrade/tests/test_fiat_convert.py

@@ -5,8 +5,10 @@ import time
 from unittest.mock import MagicMock
 
 import pytest
+from requests.exceptions import RequestException
 
 from freqtrade.fiat_convert import CryptoFiat, CryptoToFiatConverter
+from freqtrade.tests.conftest import log_has, patch_coinmarketcap
 
 
 def test_pair_convertion_object():
@@ -37,7 +39,8 @@ def test_pair_convertion_object():
     assert pair_convertion.price == 30000.123
 
 
-def test_fiat_convert_is_supported():
+def test_fiat_convert_is_supported(mocker):
+    patch_coinmarketcap(mocker)
     fiat_convert = CryptoToFiatConverter()
     assert fiat_convert._is_supported_fiat(fiat='USD') is True
     assert fiat_convert._is_supported_fiat(fiat='usd') is True
@@ -45,7 +48,9 @@ def test_fiat_convert_is_supported():
     assert fiat_convert._is_supported_fiat(fiat='ABC') is False
 
 
-def test_fiat_convert_add_pair():
+def test_fiat_convert_add_pair(mocker):
+    patch_coinmarketcap(mocker)
+
     fiat_convert = CryptoToFiatConverter()
 
     pair_len = len(fiat_convert._pairs)
@@ -67,18 +72,14 @@ def test_fiat_convert_add_pair():
 
 
 def test_fiat_convert_find_price(mocker):
-    api_mock = MagicMock(return_value={
-        'price_usd': 12345.0,
-        'price_eur': 13000.2
-    })
-    mocker.patch('freqtrade.fiat_convert.Market.ticker', api_mock)
+    patch_coinmarketcap(mocker)
+
     fiat_convert = CryptoToFiatConverter()
 
     with pytest.raises(ValueError, match=r'The fiat ABC is not supported.'):
         fiat_convert._find_price(crypto_symbol='BTC', fiat_symbol='ABC')
 
-    with pytest.raises(ValueError, match=r'The crypto symbol XRP is not supported.'):
-        fiat_convert.get_price(crypto_symbol='XRP', fiat_symbol='USD')
+    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)
     assert fiat_convert.get_price(crypto_symbol='BTC', fiat_symbol='USD') == 12345.0
@@ -88,12 +89,17 @@ def test_fiat_convert_find_price(mocker):
     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=[])
+    patch_coinmarketcap(mocker)
+    fiat_convert = CryptoToFiatConverter()
+    assert fiat_convert._find_price(crypto_symbol='CRYPTO_123', fiat_symbol='EUR') == 0.0
+    assert log_has('unsupported crypto-symbol CRYPTO_123 - returning 0.0', caplog.record_tuples)
+
+
 def test_fiat_convert_get_price(mocker):
-    api_mock = MagicMock(return_value={
-        'price_usd': 28000.0,
-        'price_eur': 15000.0
-    })
-    mocker.patch('freqtrade.fiat_convert.Market.ticker', api_mock)
+    patch_coinmarketcap(mocker)
+
     mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=28000.0)
 
     fiat_convert = CryptoToFiatConverter()
@@ -124,12 +130,92 @@ def test_fiat_convert_get_price(mocker):
     assert fiat_convert._pairs[0]._expiration is not expiration
 
 
-def test_fiat_convert_without_network():
+def test_fiat_convert_same_currencies(mocker):
+    patch_coinmarketcap(mocker)
+    fiat_convert = CryptoToFiatConverter()
+
+    assert fiat_convert.get_price(crypto_symbol='USD', fiat_symbol='USD') == 1.0
+
+
+def test_fiat_convert_two_FIAT(mocker):
+    patch_coinmarketcap(mocker)
+    fiat_convert = CryptoToFiatConverter()
+
+    assert fiat_convert.get_price(crypto_symbol='USD', fiat_symbol='EUR') == 0.0
+
+
+def test_loadcryptomap(mocker):
+    patch_coinmarketcap(mocker)
+
+    fiat_convert = CryptoToFiatConverter()
+    assert len(fiat_convert._cryptomap) == 2
+
+    assert fiat_convert._cryptomap["BTC"] == "1"
+
+
+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',
+        listings=listmock,
+    )
+    # with pytest.raises(RequestEsxception):
+    fiat_convert = CryptoToFiatConverter()
+    fiat_convert._cryptomap = {}
+    fiat_convert._load_cryptomap()
+
+    length_cryptomap = len(fiat_convert._cryptomap)
+    assert length_cryptomap == 0
+
+
+def test_fiat_convert_without_network(mocker):
     # Because CryptoToFiatConverter is a Singleton we reset the value of _coinmarketcap
+    patch_coinmarketcap(mocker)
 
     fiat_convert = CryptoToFiatConverter()
 
+    cmc_temp = CryptoToFiatConverter._coinmarketcap
     CryptoToFiatConverter._coinmarketcap = None
 
     assert fiat_convert._coinmarketcap is None
     assert fiat_convert._find_price(crypto_symbol='BTC', fiat_symbol='USD') == 0.0
+    CryptoToFiatConverter._coinmarketcap = cmc_temp
+
+
+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',
+        listings=listmock,
+    )
+    # with pytest.raises(RequestEsxception):
+    fiat_convert = CryptoToFiatConverter()
+    fiat_convert._cryptomap = {}
+    fiat_convert._load_cryptomap()
+
+    length_cryptomap = len(fiat_convert._cryptomap)
+    assert length_cryptomap == 0
+    assert log_has('Could not load FIAT Cryptocurrency map for the following problem: TypeError',
+                   caplog.record_tuples)
+
+
+def test_convert_amount(mocker):
+    patch_coinmarketcap(mocker)
+    mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter.get_price', return_value=12345.0)
+
+    fiat_convert = CryptoToFiatConverter()
+    result = fiat_convert.convert_amount(
+        crypto_amount=1.23,
+        crypto_symbol="BTC",
+        fiat_symbol="USD"
+    )
+    assert result == 15184.35
+
+    result = fiat_convert.convert_amount(
+        crypto_amount=1.23,
+        crypto_symbol="BTC",
+        fiat_symbol="BTC"
+    )
+    assert result == 1.23

freqtrade/tests/test_indicator_helpers.py

@@ -1,6 +1,8 @@
+# pragma pylint: disable=missing-docstring
+
 import pandas as pd
 
-from freqtrade.indicator_helpers import went_up, went_down
+from freqtrade.indicator_helpers import went_down, went_up
 
 
 def test_went_up():

freqtrade/tests/test_main.py

@@ -1,14 +1,16 @@
-"""
-Unit test file for main.py
-"""
+# pragma pylint: disable=missing-docstring
 
-import logging
+from copy import deepcopy
 from unittest.mock import MagicMock
 
 import pytest
 
-from freqtrade.main import main, set_loggers
-from freqtrade.tests.conftest import log_has
+from freqtrade import OperationalException
+from freqtrade.arguments import Arguments
+from freqtrade.freqtradebot import FreqtradeBot
+from freqtrade.main import main, reconfigure
+from freqtrade.state import State
+from freqtrade.tests.conftest import log_has, patch_exchange
 
 
 def test_parse_args_backtesting(mocker) -> None:
@@ -22,72 +24,148 @@ def test_parse_args_backtesting(mocker) -> None:
     call_args = backtesting_mock.call_args[0][0]
     assert call_args.config == 'config.json'
     assert call_args.live is False
-    assert call_args.loglevel == 20
+    assert call_args.loglevel == 0
     assert call_args.subparser == 'backtesting'
     assert call_args.func is not None
     assert call_args.ticker_interval is None
 
 
 def test_main_start_hyperopt(mocker) -> None:
-    """
-    Test that main() can start hyperopt
-    """
     hyperopt_mock = mocker.patch('freqtrade.optimize.hyperopt.start', MagicMock())
     main(['hyperopt'])
     assert hyperopt_mock.call_count == 1
     call_args = hyperopt_mock.call_args[0][0]
     assert call_args.config == 'config.json'
-    assert call_args.loglevel == 20
+    assert call_args.loglevel == 0
     assert call_args.subparser == 'hyperopt'
     assert call_args.func is not None
 
 
-def test_set_loggers() -> None:
-    """
-    Test set_loggers() update the logger level for third-party libraries
-    """
-    previous_value1 = logging.getLogger('requests.packages.urllib3').level
-    previous_value2 = logging.getLogger('telegram').level
-
-    set_loggers()
-
-    value1 = logging.getLogger('requests.packages.urllib3').level
-    assert previous_value1 is not value1
-    assert value1 is logging.INFO
-
-    value2 = logging.getLogger('telegram').level
-    assert previous_value2 is not value2
-    assert value2 is logging.INFO
-
-
-def test_main(mocker, caplog) -> None:
-    """
-    Test main() function
-    In this test we are skipping the while True loop by throwing an exception.
-    """
+def test_main_fatal_exception(mocker, default_conf, caplog) -> None:
+    patch_exchange(mocker)
     mocker.patch.multiple(
         'freqtrade.freqtradebot.FreqtradeBot',
         _init_modules=MagicMock(),
-        worker=MagicMock(
-            side_effect=KeyboardInterrupt
-        ),
-        clean=MagicMock(),
+        worker=MagicMock(side_effect=Exception),
+        cleanup=MagicMock(),
     )
+    mocker.patch(
+        'freqtrade.configuration.Configuration._load_config_file',
+        lambda *args, **kwargs: default_conf
+    )
+    mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
+
     args = ['-c', 'config.json.example']
 
     # Test Main + the KeyboardInterrupt exception
-    with pytest.raises(SystemExit) as pytest_wrapped_e:
-        main(args)
-        log_has('Starting freqtrade', caplog.record_tuples)
-        log_has('Got SIGINT, aborting ...', caplog.record_tuples)
-        assert pytest_wrapped_e.type == SystemExit
-        assert pytest_wrapped_e.value.code == 42
-
-    # Test the BaseException case
-    mocker.patch(
-        'freqtrade.freqtradebot.FreqtradeBot.worker',
-        MagicMock(side_effect=BaseException)
-    )
     with pytest.raises(SystemExit):
         main(args)
-        log_has('Got fatal exception!', caplog.record_tuples)
+    assert log_has('Using config: config.json.example ...', caplog.record_tuples)
+    assert log_has('Fatal exception!', caplog.record_tuples)
+
+
+def test_main_keyboard_interrupt(mocker, default_conf, caplog) -> None:
+    patch_exchange(mocker)
+    mocker.patch.multiple(
+        'freqtrade.freqtradebot.FreqtradeBot',
+        _init_modules=MagicMock(),
+        worker=MagicMock(side_effect=KeyboardInterrupt),
+        cleanup=MagicMock(),
+    )
+    mocker.patch(
+        'freqtrade.configuration.Configuration._load_config_file',
+        lambda *args, **kwargs: default_conf
+    )
+    mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
+
+    args = ['-c', 'config.json.example']
+
+    # Test Main + the KeyboardInterrupt exception
+    with pytest.raises(SystemExit):
+        main(args)
+    assert log_has('Using config: config.json.example ...', caplog.record_tuples)
+    assert log_has('SIGINT received, aborting ...', caplog.record_tuples)
+
+
+def test_main_operational_exception(mocker, default_conf, caplog) -> None:
+    patch_exchange(mocker)
+    mocker.patch.multiple(
+        'freqtrade.freqtradebot.FreqtradeBot',
+        _init_modules=MagicMock(),
+        worker=MagicMock(side_effect=OperationalException('Oh snap!')),
+        cleanup=MagicMock(),
+    )
+    mocker.patch(
+        'freqtrade.configuration.Configuration._load_config_file',
+        lambda *args, **kwargs: default_conf
+    )
+    mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
+
+    args = ['-c', 'config.json.example']
+
+    # Test Main + the KeyboardInterrupt exception
+    with pytest.raises(SystemExit):
+        main(args)
+    assert log_has('Using config: config.json.example ...', caplog.record_tuples)
+    assert log_has('Oh snap!', caplog.record_tuples)
+
+
+def test_main_reload_conf(mocker, default_conf, caplog) -> None:
+    patch_exchange(mocker)
+    mocker.patch.multiple(
+        'freqtrade.freqtradebot.FreqtradeBot',
+        _init_modules=MagicMock(),
+        worker=MagicMock(return_value=State.RELOAD_CONF),
+        cleanup=MagicMock(),
+    )
+    mocker.patch(
+        'freqtrade.configuration.Configuration._load_config_file',
+        lambda *args, **kwargs: default_conf
+    )
+    mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
+
+    # Raise exception as side effect to avoid endless loop
+    reconfigure_mock = mocker.patch(
+        'freqtrade.main.reconfigure', MagicMock(side_effect=Exception)
+    )
+
+    with pytest.raises(SystemExit):
+        main(['-c', 'config.json.example'])
+
+    assert reconfigure_mock.call_count == 1
+    assert log_has('Using config: config.json.example ...', caplog.record_tuples)
+
+
+def test_reconfigure(mocker, default_conf) -> None:
+    patch_exchange(mocker)
+    mocker.patch.multiple(
+        'freqtrade.freqtradebot.FreqtradeBot',
+        _init_modules=MagicMock(),
+        worker=MagicMock(side_effect=OperationalException('Oh snap!')),
+        cleanup=MagicMock(),
+    )
+    mocker.patch(
+        'freqtrade.configuration.Configuration._load_config_file',
+        lambda *args, **kwargs: default_conf
+    )
+    mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
+
+    freqtrade = FreqtradeBot(default_conf)
+
+    # Renew mock to return modified data
+    conf = deepcopy(default_conf)
+    conf['stake_amount'] += 1
+    mocker.patch(
+        'freqtrade.configuration.Configuration._load_config_file',
+        lambda *args, **kwargs: conf
+    )
+
+    # reconfigure should return a new instance
+    freqtrade2 = reconfigure(
+        freqtrade,
+        Arguments(['-c', 'config.json.example'], '').get_parsed_arg()
+    )
+
+    # Verify we have a new instance with the new config
+    assert freqtrade is not freqtrade2
+    assert freqtrade.config['stake_amount'] + 1 == freqtrade2.config['stake_amount']

freqtrade/tests/test_misc.py

@@ -1,34 +1,23 @@
 # pragma pylint: disable=missing-docstring,C0103
 
-"""
-Unit test file for misc.py
-"""
-
 import datetime
 from unittest.mock import MagicMock
 
-from freqtrade.analyze import Analyze
-from freqtrade.misc import (shorten_date, datesarray_to_datetimearray,
-                            common_datearray, file_dump_json)
+from freqtrade.exchange.exchange_helpers import parse_ticker_dataframe
+from freqtrade.misc import (common_datearray, datesarray_to_datetimearray,
+                            file_dump_json, format_ms_time, shorten_date)
 from freqtrade.optimize.__init__ import load_tickerdata_file
+from freqtrade.strategy.default_strategy import DefaultStrategy
 
 
 def test_shorten_date() -> None:
-    """
-    Test shorten_date() function
-    :return: None
-    """
     str_data = '1 day, 2 hours, 3 minutes, 4 seconds ago'
     str_shorten_data = '1 d, 2 h, 3 min, 4 sec ago'
     assert shorten_date(str_data) == str_shorten_data
 
 
 def test_datesarray_to_datetimearray(ticker_history):
-    """
-    Test datesarray_to_datetimearray() function
-    :return: None
-    """
-    dataframes = Analyze.parse_ticker_dataframe(ticker_history)
+    dataframes = parse_ticker_dataframe(ticker_history)
     dates = datesarray_to_datetimearray(dataframes['date'])
 
     assert isinstance(dates[0], datetime.datetime)
@@ -39,33 +28,43 @@ def test_datesarray_to_datetimearray(ticker_history):
     assert dates[0].minute == 50
 
     date_len = len(dates)
-    assert date_len == 3
+    assert date_len == 2
 
 
-def test_common_datearray(default_conf, mocker) -> None:
-    """
-    Test common_datearray()
-    :return: None
-    """
-    analyze = Analyze(default_conf)
-    tick = load_tickerdata_file(None, 'BTC_UNITEST', 1)
-    tickerlist = {'BTC_UNITEST': tick}
-    dataframes = analyze.tickerdata_to_dataframe(tickerlist)
+def test_common_datearray(default_conf) -> None:
+    strategy = DefaultStrategy(default_conf)
+    tick = load_tickerdata_file(None, 'UNITTEST/BTC', '1m')
+    tickerlist = {'UNITTEST/BTC': tick}
+    dataframes = strategy.tickerdata_to_dataframe(tickerlist)
 
     dates = common_datearray(dataframes)
 
-    assert dates.size == dataframes['BTC_UNITEST']['date'].size
-    assert dates[0] == dataframes['BTC_UNITEST']['date'][0]
-    assert dates[-1] == dataframes['BTC_UNITEST']['date'][-1]
+    assert dates.size == dataframes['UNITTEST/BTC']['date'].size
+    assert dates[0] == dataframes['UNITTEST/BTC']['date'][0]
+    assert dates[-1] == dataframes['UNITTEST/BTC']['date'][-1]
 
 
 def test_file_dump_json(mocker) -> None:
-    """
-    Test file_dump_json()
-    :return: None
-    """
     file_open = mocker.patch('freqtrade.misc.open', MagicMock())
     json_dump = mocker.patch('json.dump', MagicMock())
     file_dump_json('somefile', [1, 2, 3])
     assert file_open.call_count == 1
     assert json_dump.call_count == 1
+    file_open = mocker.patch('freqtrade.misc.gzip.open', MagicMock())
+    json_dump = mocker.patch('json.dump', MagicMock())
+    file_dump_json('somefile', [1, 2, 3], True)
+    assert file_open.call_count == 1
+    assert json_dump.call_count == 1
+
+
+def test_format_ms_time() -> None:
+    # Date 2018-04-10 18:02:01
+    date_in_epoch_ms = 1523383321000
+    date = format_ms_time(date_in_epoch_ms)
+    assert type(date) is str
+    res = datetime.datetime(2018, 4, 10, 18, 2, 1, tzinfo=datetime.timezone.utc)
+    assert date == res.astimezone(None).strftime('%Y-%m-%dT%H:%M:%S')
+    res = datetime.datetime(2017, 12, 13, 8, 2, 1, tzinfo=datetime.timezone.utc)
+    # Date 2017-12-13 08:02:01
+    date_in_epoch_ms = 1513152121000
+    assert format_ms_time(date_in_epoch_ms) == res.astimezone(None).strftime('%Y-%m-%dT%H:%M:%S')

freqtrade/tests/test_persistence.py

@@ -1,11 +1,12 @@
 # pragma pylint: disable=missing-docstring, C0103
-import os
+from unittest.mock import MagicMock
 
 import pytest
 from sqlalchemy import create_engine
 
-from freqtrade.exchange import Exchanges
-from freqtrade.persistence import Trade, init, clean_dry_run_db
+from freqtrade import OperationalException, constants
+from freqtrade.persistence import Trade, clean_dry_run_db, init
+from freqtrade.tests.conftest import log_has
 
 
 @pytest.fixture(scope='function')
@@ -13,90 +14,54 @@ def init_persistence(default_conf):
     init(default_conf)
 
 
-def test_init_create_session(default_conf, mocker):
-    mocker.patch.dict('freqtrade.persistence._CONF', default_conf)
-
+def test_init_create_session(default_conf):
     # Check if init create a session
     init(default_conf)
     assert hasattr(Trade, 'session')
     assert 'Session' in type(Trade.session).__name__
 
 
-def test_init_dry_run_db(default_conf, mocker):
-    default_conf.update({'dry_run_db': True})
-    mocker.patch.dict('freqtrade.persistence._CONF', default_conf)
+def test_init_custom_db_url(default_conf, mocker):
+    # Update path to a value other than default, but still in-memory
+    default_conf.update({'db_url': 'sqlite:///tmp/freqtrade2_test.sqlite'})
+    create_engine_mock = mocker.patch('freqtrade.persistence.create_engine', MagicMock())
 
-    # First, protect the existing 'tradesv3.dry_run.sqlite' (Do not delete user data)
-    dry_run_db = 'tradesv3.dry_run.sqlite'
-    dry_run_db_swp = dry_run_db + '.swp'
-
-    if os.path.isfile(dry_run_db):
-        os.rename(dry_run_db, dry_run_db_swp)
-
-    # Check if the new tradesv3.dry_run.sqlite was created
     init(default_conf)
-    assert os.path.isfile(dry_run_db) is True
-
-    # Delete the file made for this unitest and rollback to the previous
-    # tradesv3.dry_run.sqlite file
-
-    # 1. Delete file from the test
-    if os.path.isfile(dry_run_db):
-        os.remove(dry_run_db)
-
-    # 2. Rollback to the initial file
-    if os.path.isfile(dry_run_db_swp):
-        os.rename(dry_run_db_swp, dry_run_db)
+    assert create_engine_mock.call_count == 1
+    assert create_engine_mock.mock_calls[0][1][0] == 'sqlite:///tmp/freqtrade2_test.sqlite'
 
 
-def test_init_dry_run_without_db(default_conf, mocker):
-    default_conf.update({'dry_run_db': False})
-    mocker.patch.dict('freqtrade.persistence._CONF', default_conf)
-
-    # First, protect the existing 'tradesv3.dry_run.sqlite' (Do not delete user data)
-    dry_run_db = 'tradesv3.dry_run.sqlite'
-    dry_run_db_swp = dry_run_db + '.swp'
-
-    if os.path.isfile(dry_run_db):
-        os.rename(dry_run_db, dry_run_db_swp)
-
-    # Check if the new tradesv3.dry_run.sqlite was created
+def test_init_invalid_db_url(default_conf):
+    # Update path to a value other than default, but still in-memory
+    default_conf.update({'db_url': 'unknown:///some.url'})
+    with pytest.raises(OperationalException, match=r'.*no valid database URL*'):
         init(default_conf)
-    assert os.path.isfile(dry_run_db) is False
-
-    # Rollback to the initial 'tradesv3.dry_run.sqlite' file
-    if os.path.isfile(dry_run_db_swp):
-        os.rename(dry_run_db_swp, dry_run_db)
 
 
 def test_init_prod_db(default_conf, mocker):
     default_conf.update({'dry_run': False})
-    mocker.patch.dict('freqtrade.persistence._CONF', default_conf)
+    default_conf.update({'db_url': constants.DEFAULT_DB_PROD_URL})
 
-    # First, protect the existing 'tradesv3.sqlite' (Do not delete user data)
-    prod_db = 'tradesv3.sqlite'
-    prod_db_swp = prod_db + '.swp'
+    create_engine_mock = mocker.patch('freqtrade.persistence.create_engine', MagicMock())
 
-    if os.path.isfile(prod_db):
-        os.rename(prod_db, prod_db_swp)
-
-    # Check if the new tradesv3.sqlite was created
     init(default_conf)
-    assert os.path.isfile(prod_db) is True
+    assert create_engine_mock.call_count == 1
+    assert create_engine_mock.mock_calls[0][1][0] == 'sqlite:///tradesv3.sqlite'
 
-    # Delete the file made for this unitest and rollback to the previous tradesv3.sqlite file
 
-    # 1. Delete file from the test
-    if os.path.isfile(prod_db):
-        os.remove(prod_db)
+def test_init_dryrun_db(default_conf, mocker):
+    default_conf.update({'dry_run': True})
+    default_conf.update({'db_url': constants.DEFAULT_DB_DRYRUN_URL})
 
-    # Rollback to the initial 'tradesv3.sqlite' file
-    if os.path.isfile(prod_db_swp):
-        os.rename(prod_db_swp, prod_db)
+    create_engine_mock = mocker.patch('freqtrade.persistence.create_engine', MagicMock())
+
+    init(default_conf)
+    assert create_engine_mock.call_count == 1
+    assert create_engine_mock.mock_calls[0][1][0] == 'sqlite://'
 
 
 @pytest.mark.usefixtures("init_persistence")
-def test_update_with_bittrex(limit_buy_order, limit_sell_order):
+def test_update_with_bittrex(limit_buy_order, limit_sell_order, fee):
     """
     On this test we will buy and sell a crypto currency.
 
@@ -125,10 +90,11 @@ def test_update_with_bittrex(limit_buy_order, limit_sell_order):
     """
 
     trade = Trade(
-        pair='BTC_ETH',
+        pair='ETH/BTC',
         stake_amount=0.001,
-        fee=0.0025,
-        exchange=Exchanges.BITTREX,
+        fee_open=fee.return_value,
+        fee_close=fee.return_value,
+        exchange='bittrex',
     )
     assert trade.open_order_id is None
     assert trade.open_rate is None
@@ -151,12 +117,13 @@ def test_update_with_bittrex(limit_buy_order, limit_sell_order):
 
 
 @pytest.mark.usefixtures("init_persistence")
-def test_calc_open_close_trade_price(limit_buy_order, limit_sell_order):
+def test_calc_open_close_trade_price(limit_buy_order, limit_sell_order, fee):
     trade = Trade(
-        pair='BTC_ETH',
+        pair='ETH/BTC',
         stake_amount=0.001,
-        fee=0.0025,
-        exchange=Exchanges.BITTREX,
+        fee_open=fee.return_value,
+        fee_close=fee.return_value,
+        exchange='bittrex',
     )
 
     trade.open_order_id = 'something'
@@ -174,12 +141,13 @@ def test_calc_open_close_trade_price(limit_buy_order, limit_sell_order):
 
 
 @pytest.mark.usefixtures("init_persistence")
-def test_calc_close_trade_price_exception(limit_buy_order):
+def test_calc_close_trade_price_exception(limit_buy_order, fee):
     trade = Trade(
-        pair='BTC_ETH',
+        pair='ETH/BTC',
         stake_amount=0.001,
-        fee=0.0025,
-        exchange=Exchanges.BITTREX,
+        fee_open=fee.return_value,
+        fee_close=fee.return_value,
+        exchange='bittrex',
     )
 
     trade.open_order_id = 'something'
@@ -190,10 +158,11 @@ def test_calc_close_trade_price_exception(limit_buy_order):
 @pytest.mark.usefixtures("init_persistence")
 def test_update_open_order(limit_buy_order):
     trade = Trade(
-        pair='BTC_ETH',
+        pair='ETH/BTC',
         stake_amount=1.00,
-        fee=0.1,
-        exchange=Exchanges.BITTREX,
+        fee_open=0.1,
+        fee_close=0.1,
+        exchange='bittrex',
     )
 
     assert trade.open_order_id is None
@@ -201,7 +170,7 @@ def test_update_open_order(limit_buy_order):
     assert trade.close_profit is None
     assert trade.close_date is None
 
-    limit_buy_order['closed'] = False
+    limit_buy_order['status'] = 'open'
     trade.update(limit_buy_order)
 
     assert trade.open_order_id is None
@@ -213,10 +182,11 @@ def test_update_open_order(limit_buy_order):
 @pytest.mark.usefixtures("init_persistence")
 def test_update_invalid_order(limit_buy_order):
     trade = Trade(
-        pair='BTC_ETH',
+        pair='ETH/BTC',
         stake_amount=1.00,
-        fee=0.1,
-        exchange=Exchanges.BITTREX,
+        fee_open=0.1,
+        fee_close=0.1,
+        exchange='bittrex',
     )
     limit_buy_order['type'] = 'invalid'
     with pytest.raises(ValueError, match=r'Unknown order type'):
@@ -224,12 +194,13 @@ def test_update_invalid_order(limit_buy_order):
 
 
 @pytest.mark.usefixtures("init_persistence")
-def test_calc_open_trade_price(limit_buy_order):
+def test_calc_open_trade_price(limit_buy_order, fee):
     trade = Trade(
-        pair='BTC_ETH',
+        pair='ETH/BTC',
         stake_amount=0.001,
-        fee=0.0025,
-        exchange=Exchanges.BITTREX,
+        fee_open=fee.return_value,
+        fee_close=fee.return_value,
+        exchange='bittrex',
     )
     trade.open_order_id = 'open_trade'
     trade.update(limit_buy_order)  # Buy @ 0.00001099
@@ -242,12 +213,13 @@ def test_calc_open_trade_price(limit_buy_order):
 
 
 @pytest.mark.usefixtures("init_persistence")
-def test_calc_close_trade_price(limit_buy_order, limit_sell_order):
+def test_calc_close_trade_price(limit_buy_order, limit_sell_order, fee):
     trade = Trade(
-        pair='BTC_ETH',
+        pair='ETH/BTC',
         stake_amount=0.001,
-        fee=0.0025,
-        exchange=Exchanges.BITTREX,
+        fee_open=fee.return_value,
+        fee_close=fee.return_value,
+        exchange='bittrex',
     )
     trade.open_order_id = 'close_trade'
     trade.update(limit_buy_order)  # Buy @ 0.00001099
@@ -264,12 +236,13 @@ def test_calc_close_trade_price(limit_buy_order, limit_sell_order):
 
 
 @pytest.mark.usefixtures("init_persistence")
-def test_calc_profit(limit_buy_order, limit_sell_order):
+def test_calc_profit(limit_buy_order, limit_sell_order, fee):
     trade = Trade(
-        pair='BTC_ETH',
+        pair='ETH/BTC',
         stake_amount=0.001,
-        fee=0.0025,
-        exchange=Exchanges.BITTREX,
+        fee_open=fee.return_value,
+        fee_close=fee.return_value,
+        exchange='bittrex',
     )
     trade.open_order_id = 'profit_percent'
     trade.update(limit_buy_order)  # Buy @ 0.00001099
@@ -295,12 +268,13 @@ def test_calc_profit(limit_buy_order, limit_sell_order):
 
 
 @pytest.mark.usefixtures("init_persistence")
-def test_calc_profit_percent(limit_buy_order, limit_sell_order):
+def test_calc_profit_percent(limit_buy_order, limit_sell_order, fee):
     trade = Trade(
-        pair='BTC_ETH',
+        pair='ETH/BTC',
         stake_amount=0.001,
-        fee=0.0025,
-        exchange=Exchanges.BITTREX,
+        fee_open=fee.return_value,
+        fee_close=fee.return_value,
+        exchange='bittrex',
     )
     trade.open_order_id = 'profit_percent'
     trade.update(limit_buy_order)  # Buy @ 0.00001099
@@ -319,40 +293,43 @@ def test_calc_profit_percent(limit_buy_order, limit_sell_order):
     assert trade.calc_profit_percent(fee=0.003) == 0.0614782
 
 
-def test_clean_dry_run_db(default_conf):
-    init(default_conf, create_engine('sqlite://'))
+def test_clean_dry_run_db(default_conf, fee):
+    init(default_conf)
 
     # Simulate dry_run entries
     trade = Trade(
-        pair='BTC_ETH',
+        pair='ETH/BTC',
         stake_amount=0.001,
         amount=123.0,
-        fee=0.0025,
+        fee_open=fee.return_value,
+        fee_close=fee.return_value,
         open_rate=0.123,
-        exchange='BITTREX',
+        exchange='bittrex',
         open_order_id='dry_run_buy_12345'
     )
     Trade.session.add(trade)
 
     trade = Trade(
-        pair='BTC_ETC',
+        pair='ETC/BTC',
         stake_amount=0.001,
         amount=123.0,
-        fee=0.0025,
+        fee_open=fee.return_value,
+        fee_close=fee.return_value,
         open_rate=0.123,
-        exchange='BITTREX',
+        exchange='bittrex',
         open_order_id='dry_run_sell_12345'
     )
     Trade.session.add(trade)
 
     # Simulate prod entry
     trade = Trade(
-        pair='BTC_ETC',
+        pair='ETC/BTC',
         stake_amount=0.001,
         amount=123.0,
-        fee=0.0025,
+        fee_open=fee.return_value,
+        fee_close=fee.return_value,
         open_rate=0.123,
-        exchange='BITTREX',
+        exchange='bittrex',
         open_order_id='prod_buy_12345'
     )
     Trade.session.add(trade)
@@ -364,3 +341,238 @@ def test_clean_dry_run_db(default_conf):
 
     # We have now only the prod
     assert len(Trade.query.filter(Trade.open_order_id.isnot(None)).all()) == 1
+
+
+def test_migrate_old(mocker, default_conf, fee):
+    """
+    Test Database migration(starting with old pairformat)
+    """
+    amount = 103.223
+    create_table_old = """CREATE TABLE IF NOT EXISTS "trades" (
+                                id INTEGER NOT NULL,
+                                exchange VARCHAR NOT NULL,
+                                pair VARCHAR NOT NULL,
+                                is_open BOOLEAN NOT NULL,
+                                fee FLOAT NOT NULL,
+                                open_rate FLOAT,
+                                close_rate FLOAT,
+                                close_profit FLOAT,
+                                stake_amount FLOAT NOT NULL,
+                                amount FLOAT,
+                                open_date DATETIME NOT NULL,
+                                close_date DATETIME,
+                                open_order_id VARCHAR,
+                                PRIMARY KEY (id),
+                                CHECK (is_open IN (0, 1))
+                                );"""
+    insert_table_old = """INSERT INTO trades (exchange, pair, is_open, fee,
+                          open_rate, stake_amount, amount, open_date)
+                          VALUES ('BITTREX', 'BTC_ETC', 1, {fee},
+                          0.00258580, {stake}, {amount},
+                          '2017-11-28 12:44:24.000000')
+                          """.format(fee=fee.return_value,
+                                     stake=default_conf.get("stake_amount"),
+                                     amount=amount
+                                     )
+    engine = create_engine('sqlite://')
+    mocker.patch('freqtrade.persistence.create_engine', lambda *args, **kwargs: engine)
+
+    # Create table using the old format
+    engine.execute(create_table_old)
+    engine.execute(insert_table_old)
+    # Run init to test migration
+    init(default_conf)
+
+    assert len(Trade.query.filter(Trade.id == 1).all()) == 1
+    trade = Trade.query.filter(Trade.id == 1).first()
+    assert trade.fee_open == fee.return_value
+    assert trade.fee_close == fee.return_value
+    assert trade.open_rate_requested is None
+    assert trade.close_rate_requested is None
+    assert trade.is_open == 1
+    assert trade.amount == amount
+    assert trade.stake_amount == default_conf.get("stake_amount")
+    assert trade.pair == "ETC/BTC"
+    assert trade.exchange == "bittrex"
+    assert trade.max_rate == 0.0
+    assert trade.stop_loss == 0.0
+    assert trade.initial_stop_loss == 0.0
+
+
+def test_migrate_new(mocker, default_conf, fee, caplog):
+    """
+    Test Database migration (starting with new pairformat)
+    """
+    amount = 103.223
+    # Always create all columns apart from the last!
+    create_table_old = """CREATE TABLE IF NOT EXISTS "trades" (
+                                id INTEGER NOT NULL,
+                                exchange VARCHAR NOT NULL,
+                                pair VARCHAR NOT NULL,
+                                is_open BOOLEAN NOT NULL,
+                                fee FLOAT NOT NULL,
+                                open_rate FLOAT,
+                                close_rate FLOAT,
+                                close_profit FLOAT,
+                                stake_amount FLOAT NOT NULL,
+                                amount FLOAT,
+                                open_date DATETIME NOT NULL,
+                                close_date DATETIME,
+                                open_order_id VARCHAR,
+                                stop_loss FLOAT,
+                                initial_stop_loss FLOAT,
+                                max_rate FLOAT,
+                                sell_reason VARCHAR,
+                                strategy VARCHAR,
+                                PRIMARY KEY (id),
+                                CHECK (is_open IN (0, 1))
+                                );"""
+    insert_table_old = """INSERT INTO trades (exchange, pair, is_open, fee,
+                          open_rate, stake_amount, amount, open_date,
+                          stop_loss, initial_stop_loss, max_rate)
+                          VALUES ('binance', 'ETC/BTC', 1, {fee},
+                          0.00258580, {stake}, {amount},
+                          '2019-11-28 12:44:24.000000',
+                          0.0, 0.0, 0.0)
+                          """.format(fee=fee.return_value,
+                                     stake=default_conf.get("stake_amount"),
+                                     amount=amount
+                                     )
+    engine = create_engine('sqlite://')
+    mocker.patch('freqtrade.persistence.create_engine', lambda *args, **kwargs: engine)
+
+    # Create table using the old format
+    engine.execute(create_table_old)
+    engine.execute(insert_table_old)
+
+    # fake previous backup
+    engine.execute("create table trades_bak as select * from trades")
+
+    engine.execute("create table trades_bak1 as select * from trades")
+    # Run init to test migration
+    init(default_conf)
+
+    assert len(Trade.query.filter(Trade.id == 1).all()) == 1
+    trade = Trade.query.filter(Trade.id == 1).first()
+    assert trade.fee_open == fee.return_value
+    assert trade.fee_close == fee.return_value
+    assert trade.open_rate_requested is None
+    assert trade.close_rate_requested is None
+    assert trade.is_open == 1
+    assert trade.amount == amount
+    assert trade.stake_amount == default_conf.get("stake_amount")
+    assert trade.pair == "ETC/BTC"
+    assert trade.exchange == "binance"
+    assert trade.max_rate == 0.0
+    assert trade.stop_loss == 0.0
+    assert trade.initial_stop_loss == 0.0
+    assert trade.sell_reason is None
+    assert trade.strategy is None
+    assert trade.ticker_interval is None
+    assert log_has("trying trades_bak1", caplog.record_tuples)
+    assert log_has("trying trades_bak2", caplog.record_tuples)
+
+
+def test_migrate_mid_state(mocker, default_conf, fee, caplog):
+    """
+    Test Database migration (starting with new pairformat)
+    """
+    amount = 103.223
+    create_table_old = """CREATE TABLE IF NOT EXISTS "trades" (
+                                id INTEGER NOT NULL,
+                                exchange VARCHAR NOT NULL,
+                                pair VARCHAR NOT NULL,
+                                is_open BOOLEAN NOT NULL,
+                                fee_open FLOAT NOT NULL,
+                                fee_close FLOAT NOT NULL,
+                                open_rate FLOAT,
+                                close_rate FLOAT,
+                                close_profit FLOAT,
+                                stake_amount FLOAT NOT NULL,
+                                amount FLOAT,
+                                open_date DATETIME NOT NULL,
+                                close_date DATETIME,
+                                open_order_id VARCHAR,
+                                PRIMARY KEY (id),
+                                CHECK (is_open IN (0, 1))
+                                );"""
+    insert_table_old = """INSERT INTO trades (exchange, pair, is_open, fee_open, fee_close,
+                          open_rate, stake_amount, amount, open_date)
+                          VALUES ('binance', 'ETC/BTC', 1, {fee}, {fee},
+                          0.00258580, {stake}, {amount},
+                          '2019-11-28 12:44:24.000000')
+                          """.format(fee=fee.return_value,
+                                     stake=default_conf.get("stake_amount"),
+                                     amount=amount
+                                     )
+    engine = create_engine('sqlite://')
+    mocker.patch('freqtrade.persistence.create_engine', lambda *args, **kwargs: engine)
+
+    # Create table using the old format
+    engine.execute(create_table_old)
+    engine.execute(insert_table_old)
+
+    # Run init to test migration
+    init(default_conf)
+
+    assert len(Trade.query.filter(Trade.id == 1).all()) == 1
+    trade = Trade.query.filter(Trade.id == 1).first()
+    assert trade.fee_open == fee.return_value
+    assert trade.fee_close == fee.return_value
+    assert trade.open_rate_requested is None
+    assert trade.close_rate_requested is None
+    assert trade.is_open == 1
+    assert trade.amount == amount
+    assert trade.stake_amount == default_conf.get("stake_amount")
+    assert trade.pair == "ETC/BTC"
+    assert trade.exchange == "binance"
+    assert trade.max_rate == 0.0
+    assert trade.stop_loss == 0.0
+    assert trade.initial_stop_loss == 0.0
+    assert log_has("trying trades_bak0", caplog.record_tuples)
+
+
+def test_adjust_stop_loss(limit_buy_order, limit_sell_order, fee):
+    trade = Trade(
+        pair='ETH/BTC',
+        stake_amount=0.001,
+        fee_open=fee.return_value,
+        fee_close=fee.return_value,
+        exchange='bittrex',
+        open_rate=1,
+    )
+
+    trade.adjust_stop_loss(trade.open_rate, 0.05, True)
+    assert trade.stop_loss == 0.95
+    assert trade.max_rate == 1
+    assert trade.initial_stop_loss == 0.95
+
+    # Get percent of profit with a lowre rate
+    trade.adjust_stop_loss(0.96, 0.05)
+    assert trade.stop_loss == 0.95
+    assert trade.max_rate == 1
+    assert trade.initial_stop_loss == 0.95
+
+    # Get percent of profit with a custom rate (Higher than open rate)
+    trade.adjust_stop_loss(1.3, -0.1)
+    assert round(trade.stop_loss, 8) == 1.17
+    assert trade.max_rate == 1.3
+    assert trade.initial_stop_loss == 0.95
+
+    # current rate lower again ... should not change
+    trade.adjust_stop_loss(1.2, 0.1)
+    assert round(trade.stop_loss, 8) == 1.17
+    assert trade.max_rate == 1.3
+    assert trade.initial_stop_loss == 0.95
+
+    # current rate higher... should raise stoploss
+    trade.adjust_stop_loss(1.4, 0.1)
+    assert round(trade.stop_loss, 8) == 1.26
+    assert trade.max_rate == 1.4
+    assert trade.initial_stop_loss == 0.95
+
+    #  Initial is true but stop_loss set - so doesn't do anything
+    trade.adjust_stop_loss(1.7, 0.1, True)
+    assert round(trade.stop_loss, 8) == 1.26
+    assert trade.max_rate == 1.4
+    assert trade.initial_stop_loss == 0.95

freqtrade/tests/test_state.py

@@ -1,14 +0,0 @@
-"""
-Unit test file for constants.py
-"""
-
-from freqtrade.state import State
-
-
-def test_state_object() -> None:
-    """
-    Test the State object has the mandatory states
-    :return: None
-    """
-    assert hasattr(State, 'RUNNING')
-    assert hasattr(State, 'STOPPED')

freqtrade/tests/test_talib.py

@@ -0,0 +1,16 @@
+
+
+import talib.abstract as ta
+import pandas as pd
+
+
+def test_talib_bollingerbands_near_zero_values():
+    inputs = pd.DataFrame([
+        {'close': 0.00000010},
+        {'close': 0.00000011},
+        {'close': 0.00000012},
+        {'close': 0.00000013},
+        {'close': 0.00000014}
+    ])
+    bollinger = ta.BBANDS(inputs, matype=0, timeperiod=2)
+    assert (bollinger['upperband'][3] != bollinger['middleband'][3])