Merge branch 'wohlgemuth' of https://github.com/berlinguyinca/freqtrade into wohlgemuth

.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

@@ -7,6 +7,7 @@ config*.json
 logfile.txt
 hyperopt_trials.pickle
 freqtrade-plot.html
+freqtrade-profit-plot.html
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

.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

@@ -18,17 +18,17 @@ install:
 - 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
     - script: mypy freqtrade
-after_success:
-- coveralls
 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,6 +42,11 @@ 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)

README.md

@@ -1,8 +1,8 @@
 # freqtrade
 
-[![Build Status](https://travis-ci.org/gcarq/freqtrade.svg?branch=develop)](https://travis-ci.org/gcarq/freqtrade)
+[![Build Status](https://travis-ci.org/freqtrade/freqtrade.svg?branch=develop)](https://travis-ci.org/freqtrade/freqtrade)
-[![Coverage Status](https://coveralls.io/repos/github/gcarq/freqtrade/badge.svg?branch=develop&service=github)](https://coveralls.io/github/gcarq/freqtrade?branch=develop)
+[![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/gcarq/freqtrade/maintainability)
+[![Maintainability](https://api.codeclimate.com/v1/badges/5737e6d668200b7518ff/maintainability)](https://codeclimate.com/github/freqtrade/freqtrade/maintainability)
 
 ## First of all, this is a fork!
 
@@ -17,7 +17,7 @@ This reminds of the Torvalds kernel vs the Cox kernel...
 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 
@@ -34,12 +34,12 @@ hesitate to read the source code and understand the mechanism of this bot.
 ## Table of Contents
 - [Features](#features)
 - [Quick start](#quick-start)
-- [Documentations](https://github.com/gcarq/freqtrade/blob/develop/docs/index.md)
+- [Documentations](https://github.com/freqtrade/freqtrade/blob/develop/docs/index.md)
-   - [Installation](https://github.com/gcarq/freqtrade/blob/develop/docs/installation.md)
+   - [Installation](https://github.com/freqtrade/freqtrade/blob/develop/docs/installation.md)
-   - [Configuration](https://github.com/gcarq/freqtrade/blob/develop/docs/configuration.md)
+   - [Configuration](https://github.com/freqtrade/freqtrade/blob/develop/docs/configuration.md)
-   - [Strategy Optimization](https://github.com/gcarq/freqtrade/blob/develop/docs/bot-optimization.md)
+   - [Strategy Optimization](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-optimization.md)
-   - [Backtesting](https://github.com/gcarq/freqtrade/blob/develop/docs/backtesting.md)
+   - [Backtesting](https://github.com/freqtrade/freqtrade/blob/develop/docs/backtesting.md)
-   - [Hyperopt](https://github.com/gcarq/freqtrade/blob/develop/docs/hyperopt.md)
+   - [Hyperopt](https://github.com/freqtrade/freqtrade/blob/develop/docs/hyperopt.md)
 - [Support](#support)
    - [Help](#help--slack)
    - [Bugs](#bugs--issues)
@@ -99,7 +99,7 @@ strategy parameters with real exchange data.
 ## 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) 
+[bot documentation](https://github.com/freqtrade/freqtrade/blob/develop/docs/index.md) 
 to ensure you understand how the bot is working.
 
 ### Easy installation
@@ -113,7 +113,7 @@ The following steps are made for Linux/MacOS environment
 
 **1. Clone the repo**
 ```bash
-git clone git@github.com:gcarq/freqtrade.git
+git clone git@github.com:freqtrade/freqtrade.git
 git checkout develop
 cd freqtrade
 ```
@@ -135,26 +135,26 @@ 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)
+### [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/gcarq/freqtrade/issues?q=is%3Aissue) 
+[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/gcarq/freqtrade/issues/new) and 
+[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/gcarq/freqtrade/labels/enhancement)
+### [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/gcarq/freqtrade/labels/enhancement).
+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/gcarq/freqtrade/issues/new) 
+[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/gcarq/freqtrade/pulls)
+### [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/gcarq/freqtrade/blob/develop/CONTRIBUTING.md)
+[Contributing document](https://github.com/freqtrade/freqtrade/blob/develop/CONTRIBUTING.md)
 to understand the requirements before sending your pull-requests. 
 
 **Important:** Always create your PR against the `develop` branch, not 
@@ -197,14 +197,14 @@ optional arguments:
                         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 run the bot](https://github.com/freqtrade/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 Backtesting](https://github.com/freqtrade/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)
+- [How to use Hyperopt](https://github.com/freqtrade/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)
+[documentation](https://github.com/freqtrade/freqtrade/blob/develop/docs/index.md)
 
 - `/start`: Starts the trader
 - `/stop`: Stops the trader

config.json.example

@@ -10,7 +10,14 @@
     },
     "unfilledtimeout": 600,
     "bid_strategy": {
-        "ask_last_balance": 0.0
+        "ask_last_balance": 0.0,
+        "use_book_order": true,
+        "book_order_top": 6
+    },
+    "ask_strategy":{
+        "use_book_order": true,
+        "book_order_min": 1,
+        "book_order_max": 30
     },
     "exchange": {
         "name": "bittrex",

config_full.json.example

@@ -15,7 +15,14 @@
     "stoploss": -0.10,
     "unfilledtimeout": 600,
     "bid_strategy": {
-        "ask_last_balance": 0.0
+        "ask_last_balance": 0.0,
+        "use_book_order": true,
+        "book_order_top": 6
+    },
+    "ask_strategy":{
+        "use_book_order": true,
+        "book_order_min": 1,
+        "book_order_max": 30
     },
     "exchange": {
         "name": "bittrex",
@@ -46,6 +53,7 @@
         "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

@@ -14,7 +14,7 @@ real data. This is what we call
 
 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.
@@ -93,22 +93,31 @@ The full timerange specification:
                                                 `--timerange=1527595200-1527618600`
 
 
-**Update testdata directory**
+**Downloading new set of ticker data**
-To update your testdata directory, or download into another testdata directory:
+To download new set of backtesting ticker data, you can use a download script.
-```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
+If you are using Binance for example:
+- create a folder `user_data/data/binance` and copy `pairs.json` in that folder.
+- update the `pairs.json` to contain the currency pairs you are interested in.
 
 ```bash
-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
+Then run:
-into the current working directory.
+
+```bash
+python scripts/download_backtest_data --exchange binance
+```
+
+This will download ticker data for all the currency pairs you defined in `pairs.json`.
+
+- To use a different folder than the exchange specific default, use `--export user_data/data/some_directory`.
+- To change the exchange used to download the tickers, use `--exchange`. Default is `bittrex`.
+- To use `pairs.json` from some other folder, use `--pairs-file some_other_dir/pairs.json`.
+- To download ticker data for only 10 days, use `--days 10`.
+- Use `--timeframes` to specify which tickers to download. Default is `--timeframes 1m 5m` which will download 1-minute and 5-minute tickers.
 
 
 For help about backtesting usage, please refer to 
@@ -166,4 +175,4 @@ strategies, your configuration, and the crypto-currency you have set up.
 ## 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,12 +27,14 @@ 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
@@ -43,20 +49,23 @@ 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.
 
 Sample from `user_data/strategies/test_strategy.py`:
+
 ```python
 def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
     """
@@ -76,10 +85,11 @@ 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.
 
 Sample from `user_data/strategies/test_strategy.py`:
+
 ```python
 def populate_sell_trend(self, dataframe: DataFrame) -> DataFrame:
     """
@@ -98,11 +108,13 @@ def populate_sell_trend(self, dataframe: DataFrame) -> 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.
 
 Sample:
+
 ```python
 def populate_indicators(dataframe: DataFrame) -> DataFrame:
     """
@@ -137,16 +149,25 @@ def populate_indicators(dataframe: DataFrame) -> DataFrame:
     return dataframe
 ```
 
-**Want more indicators example?**  
+### Want more indicator examples
-Look into the [user_data/strategies/test_strategy.py](https://github.com/gcarq/freqtrade/blob/develop/user_data/strategies/test_strategy.py).  
+
+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

@@ -9,9 +9,9 @@ it.
 
 ## Bot commands
 ```
-usage: main.py [-h] [-v] [--version] [-c PATH] [-d PATH] [-s NAME]
+usage: freqtrade [-h] [-v] [--version] [-c PATH] [-d PATH] [-s NAME]
                  [--strategy-path PATH] [--dynamic-whitelist [INT]]
-               [--dry-run-db]
+                 [--db-url PATH]
                  {backtesting,hyperopt} ...
 
 Simple High Frequency Trading Bot for crypto currencies
@@ -28,17 +28,16 @@ optional arguments:
   -c PATH, --config PATH
                         specify configuration file (default: config.json)
   -d PATH, --datadir PATH
-                        path to backtest data (default:
+                        path to backtest data
-                        freqtrade/tests/testdata
   -s NAME, --strategy NAME
                         specify strategy class name (default: DefaultStrategy)
   --strategy-path PATH  specify additional strategy lookup path
   --dynamic-whitelist [INT]
                         dynamically generate and update whitelist based on 24h
-                        BaseVolume (Default 20 currencies)
+                        BaseVolume (default: 20)
-  --dry-run-db          Force dry run to use a local DB
+  --db-url PATH         Override trades database URL, this is useful if
-                        "tradesv3.dry_run.sqlite" instead of memory DB. Work
+                        dry_run is enabled or in custom deployments (default:
-                        only if dry_run is enabled.
+                        sqlite:///tradesv3.sqlite)
 ```
 
 ### How to use a different config file?
@@ -68,7 +67,7 @@ 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
@@ -102,14 +101,14 @@ 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 
+using `--db-url`. This can also be used to specify a custom database
-`tradesv3.dry_run.sqlite`
+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
 ```
 
 
@@ -189,9 +188,9 @@ optional arguments:
 
 ## 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).
+[optimize your bot](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-optimization.md).

docs/configuration.md

@@ -34,13 +34,14 @@ The table below will list all configuration parameters.
 | `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`.
+| `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).
+[misc.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/misc.py#L205).
 
 ### Understand minimal_roi
 `minimal_roi` is a JSON object where the key is a duration
@@ -73,6 +74,12 @@ value. This parameter is optional. If you use it, it will take over the
 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
@@ -92,8 +99,10 @@ The bot was tested with the following exchanges:
 Feel free to test other exchanges and submit your PR to improve the bot.
 
 ### What values for fiat_display_currency?
-`fiat_display_currency` set the fiat to use for the conversion form coin to fiat in Telegram. 
+`fiat_display_currency` set the base currency to use for the conversion from 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".
+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
@@ -103,9 +112,10 @@ 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 Exchange API key (change them by fake api credentials)
@@ -129,7 +139,7 @@ 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,
 ```
@@ -144,9 +154,8 @@ you run it in production mode.
 }
 ```
 If you have not your Bittrex API key yet, 
-[see our tutorial](https://github.com/gcarq/freqtrade/blob/develop/docs/pre-requisite.md).
+[see our tutorial](https://github.com/freqtrade/freqtrade/blob/develop/docs/pre-requisite.md).
-
 
 ## 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).
+[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

@@ -14,13 +14,13 @@ parameters with Hyperopt.
 
 ## 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)
+your strategy file located into [user_data/strategies/](https://github.com/freqtrade/freqtrade/blob/develop/user_data/strategies/test_strategy.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 [populate_buy_trend()](https://github.com/freqtrade/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`.
+- Inside [hyperopt_space()](https://github.com/freqtrade/freqtrade/blob/develop/user_data/strategies/test_strategy.py#L244-L297) known as `SPACE`.
 
 There you have two different type of indicators: 1. `guards` and 2. 
 `triggers`.
@@ -110,13 +110,13 @@ 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).
+[user_data/hyperopt_conf.py](https://github.com/freqtrade/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).
+parameters, you do this by adding them into the [hyperopt_space()](https://github.com/freqtrade/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.
 
@@ -312,4 +312,4 @@ def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
 
 ## 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

@@ -6,27 +6,27 @@ 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)
+- [Pre-requisite](https://github.com/freqtrade/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 Bittrex account](https://github.com/freqtrade/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)
+	- [Setup your Telegram bot](https://github.com/freqtrade/freqtrade/blob/develop/docs/pre-requisite.md#setup-your-telegram-bot)
-- [Bot Installation](https://github.com/gcarq/freqtrade/blob/develop/docs/installation.md)
+- [Bot Installation](https://github.com/freqtrade/freqtrade/blob/develop/docs/installation.md)
-    - [Install with Docker (all platforms)](https://github.com/gcarq/freqtrade/blob/develop/docs/installation.md#docker)
+    - [Install with Docker (all platforms)](https://github.com/freqtrade/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 Linux Ubuntu](https://github.com/freqtrade/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 MacOS](https://github.com/freqtrade/freqtrade/blob/develop/docs/installation.md#23-macos-installation)
-    - [Install on Windows](https://github.com/gcarq/freqtrade/blob/develop/docs/installation.md#windows)
+    - [Install on Windows](https://github.com/freqtrade/freqtrade/blob/develop/docs/installation.md#windows)
-- [Bot Configuration](https://github.com/gcarq/freqtrade/blob/develop/docs/configuration.md)
+- [Bot Configuration](https://github.com/freqtrade/freqtrade/blob/develop/docs/configuration.md)
-- [Bot usage (Start your bot)](https://github.com/gcarq/freqtrade/blob/develop/docs/bot-usage.md)
+- [Bot usage (Start your bot)](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md)
-    - [Bot commands](https://github.com/gcarq/freqtrade/blob/develop/docs/bot-usage.md#bot-commands)
+    - [Bot commands](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md#bot-commands)
-    - [Backtesting commands](https://github.com/gcarq/freqtrade/blob/develop/docs/bot-usage.md#backtesting-commands)
+    - [Backtesting commands](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md#backtesting-commands)
-    - [Hyperopt commands](https://github.com/gcarq/freqtrade/blob/develop/docs/bot-usage.md#hyperopt-commands)
+    - [Hyperopt commands](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md#hyperopt-commands)
-- [Bot Optimization](https://github.com/gcarq/freqtrade/blob/develop/docs/bot-optimization.md)
+- [Bot Optimization](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-optimization.md)
-	- [Change your strategy](https://github.com/gcarq/freqtrade/blob/develop/docs/bot-optimization.md#change-your-strategy)
+	- [Change your strategy](https://github.com/freqtrade/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)
+    - [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/gcarq/freqtrade/blob/develop/docs/backtesting.md)
+    - [Test your strategy with Backtesting](https://github.com/freqtrade/freqtrade/blob/develop/docs/backtesting.md)
-    - [Find optimal parameters with Hyperopt](https://github.com/gcarq/freqtrade/blob/develop/docs/hyperopt.md)
+    - [Find optimal parameters with Hyperopt](https://github.com/freqtrade/freqtrade/blob/develop/docs/hyperopt.md)
-- [Control the bot with telegram](https://github.com/gcarq/freqtrade/blob/develop/docs/telegram-usage.md)
+- [Control the bot with telegram](https://github.com/freqtrade/freqtrade/blob/develop/docs/telegram-usage.md)
-- [Contribute to the project](https://github.com/gcarq/freqtrade/blob/develop/CONTRIBUTING.md)
+- [Contribute to the project](https://github.com/freqtrade/freqtrade/blob/develop/CONTRIBUTING.md)
-	- [How to contribute](https://github.com/gcarq/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/gcarq/freqtrade/blob/develop/CONTRIBUTING.md)
+	- [Run tests & Check PEP8 compliance](https://github.com/freqtrade/freqtrade/blob/develop/CONTRIBUTING.md)
-- [FAQ](https://github.com/gcarq/freqtrade/blob/develop/docs/faq.md)
+- [FAQ](https://github.com/freqtrade/freqtrade/blob/develop/docs/faq.md)
-    - [SQL cheatsheet](https://github.com/gcarq/freqtrade/blob/develop/docs/sql_cheatsheet.md)
+    - [SQL cheatsheet](https://github.com/freqtrade/freqtrade/blob/develop/docs/sql_cheatsheet.md)

docs/installation.md

@@ -2,7 +2,7 @@
 
 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
 
@@ -16,7 +16,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 +34,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,12 +44,15 @@ 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`.
 
 ------
@@ -63,13 +67,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 +93,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 +118,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 +126,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):
@@ -137,11 +139,11 @@ There is known issue in OSX Docker versions after 17.09.1, whereby /etc/localtim
 ```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
+
+More information on this docker issue and work-around can be read [here](https://github.com/docker/for-mac/issues/2396)
 
 In this example, the database will be created inside the docker instance and will be lost when you will refresh your image.
 
-
 ### 5. Run a restartable docker image
 
 To run a restartable instance in the background (feel free to place your configuration and database files wherever it feels comfortable on your filesystem).
@@ -162,10 +164,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
 
@@ -190,13 +193,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
@@ -237,13 +240,7 @@ sudo apt-get install mongodb-org
 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
@@ -251,6 +248,7 @@ git checkout develop
 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
 ```
@@ -261,7 +259,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
@@ -287,7 +284,7 @@ export PATH=<path_freqtrade>/env/mongodb/bin:$PATH
 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:
@@ -296,7 +293,6 @@ Optionally checkout the develop branch:
 git checkout develop
 ```
 
-
 ### Setup Config and virtual env
 
 #### 1. Initialize the configuration
@@ -306,8 +302,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)
 
@@ -331,27 +326,41 @@ python3.6 ./freqtrade/main.py -c config.json
 
 ## Windows
 
-We recommend that Windows users use [Docker](#docker) as this will work
+We recommend that Windows users use [Docker](#docker) as this will work much easier and smoother (also more secure).
-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 freqtrade\main.py
->python 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

@@ -48,6 +48,12 @@ To plot trades stored in a database use `--db-url` argument:
 python scripts/plot_dataframe.py --db-url 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
 
 The profit plotter show a picture with three plots:

docs/sql_cheatsheet.md

@@ -85,7 +85,7 @@ INSERT INTO trades (exchange, pair, is_open, fee_open, fee_close, open_rate, sta
 
 ## 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/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

freqtrade/__init__.py

@@ -12,7 +12,8 @@ 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.
     """
 
 

freqtrade/analyze.py

@@ -62,6 +62,7 @@ class Analyze(object):
             'close': 'last',
             'volume': 'max',
         })
+        frame.drop(frame.tail(1).index, inplace=True)     # eliminate partial candle
         return frame
 
     def populate_indicators(self, dataframe: DataFrame) -> DataFrame:

freqtrade/arguments.py

@@ -2,16 +2,28 @@
 This module contains the argument manager class
 """
 
+import os
 import argparse
 import logging
-import os
 import re
 import arrow
-from typing import List, Tuple, Optional
+from typing import List, Optional, NamedTuple
 
 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
@@ -60,7 +72,7 @@ class Arguments(object):
         self.parser.add_argument(
             '--version',
             action='version',
-            version='%(prog)s {}'.format(__version__),
+            version=f'%(prog)s {__version__}'
         )
         self.parser.add_argument(
             '-c', '--config',
@@ -72,9 +84,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',
         )
@@ -95,8 +107,8 @@ class Arguments(object):
         )
         self.parser.add_argument(
             '--dynamic-whitelist',
-            help='dynamically generate and update whitelist \
+            help='dynamically generate and update whitelist'
-                                  based on 24h BaseVolume (Default 20 currencies)',  # noqa
+                 ' based on 24h BaseVolume (default: %(const)s)',
             dest='dynamic_whitelist',
             const=constants.DYNAMIC_WHITELIST,
             type=int,
@@ -104,11 +116,13 @@ class Arguments(object):
             nargs='?',
         )
         self.parser.add_argument(
-            '--dry-run-db',
+            '--db-url',
-            help='Force dry run to use a local DB "tradesv3.dry_run.sqlite" \
+            help='Override trades database URL, this is useful if dry_run is enabled'
-                                  instead of memory DB. Work only if dry_run is enabled.',
+                 ' or in custom deployments (default: %(default)s)',
-            action='store_true',
+            dest='db_url',
-            dest='dry_run_db',
+            default=constants.DEFAULT_DB_PROD_URL,
+            type=str,
+            metavar='PATH',
         )
 
     @staticmethod
@@ -124,8 +138,8 @@ class Arguments(object):
         )
         parser.add_argument(
             '-r', '--refresh-pairs-cached',
-            help='refresh the pairs files in tests/testdata with the latest data from the exchange. \
+            help='refresh the pairs files in tests/testdata with the latest data from the '
-                  Use it if you want to run your backtesting with up-to-date data.',
+                 'exchange. Use it if you want to run your backtesting with up-to-date data.',
             action='store_true',
             dest='refresh_pairs',
         )
@@ -141,15 +155,21 @@ class Arguments(object):
             '--export-filename',
             help='Save backtest results to this filename \
                   requires --export to be set as well\
-                  Example --export-filename=backtest_today.json\
+                  Example --export-filename=user_data/backtest_data/backtest_today.json\
-                  (default: %(default)s',
+                  (default: %(default)s)',
             type=str,
-            default='backtest-result.json',
+            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 (1m, 5m, 30m, 1h, 1d)',
@@ -221,15 +241,14 @@ class Arguments(object):
         self.hyperopt_options(hyperopt_cmd)
 
     @staticmethod
-    def parse_timerange(text: Optional[str]) -> Optional[Tuple[Tuple,
+    def parse_timerange(text: Optional[str]) -> TimeRange:
-                                                         Optional[int], Optional[int]]]:
         """
         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')),
@@ -245,8 +264,8 @@ class Arguments(object):
             if match:  # Regex has matched
                 rvals = match.groups()
                 index = 0
-                start: Optional[int] = None
+                start: int = 0
-                stop: Optional[int] = None
+                stop: int = 0
                 if stype[0]:
                     starts = rvals[index]
                     if stype[0] == 'date':
@@ -262,7 +281,7 @@ class Arguments(object):
                             else arrow.get(stops, 'YYYYMMDD').timestamp
                     else:
                         stop = int(stops)
-                return stype, start, stop
+                return TimeRange(stype[0], stype[1], start, stop)
         raise Exception('Incorrect syntax for timerange "%s"' % text)
 
     def scripts_options(self) -> None:
@@ -276,7 +295,6 @@ class Arguments(object):
             default=None
         )
 
-
         self.parser.add_argument(
             '--stop-loss',
             help='Renders stop/loss information in the main chart',
@@ -381,25 +399,42 @@ class Arguments(object):
             '--pairs-file',
             help='File containing a list of pairs to download',
             dest='pairs_file',
-            default=None
+            default=None,
+            metavar='PATH',
         )
 
         self.parser.add_argument(
             '--export',
             help='Export files to given dir',
             dest='export',
-            default=None)
+            default=None,
+            metavar='PATH',
+        )
 
         self.parser.add_argument(
             '--days',
             help='Download data for number of days',
             dest='days',
             type=int,
-            default=None)
+            metavar='INT',
+            default=None
+        )
 
         self.parser.add_argument(
             '--exchange',
-            help='Exchange name',
+            help='Exchange name (default: %(default)s)',
             dest='exchange',
             type=str,
-            default='bittrex')
+            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',
+        )

freqtrade/configuration.py

@@ -1,7 +1,7 @@
 """
 This module contains the configuration class
 """
-
+import os
 import json
 import logging
 from argparse import Namespace
@@ -61,11 +61,9 @@ class Configuration(object):
             with open(path) as file:
                 conf = json.load(file)
         except FileNotFoundError:
-            logger.critical(
+            raise OperationalException(
-                'Config file "%s" not found. Please create your config file',
+                'Config file "{}" not found!'
-                path
+                ' Please create a config file or check whether it exists.'.format(path))
-            )
-            exit(0)
 
         if 'internals' not in conf:
             conf['internals'] = {}
@@ -97,22 +95,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.db_url != constants.DEFAULT_DB_PROD_URL:
-        if self.args.dry_run_db and config.get('dry_run', False):
+            config.update({'db_url': self.args.db_url})
-            config.update({'dry_run_db': True})
+            logger.info('Parameter --db-url detected ...')
-            logger.info('Parameter --dry-run-db 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('Using DB: "{}"'.format(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
@@ -145,7 +156,9 @@ class Configuration(object):
         # If --datadir is used we add it to the configuration
         if 'datadir' in self.args and self.args.datadir:
             config.update({'datadir': self.args.datadir})
-            logger.info('Using data folder: %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:
@@ -223,9 +236,8 @@ class Configuration(object):
         exchange = config.get('exchange', {}).get('name').lower()
         if exchange not in ccxt.exchanges:
 
-            exception_msg = 'Exchange "{}" not supported.\n' \
+            exception_msg = f'Exchange "{exchange}" not supported.\n' \
-                            'The following exchanges are supported: {}'\
+                            f'The following exchanges are supported: {", ".join(ccxt.exchanges)}'
-                .format(exchange, ', '.join(ccxt.exchanges))
 
             logger.critical(exception_msg)
             raise OperationalException(

freqtrade/constants.py

@@ -9,9 +9,12 @@ 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://'
 
 TICKER_INTERVAL_MINUTES = {
     '1m': 1,
+    '3m': 3,
     '5m': 5,
     '15m': 15,
     '30m': 30,
@@ -19,8 +22,10 @@ TICKER_INTERVAL_MINUTES = {
     '2h': 120,
     '4h': 240,
     '6h': 360,
+    '8h': 480,
     '12h': 720,
     '1d': 1440,
+    '3d': 4320,
     '1w': 10080,
 }
 
@@ -28,7 +33,8 @@ 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"
+    "RUB", "SEK", "SGD", "THB", "TRY", "TWD", "ZAR", "USD",
+    "BTC", "ETH", "XRP", "LTC", "BCH", "USDT"
     ]
 
 # Required json-schema for user specified config
@@ -59,9 +65,19 @@ CONF_SCHEMA = {
                     'maximum': 1,
                     'exclusiveMaximum': False
                 },
+                'use_book_order': {'type': 'boolean'},
+                'book_order_top': {'type': 'number', 'maximum':20,'minimum':1}
             },
             'required': ['ask_last_balance']
         },
+        'ask_strategy': {
+            'type': 'object',
+            'properties': {
+                'use_book_order': {'type': 'boolean'},
+                'book_order_min': {'type': 'number', 'minimum':1},
+                'book_order_max': {'type': 'number', 'minimum':1}
+            },
+        },
         'exchange': {'$ref': '#/definitions/exchange'},
         'experimental': {
             'type': 'object',
@@ -79,6 +95,7 @@ CONF_SCHEMA = {
             },
             'required': ['enabled', 'token', 'chat_id']
         },
+        'db_url': {'type': 'string'},
         'initial_state': {'type': 'string', 'enum': ['running', 'stopped']},
         'internals': {
             'type': 'object',

freqtrade/exchange/__init__.py

@@ -18,6 +18,8 @@ _API: ccxt.Exchange = None
 _CONF: Dict = {}
 API_RETRY_COUNT = 4
 
+_CACHED_TICKER: Dict[str, Any] = {}
+
 # Holds all open sell orders for dry_run
 _DRY_RUN_OPEN_ORDERS: Dict[str, Any] = {}
 
@@ -57,7 +59,7 @@ def init_ccxt(exchange_config: dict) -> ccxt.Exchange:
     name = exchange_config['name']
 
     if name not in ccxt.exchanges:
-        raise OperationalException('Exchange {} is not supported'.format(name))
+        raise OperationalException(f'Exchange {name} is not supported')
     try:
         api = getattr(ccxt, name.lower())({
             'apiKey': exchange_config.get('key'),
@@ -67,7 +69,7 @@ def init_ccxt(exchange_config: dict) -> ccxt.Exchange:
             'enableRateLimit': True,
         })
     except (KeyError, AttributeError):
-        raise OperationalException('Exchange {} is not supported'.format(name))
+        raise OperationalException(f'Exchange {name} is not supported')
 
     return api
 
@@ -116,11 +118,10 @@ def validate_pairs(pairs: List[str]) -> None:
         # 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, get_name()))
+                f'Pair {pair} is not available at {get_name()}')
 
 
 def exchange_has(endpoint: str) -> bool:
@@ -136,7 +137,7 @@ def exchange_has(endpoint: str) -> bool:
 def buy(pair: str, rate: float, amount: float) -> Dict:
     if _CONF['dry_run']:
         global _DRY_RUN_OPEN_ORDERS
-        order_id = 'dry_run_buy_{}'.format(randint(0, 10**6))
+        order_id = f'dry_run_buy_{randint(0, 10**6)}'
         _DRY_RUN_OPEN_ORDERS[order_id] = {
             'pair': pair,
             'price': rate,
@@ -154,20 +155,17 @@ def buy(pair: str, rate: float, amount: float) -> Dict:
         return _API.create_limit_buy_order(pair, amount, rate)
     except ccxt.InsufficientFunds as e:
         raise DependencyException(
-            'Insufficient funds to create limit buy order on market {}.'
+            f'Insufficient funds to create limit buy order on market {pair}.'
-            'Tried to buy amount {} at rate {} (total {}).'
+            f'Tried to buy amount {amount} at rate {rate} (total {rate*amount}).'
-            'Message: {}'.format(pair, amount, rate, rate*amount, e)
+            f'Message: {e}')
-        )
     except ccxt.InvalidOrder as e:
         raise DependencyException(
-            'Could not create limit buy order on market {}.'
+            f'Could not create limit buy order on market {pair}.'
-            'Tried to buy amount {} at rate {} (total {}).'
+            f'Tried to buy amount {amount} at rate {rate} (total {rate*amount}).'
-            'Message: {}'.format(pair, amount, rate, rate*amount, e)
+            f'Message: {e}')
-        )
     except (ccxt.NetworkError, ccxt.ExchangeError) as e:
         raise TemporaryError(
-            'Could not place buy order due to {}. Message: {}'.format(
+            f'Could not place buy order due to {e.__class__.__name__}. Message: {e}')
-                e.__class__.__name__, e))
     except ccxt.BaseError as e:
         raise OperationalException(e)
 
@@ -175,7 +173,7 @@ def buy(pair: str, rate: float, amount: float) -> Dict:
 def sell(pair: str, rate: float, amount: float) -> Dict:
     if _CONF['dry_run']:
         global _DRY_RUN_OPEN_ORDERS
-        order_id = 'dry_run_sell_{}'.format(randint(0, 10**6))
+        order_id = f'dry_run_sell_{randint(0, 10**6)}'
         _DRY_RUN_OPEN_ORDERS[order_id] = {
             'pair': pair,
             'price': rate,
@@ -192,20 +190,17 @@ def sell(pair: str, rate: float, amount: float) -> Dict:
         return _API.create_limit_sell_order(pair, amount, rate)
     except ccxt.InsufficientFunds as e:
         raise DependencyException(
-            'Insufficient funds to create limit sell order on market {}.'
+            f'Insufficient funds to create limit sell order on market {pair}.'
-            'Tried to sell amount {} at rate {} (total {}).'
+            f'Tried to sell amount {amount} at rate {rate} (total {rate*amount}).'
-            'Message: {}'.format(pair, amount, rate, rate*amount, e)
+            f'Message: {e}')
-        )
     except ccxt.InvalidOrder as e:
         raise DependencyException(
-            'Could not create limit sell order on market {}.'
+            f'Could not create limit sell order on market {pair}.'
-            'Tried to sell amount {} at rate {} (total {}).'
+            f'Tried to sell amount {amount} at rate {rate} (total {rate*amount}).'
-            'Message: {}'.format(pair, amount, rate, rate*amount, e)
+            f'Message: {e}')
-        )
     except (ccxt.NetworkError, ccxt.ExchangeError) as e:
         raise TemporaryError(
-            'Could not place sell order due to {}. Message: {}'.format(
+            f'Could not place sell order due to {e.__class__.__name__}. Message: {e}')
-                e.__class__.__name__, e))
     except ccxt.BaseError as e:
         raise OperationalException(e)
 
@@ -220,8 +215,7 @@ def get_balance(currency: str) -> float:
     balance = balances.get(currency)
     if balance is None:
         raise TemporaryError(
-            'Could not get {} balance due to malformed exchange response: {}'.format(
+            f'Could not get {currency} balance due to malformed exchange response: {balances}')
-                currency, balances))
     return balance['free']
 
 
@@ -241,11 +235,23 @@ def get_balances() -> dict:
         return balances
     except (ccxt.NetworkError, ccxt.ExchangeError) as e:
         raise TemporaryError(
-            'Could not get balance due to {}. Message: {}'.format(
+            f'Could not get balance due to {e.__class__.__name__}. Message: {e}')
-                e.__class__.__name__, e))
     except ccxt.BaseError as e:
         raise OperationalException(e)
 
+@retrier
+def get_order_book(pair: str, refresh: Optional[bool] = True) -> dict:
+    try:
+        return _API.fetch_order_book(pair)
+    except ccxt.NotSupported as e:
+        raise OperationalException(
+            f'Exchange {_API.name} does not support fetching order book.'
+            f'Message: {e}')
+    except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+        raise TemporaryError(
+            f'Could not load order book due to {e.__class__.__name__}. Message: {e}')
+    except ccxt.BaseError as e:
+        raise OperationalException(e)
 
 @retrier
 def get_tickers() -> Dict:
@@ -253,28 +259,37 @@ def get_tickers() -> Dict:
         return _API.fetch_tickers()
     except ccxt.NotSupported as e:
         raise OperationalException(
-            'Exchange {} does not support fetching tickers in batch.'
+            f'Exchange {_API.name} does not support fetching tickers in batch.'
-            'Message: {}'.format(_API.name, e)
+            f'Message: {e}')
-        )
     except (ccxt.NetworkError, ccxt.ExchangeError) as e:
         raise TemporaryError(
-            'Could not load tickers due to {}. Message: {}'.format(
+            f'Could not load tickers due to {e.__class__.__name__}. Message: {e}')
-                e.__class__.__name__, e))
     except ccxt.BaseError as e:
         raise OperationalException(e)
 
 
-# TODO: remove refresh argument, keeping it to keep track of where it was intended to be used
 @retrier
 def get_ticker(pair: str, refresh: Optional[bool] = True) -> dict:
+    global _CACHED_TICKER
+    if refresh or pair not in _CACHED_TICKER.keys():
         try:
-        return _API.fetch_ticker(pair)
+            data = _API.fetch_ticker(pair)
+            try:
+                _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(
-            'Could not load ticker history due to {}. Message: {}'.format(
+                f'Could not load ticker history due to {e.__class__.__name__}. Message: {e}')
-                e.__class__.__name__, e))
         except ccxt.BaseError as e:
             raise OperationalException(e)
+    else:
+        logger.info("returning cached ticker-data for %s", pair)
+        return _CACHED_TICKER[pair]
 
 
 @retrier
@@ -313,15 +328,13 @@ def get_ticker_history(pair: str, tick_interval: str, since_ms: Optional[int] =
         return data
     except ccxt.NotSupported as e:
         raise OperationalException(
-            'Exchange {} does not support fetching historical candlestick data.'
+            f'Exchange {_API.name} does not support fetching historical candlestick data.'
-            'Message: {}'.format(_API.name, e)
+            f'Message: {e}')
-        )
     except (ccxt.NetworkError, ccxt.ExchangeError) as e:
         raise TemporaryError(
-            'Could not load ticker history due to {}. Message: {}'.format(
+            f'Could not load ticker history due to {e.__class__.__name__}. Message: {e}')
-                e.__class__.__name__, e))
     except ccxt.BaseError as e:
-        raise OperationalException('Could not fetch ticker data. Msg: {}'.format(e))
+        raise OperationalException(f'Could not fetch ticker data. Msg: {e}')
 
 
 @retrier
@@ -333,12 +346,10 @@ def cancel_order(order_id: str, pair: str) -> None:
         return _API.cancel_order(order_id, pair)
     except ccxt.InvalidOrder as e:
         raise DependencyException(
-            'Could not cancel order. Message: {}'.format(e)
+            f'Could not cancel order. Message: {e}')
-        )
     except (ccxt.NetworkError, ccxt.ExchangeError) as e:
         raise TemporaryError(
-            'Could not cancel order due to {}. Message: {}'.format(
+            f'Could not cancel order due to {e.__class__.__name__}. Message: {e}')
-                e.__class__.__name__, e))
     except ccxt.BaseError as e:
         raise OperationalException(e)
 
@@ -355,12 +366,10 @@ def get_order(order_id: str, pair: str) -> Dict:
         return _API.fetch_order(order_id, pair)
     except ccxt.InvalidOrder as e:
         raise DependencyException(
-            'Could not get order. Message: {}'.format(e)
+            f'Could not get order. Message: {e}')
-        )
     except (ccxt.NetworkError, ccxt.ExchangeError) as e:
         raise TemporaryError(
-            'Could not get order due to {}. Message: {}'.format(
+            f'Could not get order due to {e.__class__.__name__}. Message: {e}')
-                e.__class__.__name__, e))
     except ccxt.BaseError as e:
         raise OperationalException(e)
 
@@ -379,8 +388,7 @@ def get_trades_for_order(order_id: str, pair: str, since: datetime) -> List:
 
     except ccxt.NetworkError as e:
         raise TemporaryError(
-            'Could not get trades due to networking error. Message: {}'.format(e)
+            f'Could not get trades due to networking error. Message: {e}')
-        )
     except ccxt.BaseError as e:
         raise OperationalException(e)
 
@@ -402,8 +410,7 @@ def get_markets() -> List[dict]:
         return _API.fetch_markets()
     except (ccxt.NetworkError, ccxt.ExchangeError) as e:
         raise TemporaryError(
-            'Could not load markets due to {}. Message: {}'.format(
+            f'Could not load markets due to {e.__class__.__name__}. Message: {e}')
-                e.__class__.__name__, e))
     except ccxt.BaseError as e:
         raise OperationalException(e)
 
@@ -428,8 +435,7 @@ def get_fee(symbol='ETH/BTC', type='', side='', amount=1,
                                   price=price, takerOrMaker=taker_or_maker)['rate']
     except (ccxt.NetworkError, ccxt.ExchangeError) as e:
         raise TemporaryError(
-            'Could not get fee info due to {}. Message: {}'.format(
+            f'Could not get fee info due to {e.__class__.__name__}. Message: {e}')
-                e.__class__.__name__, e))
     except ccxt.BaseError as e:
         raise OperationalException(e)
 

freqtrade/fiat_convert.py

@@ -119,7 +119,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:
@@ -182,7 +182,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.')
 
         # No need to convert if both crypto and fiat are the same
         if crypto_symbol == fiat_symbol:
@@ -192,6 +192,7 @@ class CryptoToFiatConverter(object):
             # 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
+
         try:
             return float(
                 self._coinmarketcap.ticker(

freqtrade/freqtradebot.py

@@ -33,12 +33,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)-> 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(
@@ -57,17 +56,16 @@ class FreqtradeBot(object):
         self.persistence = None
         self.exchange = None
 
-        self._init_modules(db_url=db_url)
+        self._init_modules()
 
-    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
 
-        persistence.init(self.config, db_url)
+        persistence.init(self.config)
         exchange.init(self.config)
 
         # Set initial application state
@@ -78,17 +76,14 @@ 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('Cleaning up modules ...')
-        logger.info('Stopping trader and cleaning up modules...')
-        self.state = State.STOPPED
         self.rpc.cleanup()
         persistence.cleanup()
-        return True
 
     def worker(self, old_state: State = None) -> State:
         """
@@ -99,7 +94,7 @@ 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(f'*Status:* `{state.name.lower()}`')
             logger.info('Changing state to: %s', state.name)
 
         if state == State.STOPPED:
@@ -173,12 +168,10 @@ class FreqtradeBot(object):
             logger.warning('%s, retrying in 30 seconds...', error)
             time.sleep(constants.RETRY_TIMEOUT)
         except OperationalException:
-            self.rpc.send_msg(
+            tb = traceback.format_exc()
-                '*Status:* OperationalException:\n```\n{traceback}```{hint}'
-                .format(
-                    traceback=traceback.format_exc(),
             hint = 'Issue `/start` if you think it is safe to restart.'
-                )
+            self.rpc.send_msg(
+                f'*Status:* OperationalException:\n```\n{tb}```{hint}'
             )
             logger.exception('OperationalException. Stopping trader ...')
             self.state = State.STOPPED
@@ -241,27 +234,37 @@ class FreqtradeBot(object):
 
         return final_list
 
-    def get_target_bid(self, ticker: Dict[str, float]) -> float:
+    def get_target_bid(self, pair: str) -> float:
         """
         Calculates bid target between current ask price and last price
         :param ticker: Ticker to use for getting Ask and Last Price
         :return: float: Price
         """
+
+        if self.config['bid_strategy']['use_book_order']:
+            logger.info('Getting price from Order Book')
+            orderBook = exchange.get_order_book(pair)
+            return orderBook['bids'][self.config['bid_strategy']['book_order_top']][0]
+        else:
+            logger.info('Using Ask / Last Price')
+            ticker = exchange.get_ticker(pair);
             if ticker['ask'] < ticker['last']:
                 return ticker['ask']
             balance = self.config['bid_strategy']['ask_last_balance']
             return ticker['ask'] + balance * (ticker['last'] - ticker['ask'])
 
+
     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()
+        stake_currency = self.config['stake_currency']
+        fiat_currency = self.config['fiat_display_currency']
+        exc_name = exchange.get_name()
 
         logger.info(
             'Checking buy signals to create a new trade with stake_amount: %f ...',
@@ -269,10 +272,9 @@ class FreqtradeBot(object):
         )
         whitelist = copy.deepcopy(self.config['exchange']['pair_whitelist'])
         # Check if stake_amount is fulfilled
-        if exchange.get_balance(self.config['stake_currency']) < stake_amount:
+        if exchange.get_balance(stake_currency) < stake_amount:
             raise DependencyException(
-                'stake amount is not fulfilled (currency={})'.format(self.config['stake_currency'])
+                f'stake amount is not fulfilled (currency={stake_currency})')
-            )
 
         # Remove currently opened and latest pairs from whitelist
         for trade in Trade.query.filter(Trade.is_open.is_(True)).all():
@@ -291,32 +293,25 @@ class FreqtradeBot(object):
                 break
         else:
             return False
-
+        pair_s = pair.replace('_', '/')
+        pair_url = exchange.get_pair_detail_url(pair)
         # Calculate amount
-        buy_limit = self.get_target_bid(exchange.get_ticker(pair))
+        buy_limit = self.get_target_bid(pair)
         amount = stake_amount / buy_limit
 
         order_id = exchange.buy(pair, buy_limit, amount)['id']
 
         stake_amount_fiat = self.fiat_converter.convert_amount(
             stake_amount,
-            self.config['stake_currency'],
+            stake_currency,
-            self.config['fiat_display_currency']
+            fiat_currency
         )
 
         # Create trade entity and return
         self.rpc.send_msg(
-            '*{}:* Buying [{}]({}) with limit `{:.8f} ({:.6f} {}, {:.3f} {})` '
+            f"""*{exc_name}:* Buying [{pair_s}]({pair_url}) \
-            .format(
+with limit `{buy_limit:.8f} ({stake_amount:.6f} \
-                exchange.get_name(),
+{stake_currency}, {stake_amount_fiat:.3f} {fiat_currency})`"""
-                pair.replace('_', '/'),
-                exchange.get_pair_detail_url(pair),
-                buy_limit,
-                stake_amount,
-                self.config['stake_currency'],
-                stake_amount_fiat,
-                self.config['fiat_display_currency']
-            )
         )
         # Fee is applied twice because we make a LIMIT_BUY and LIMIT_SELL
         fee = exchange.get_fee(symbol=pair, taker_or_maker='maker')
@@ -417,12 +412,12 @@ class FreqtradeBot(object):
                     fee_abs += exectrade['fee']['cost']
 
         if amount != order_amount:
-            logger.warning("amount {} does not match amount {}".format(amount, trade.amount))
+            logger.warning(f"amount {amount} does not match amount {trade.amount}")
             raise OperationalException("Half bought? Amounts don't match")
         real_amount = amount - fee_abs
         if fee_abs != 0:
-            logger.info("Applying fee on amount for {} (from {} to {}) from Trades".format(
+            logger.info(f"""Applying fee on amount for {trade} \
-                        trade, order['amount'], real_amount))
+(from {order_amount} to {real_amount}) from Trades""")
         return real_amount
 
     def handle_trade(self, trade: Trade) -> bool:
@@ -431,22 +426,39 @@ class FreqtradeBot(object):
         :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']
+        sell_rate = exchange.get_ticker(trade.pair)['bid']
 
         (buy, sell) = (False, False)
 
         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):
+        if self.config['ask_strategy']['use_book_order']:
-            self.execute_sell(trade, current_rate)
+            logger.info('Using order book for selling...')
+            orderBook = exchange.get_order_book(trade.pair)
+            # logger.debug('Order book %s',orderBook)
+            for i in range(self.config['ask_strategy']['book_order_min'],self.config['ask_strategy']['book_order_max']):
+                sell_rate = orderBook['asks'][i-1][0]
+                logger.debug('checking sell rate %s) %.8f > %.8f (%f %%)',i,trade.open_rate,sell_rate,((sell_rate/trade.open_rate)*100)-100)
+                if self.check_sell(trade, sell_rate, buy, sell):
                     return True
+                    break
+        else:
+            if self.check_sell(trade, sell_rate, buy, sell):
+                return True
+            
         logger.info('Found no sell signals for whitelisted currencies. Trying again..')
         return False
 
+    def check_sell(self, trade: Trade, sell_rate: float, buy: bool, sell: bool ) -> bool:
+        if self.analyze.should_sell(trade, sell_rate, datetime.utcnow(), buy, sell):
+            self.execute_sell(trade, sell_rate)
+            return True
+        return False
+
     def check_handle_timedout(self, timeoutvalue: int) -> None:
         """
         Check if any orders are timed out and cancel if neccessary
@@ -457,6 +469,12 @@ class FreqtradeBot(object):
 
         for trade in Trade.query.filter(Trade.open_order_id.isnot(None)).all():
             try:
+                # 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 = exchange.get_order(trade.open_order_id, trade.pair)
             except requests.exceptions.RequestException:
                 logger.info(
@@ -482,16 +500,14 @@ class FreqtradeBot(object):
         """Buy timeout - cancel order
         :return: True if order was fully cancelled
         """
+        pair_s = trade.pair.replace('_', '/')
         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(
+            self.rpc.send_msg(f'*Timeout:* Unfilled buy order for {pair_s} cancelled')
-                trade.pair.replace('_', '/')))
             return True
 
         # if trade is partially complete, edit the stake details for the trade
@@ -500,8 +516,7 @@ 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(
+        self.rpc.send_msg(f'*Timeout:* Remaining buy order for {pair_s} cancelled')
-            trade.pair.replace('_', '/')))
         return False
 
     # FIX: 20180110, should cancel_order() be cond. or unconditionally called?
@@ -510,6 +525,7 @@ 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, trade.pair)
@@ -518,8 +534,7 @@ class FreqtradeBot(object):
             trade.close_date = None
             trade.is_open = True
             trade.open_order_id = None
-            self.rpc.send_msg('*Timeout:* Unfilled sell order for {} cancelled'.format(
+            self.rpc.send_msg(f'*Timeout:* Unfilled sell order for {pair_s} cancelled')
-                trade.pair.replace('_', '/')))
             logger.info('Sell order timeout for %s.', trade)
             return True
 
@@ -533,6 +548,8 @@ class FreqtradeBot(object):
         :param limit: limit rate for the sell order
         :return: None
         """
+        exc = trade.exchange
+        pair = trade.pair
         # Execute sell and update trade record
         order_id = exchange.sell(str(trade.pair), limit, trade.amount)['id']
         trade.open_order_id = order_id
@@ -542,43 +559,31 @@ class FreqtradeBot(object):
         profit_trade = trade.calc_profit(rate=limit)
         current_rate = exchange.get_ticker(trade.pair)['bid']
         profit = trade.calc_profit_percent(limit)
+        pair_url = exchange.get_pair_detail_url(trade.pair)
+        gain = "profit" if fmt_exp_profit > 0 else "loss"
 
-        message = "*{exchange}:* Selling\n" \
+        message = f"*{exc}:* Selling\n" \
-                  "*Current Pair:* [{pair}]({pair_url})\n" \
+                  f"*Current Pair:* [{pair}]({pair_url})\n" \
-                  "*Limit:* `{limit}`\n" \
+                  f"*Limit:* `{limit}`\n" \
-                  "*Amount:* `{amount}`\n" \
+                  f"*Amount:* `{round(trade.amount, 8)}`\n" \
-                  "*Open Rate:* `{open_rate:.8f}`\n" \
+                  f"*Open Rate:* `{trade.open_rate:.8f}`\n" \
-                  "*Current Rate:* `{current_rate:.8f}`\n" \
+                  f"*Current Rate:* `{current_rate:.8f}`\n" \
-                  "*Profit:* `{profit:.2f}%`" \
+                  f"*Profit:* `{round(profit * 100, 2):.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),
-                  )
 
         # For regular case, when the configuration exists
         if 'stake_currency' in self.config and 'fiat_display_currency' in self.config:
+            stake = self.config['stake_currency']
+            fiat = self.config['fiat_display_currency']
             fiat_converter = CryptoToFiatConverter()
             profit_fiat = fiat_converter.convert_amount(
                 profit_trade,
-                self.config['stake_currency'],
+                stake,
-                self.config['fiat_display_currency']
+                fiat
-            )
-            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'],
             )
+            message += f'` ({gain}: {fmt_exp_profit:.2f}%, {profit_trade:.8f} {stake}`' \
+                       f'` / {profit_fiat:.3f} {fiat})`'\
+                       ''
         # Because telegram._forcesell does not have the configuration
         # Ignore the FIAT value and does not show the stake_currency as well
         else:

freqtrade/main.py

@@ -5,11 +5,14 @@ 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.freqtradebot import FreqtradeBot
+from freqtrade.state import State
 
 logger = logging.getLogger('freqtrade')
 
@@ -43,18 +46,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('*Status:* `Process died ...`')
+            freqtrade.cleanup()
         sys.exit(return_code)
 
 
+def reconfigure(freqtrade: FreqtradeBot, args: Namespace) -> FreqtradeBot:
+    """
+    Cleans up current instance, reloads the configuration and returns the new instance
+    """
+    # Clean up current modules
+    freqtrade.cleanup()
+
+    # Create new instance
+    freqtrade = FreqtradeBot(Configuration(args).get_config())
+    freqtrade.rpc.send_msg(
+        '*Status:* `Config reloaded ...`'.format(
+            freqtrade.state.name.lower()
+        )
+    )
+    return freqtrade
+
+
 def set_loggers() -> None:
     """
     Set the logger level for Third party libs

freqtrade/optimize/__init__.py

@@ -9,39 +9,40 @@ import arrow
 
 from freqtrade import misc, constants
 from freqtrade.exchange import get_ticker_history
+from freqtrade.arguments import TimeRange
 
 from user_data.hyperopt_conf import hyperopt_optimize_conf
 
 logger = logging.getLogger(__name__)
 
 
-def trim_tickerlist(tickerlist: List[Dict], timerange: Tuple[Tuple, int, int]) -> List[Dict]:
+def trim_tickerlist(tickerlist: List[Dict], timerange: TimeRange) -> List[Dict]:
     if not tickerlist:
         return tickerlist
 
-    stype, start, stop = timerange
-
     start_index = 0
     stop_index = len(tickerlist)
 
-    if stype[0] == 'line':
+    if timerange.starttype == 'line':
-        stop_index = start
+        stop_index = timerange.startts
-    if stype[0] == 'index':
+    if timerange.starttype == 'index':
-        start_index = start
+        start_index = timerange.startts
-    elif stype[0] == 'date':
+    elif timerange.starttype == 'date':
-        while start_index < len(tickerlist) and tickerlist[start_index][0] < start * 1000:
+        while (start_index < len(tickerlist) and
+               tickerlist[start_index][0] < timerange.startts * 1000):
             start_index += 1
 
-    if stype[1] == 'line':
+    if timerange.stoptype == 'line':
-        start_index = len(tickerlist) + stop
+        start_index = len(tickerlist) + timerange.stopts
-    if stype[1] == 'index':
+    if timerange.stoptype == 'index':
-        stop_index = stop
+        stop_index = timerange.stopts
-    elif stype[1] == 'date':
+    elif timerange.stoptype == 'date':
-        while stop_index > 0 and tickerlist[stop_index-1][0] > stop * 1000:
+        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 [{start},{stop}] is incorrect')
+        raise ValueError(f'The timerange [{timerange.startts},{timerange.stopts}] is incorrect')
 
     return tickerlist[start_index:stop_index]
 
@@ -49,7 +50,7 @@ def trim_tickerlist(tickerlist: List[Dict], timerange: Tuple[Tuple, int, int]) -
 def load_tickerdata_file(
         datadir: str, pair: str,
         ticker_interval: str,
-        timerange: Optional[Tuple[Tuple, int, int]] = None) -> Optional[List[Dict]]:
+        timerange: Optional[TimeRange] = None) -> Optional[List[Dict]]:
     """
     Load a pair from file,
     :return dict OR empty if unsuccesful
@@ -84,7 +85,7 @@ def load_data(datadir: str,
               ticker_interval: str,
               pairs: Optional[List[str]] = None,
               refresh_pairs: Optional[bool] = False,
-              timerange: Optional[Tuple[Tuple, int, int]] = None) -> Dict[str, List]:
+              timerange: TimeRange = TimeRange(None, None, 0, 0)) -> Dict[str, List]:
     """
     Loads ticker history data for the given parameters
     :return: dict
@@ -124,7 +125,7 @@ def make_testdata_path(datadir: str) -> str:
 
 def download_pairs(datadir, pairs: List[str],
                    ticker_interval: str,
-                   timerange: Optional[Tuple[Tuple, int, int]] = None) -> bool:
+                   timerange: TimeRange = TimeRange(None, None, 0, 0)) -> bool:
     """For each pairs passed in parameters, download the ticker intervals"""
     for pair in pairs:
         try:
@@ -144,7 +145,7 @@ def download_pairs(datadir, pairs: List[str],
 
 def load_cached_data_for_updating(filename: str,
                                   tick_interval: str,
-                                  timerange: Optional[Tuple[Tuple, int, int]]) -> Tuple[
+                                  timerange: Optional[TimeRange]) -> Tuple[
                                                                                   List[Any],
                                                                                   Optional[int]]:
     """
@@ -155,10 +156,10 @@ def load_cached_data_for_updating(filename: str,
 
     # user sets timerange, so find the start time
     if timerange:
-        if timerange[0][0] == 'date':
+        if timerange.starttype == 'date':
-            since_ms = timerange[1] * 1000
+            since_ms = timerange.startts * 1000
-        elif timerange[0][1] == 'line':
+        elif timerange.stoptype == 'line':
-            num_minutes = timerange[2] * constants.TICKER_INTERVAL_MINUTES[tick_interval]
+            num_minutes = timerange.stopts * constants.TICKER_INTERVAL_MINUTES[tick_interval]
             since_ms = arrow.utcnow().shift(minutes=num_minutes).timestamp * 1000
 
     # read the cached file
@@ -188,7 +189,7 @@ def load_cached_data_for_updating(filename: str,
 def download_backtesting_testdata(datadir: str,
                                   pair: str,
                                   tick_interval: str = '5m',
-                                  timerange: Optional[Tuple[Tuple, int, int]] = None) -> None:
+                                  timerange: Optional[TimeRange] = None) -> None:
 
     """
     Download the latest ticker intervals from the exchange for the pairs passed in parameters

freqtrade/optimize/backtesting.py

@@ -161,7 +161,15 @@ class Backtesting(object):
         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.populate_sell_trend(
+                self.populate_buy_trend(pair_data))[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)
+
             ticker = [x for x in ticker_data.itertuples()]
 
             lock_pair_until = None
@@ -221,7 +229,7 @@ class Backtesting(object):
 
             timerange = Arguments.parse_timerange(None if self.config.get(
                 'timerange') is None else str(self.config.get('timerange')))
-            data = optimize.load_data(  # type: ignore # timerange will be refactored
+            data = optimize.load_data(
                 self.config['datadir'],
                 pairs=pairs,
                 ticker_interval=self.ticker_interval,
@@ -229,6 +237,9 @@ class Backtesting(object):
                 timerange=timerange
             )
 
+        if not data:
+            logger.critical("No data found. Terminating.")
+            return
         # Ignore max_open_trades in backtesting, except realistic flag was passed
         if self.config.get('realistic_simulation', False):
             max_open_trades = self.config['max_open_trades']

freqtrade/optimize/hyperopt.py

@@ -497,7 +497,7 @@ class Hyperopt(Backtesting):
     def start(self) -> None:
         timerange = Arguments.parse_timerange(None if self.config.get(
             'timerange') is None else str(self.config.get('timerange')))
-        data = load_data(  # type: ignore # timerange will be refactored
+        data = load_data(
             datadir=str(self.config.get('datadir')),
             pairs=self.config['exchange']['pair_whitelist'],
             ticker_interval=self.ticker_interval,

freqtrade/persistence.py

@@ -10,13 +10,14 @@ from typing import Dict, Optional, Any
 import arrow
 from sqlalchemy import (Boolean, Column, DateTime, Float, Integer, String,
                         create_engine)
-from sqlalchemy.engine import Engine
+from sqlalchemy import 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 sqlalchemy import inspect
 
+from freqtrade import OperationalException
 
 logger = logging.getLogger(__name__)
 
@@ -24,29 +25,34 @@ _CONF = {}
 _DECL_BASE: Any = declarative_base()
 
 
-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):
+    db_url = _CONF.get('db_url', None)
-            # the user wants dry run to use a DB
+    kwargs = {}
-            if _CONF.get('dry_run_db', False):
+
-                engine = create_engine('sqlite:///tradesv3.dry_run.sqlite')
+    # Take care of thread ownership if in-memory db
-            # Otherwise dry run will store in memory
+    if db_url == 'sqlite://':
-            else:
+        kwargs.update({
-                engine = create_engine('sqlite://',
+            'connect_args': {'check_same_thread': False},
-                                       connect_args={'check_same_thread': False},
+            'poolclass': StaticPool,
-                                       poolclass=StaticPool,
+            'echo': False,
-                                       echo=False)
+        })
-        else:
+
-            engine = create_engine('sqlite:///tradesv3.sqlite')
+    try:
+        engine = create_engine(db_url, **kwargs)
+    except NoSuchModuleError:
+        error = 'Given value for db_url: \'{}\' is no valid database URL! (See {}).'.format(
+            db_url, 'http://docs.sqlalchemy.org/en/latest/core/engines.html#database-urls'
+        )
+        raise OperationalException(error)
 
     session = scoped_session(sessionmaker(bind=engine, autoflush=True, autocommit=True))
     Trade.session = session()
@@ -54,8 +60,8 @@ def init(config: dict, engine: Optional[Engine] = None) -> None:
     _DECL_BASE.metadata.create_all(engine)
     check_migrate(engine)
 
-    # Clean dry_run DB
+    # Clean dry_run DB if the db is not in-memory
-    if _CONF.get('dry_run', False) and _CONF.get('dry_run_db', False):
+    if _CONF.get('dry_run', False) and db_url != 'sqlite://':
         clean_dry_run_db()
 
 

freqtrade/rpc/rpc.py

@@ -9,6 +9,7 @@ from typing import Dict, Tuple, Any
 import arrow
 import sqlalchemy as sql
 from pandas import DataFrame
+from numpy import mean, nan_to_num
 
 from freqtrade import exchange
 from freqtrade.misc import shorten_date
@@ -212,14 +213,14 @@ class RPC(object):
         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_percent = round(nan_to_num(mean(profit_closed_percent)) * 100, 2)
         profit_closed_fiat = fiat.convert_amount(
             profit_closed_coin,
             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_percent = round(nan_to_num(mean(profit_all_percent)) * 100, 2)
         profit_all_fiat = fiat.convert_amount(
             profit_all_coin,
             stake_currency,
@@ -301,6 +302,11 @@ class RPC(object):
 
         return True, '*Status:* `already stopped`'
 
+    def rpc_reload_conf(self) -> str:
+        """ Handler for reload_conf. """
+        self.freqtrade.state = State.RELOAD_CONF
+        return '*Status:* `Reloading config ...`'
+
     # FIX: no test for this!!!!
     def rpc_forcesell(self, trade_id) -> Tuple[bool, Any]:
         """
@@ -356,6 +362,7 @@ class RPC(object):
             return True, 'Invalid argument.'
 
         _exec_forcesell(trade)
+        Trade.session.flush()
         return False, ''
 
     def rpc_performance(self) -> Tuple[bool, Any]:

freqtrade/rpc/telegram.py

@@ -93,6 +93,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),
         ]
@@ -300,6 +301,18 @@ class Telegram(RPC):
         (error, msg) = self.rpc_stop()
         self.send_msg(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(msg, bot=bot)
+
     @authorized_only
     def _forcesell(self, bot: Bot, update: Update) -> None:
         """

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/tests/conftest.py

@@ -9,7 +9,6 @@ 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
@@ -45,7 +44,7 @@ def get_patched_freqtradebot(mocker, config) -> FreqtradeBot:
     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:
@@ -88,7 +87,14 @@ def default_conf():
         "stoploss": -0.10,
         "unfilledtimeout": 600,
         "bid_strategy": {
-            "ask_last_balance": 0.0
+            "use_book_order": False,
+            "book_order_top": 6,
+            "ask_last_balance": 0.0,
+        },
+        "ask_strategy": {
+            "use_book_order": False,
+            "book_order_min": 1,
+            "book_order_max": 10
         },
         "exchange": {
             "name": "bittrex",
@@ -108,7 +114,8 @@ 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

freqtrade/tests/exchange/test_exchange.py

@@ -310,9 +310,19 @@ def test_get_ticker(default_conf, mocker):
     # if not fetching a new result we should get the cached ticker
     ticker = get_ticker(pair='ETH/BTC')
 
+    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
+
+    # Test caching
+    api_mock.fetch_ticker = MagicMock()
+    get_ticker(pair='ETH/BTC', refresh=False)
+    assert api_mock.fetch_ticker.call_count == 0
+
     with pytest.raises(TemporaryError):  # test retrier
         api_mock.fetch_ticker = MagicMock(side_effect=ccxt.NetworkError)
         mocker.patch('freqtrade.exchange._API', api_mock)
@@ -323,6 +333,10 @@ def test_get_ticker(default_conf, mocker):
         mocker.patch('freqtrade.exchange._API', api_mock)
         get_ticker(pair='ETH/BTC', refresh=True)
 
+    api_mock.fetch_ticker = MagicMock(return_value={})
+    mocker.patch('freqtrade.exchange._API', api_mock)
+    get_ticker(pair='ETH/BTC', refresh=True)
+
 
 def make_fetch_ohlcv_mock(data):
     def fetch_ohlcv_mock(pair, timeframe, since):

freqtrade/tests/optimize/test_backtesting.py

@@ -13,7 +13,7 @@ from arrow import Arrow
 
 from freqtrade import optimize
 from freqtrade.analyze import Analyze
-from freqtrade.arguments import Arguments
+from freqtrade.arguments import Arguments, TimeRange
 from freqtrade.optimize.backtesting import Backtesting, start, setup_configuration
 from freqtrade.tests.conftest import log_has
 
@@ -30,7 +30,7 @@ def trim_dictlist(dict_list, num):
 
 
 def load_data_test(what):
-    timerange = ((None, 'line'), None, -100)
+    timerange = TimeRange(None, 'line', 0, -101)
     data = optimize.load_data(None, ticker_interval='1m',
                               pairs=['UNITTEST/BTC'], timerange=timerange)
     pair = data['UNITTEST/BTC']
@@ -112,14 +112,14 @@ def mocked_load_data(datadir, pairs=[], ticker_interval='0m', refresh_pairs=Fals
 # use for mock freqtrade.exchange.get_ticker_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(mocker, conf=None, pair='UNITTEST/BTC', record=None):
     data = optimize.load_data(None, ticker_interval='8m', pairs=[pair])
-    data = trim_dictlist(data, -200)
+    data = trim_dictlist(data, -201)
     mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
     backtesting = Backtesting(conf)
     return {
@@ -313,13 +313,13 @@ def test_tickerdata_to_dataframe(default_conf, mocker) -> None:
     Test Backtesting.tickerdata_to_dataframe() method
     """
     mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
-    timerange = ((None, 'line'), None, -100)
+    timerange = TimeRange(None, 'line', 0, -100)
     tick = optimize.load_tickerdata_file(None, 'UNITTEST/BTC', '1m', timerange=timerange)
     tickerlist = {'UNITTEST/BTC': tick}
 
     backtesting = Backtesting(default_conf)
     data = backtesting.tickerdata_to_dataframe(tickerlist)
-    assert len(data['UNITTEST/BTC']) == 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)
@@ -343,7 +343,7 @@ def test_get_timeframe(default_conf, mocker) -> None:
     )
     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(default_conf, mocker):
@@ -418,6 +418,40 @@ def test_backtesting_start(default_conf, mocker, caplog) -> None:
         assert log_has(line, caplog.record_tuples)
 
 
+def test_backtesting_start_no_data(default_conf, mocker, caplog) -> None:
+    """
+    Test Backtesting.start() method if no data is found
+    """
+
+    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', MagicMock(return_value={}))
+    mocker.patch('freqtrade.exchange.get_ticker_history')
+    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    mocker.patch.multiple(
+        'freqtrade.optimize.backtesting.Backtesting',
+        backtest=MagicMock(),
+        _generate_text_table=MagicMock(return_value='1'),
+        get_timeframe=get_timeframe,
+    )
+
+    conf = deepcopy(default_conf)
+    conf['exchange']['pair_whitelist'] = ['UNITTEST/BTC']
+    conf['ticker_interval'] = "1m"
+    conf['live'] = False
+    conf['datadir'] = None
+    conf['export'] = None
+    conf['timerange'] = '20180101-20180102'
+
+    backtesting = Backtesting(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:
     """
     Test Backtesting.backtest() method
@@ -480,7 +514,7 @@ def test_processed(default_conf, mocker) -> None:
 
 def test_backtest_pricecontours(default_conf, fee, mocker) -> None:
     mocker.patch('freqtrade.optimize.backtesting.exchange.get_fee', fee)
-    tests = [['raise', 17], ['lower', 0], ['sine', 17]]
+    tests = [['raise', 17], ['lower', 0], ['sine', 16]]
     for [contour, numres] in tests:
         simple_backtest(default_conf, contour, numres, mocker)
 
@@ -608,10 +642,12 @@ def test_backtest_start_live(default_conf, mocker, caplog):
     args = [
         '--config', 'config.json',
         '--strategy', 'DefaultStrategy',
+        '--datadir', 'freqtrade/tests/testdata',
         'backtesting',
         '--ticker-interval', '1m',
         '--live',
-        '--timerange', '-100'
+        '--timerange', '-100',
+        '--realistic-simulation'
     ]
     args = get_args(args)
     start(args)
@@ -621,13 +657,14 @@ def test_backtest_start_live(default_conf, mocker, caplog):
         'Using ticker_interval: 1m ...',
         'Parameter -l/--live detected ...',
         'Using max_open_trades: 1 ...',
-        'Parameter --timerange detected: -100 ..',
+        '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 --realistic-simulation detected ...'
     ]
 
     for line in exists:
-        log_has(line, caplog.record_tuples)
+        assert log_has(line, caplog.record_tuples)

freqtrade/tests/optimize/test_optimize.py

@@ -11,6 +11,7 @@ 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, \
     load_cached_data_for_updating
+from freqtrade.arguments import TimeRange
 from freqtrade.tests.conftest import log_has
 
 # Change this if modifying UNITTEST/BTC testdatafile
@@ -176,7 +177,7 @@ def test_load_cached_data_for_updating(mocker) -> None:
 
     # timeframe starts earlier than the cached data
     # should fully update data
-    timerange = (('date', None), test_data[0][0] / 1000 - 1, None)
+    timerange = TimeRange('date', None, test_data[0][0] / 1000 - 1, 0)
     data, start_ts = load_cached_data_for_updating(test_filename,
                                                    '1m',
                                                    timerange)
@@ -187,13 +188,13 @@ def test_load_cached_data_for_updating(mocker) -> None:
     num_lines = (test_data[-1][0] - test_data[1][0]) / 1000 / 60 + 120
     data, start_ts = load_cached_data_for_updating(test_filename,
                                                    '1m',
-                                                   ((None, 'line'), None, -num_lines))
+                                                   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 = (('date', None), test_data[0][0] / 1000 + 1, None)
+    timerange = TimeRange('date', None, test_data[0][0] / 1000 + 1, 0)
     data, start_ts = load_cached_data_for_updating(test_filename,
                                                    '1m',
                                                    timerange)
@@ -202,7 +203,7 @@ def test_load_cached_data_for_updating(mocker) -> None:
 
     # same with 'line' timeframe
     num_lines = (test_data[-1][0] - test_data[1][0]) / 1000 / 60 + 30
-    timerange = ((None, 'line'), None, -num_lines)
+    timerange = TimeRange(None, 'line', 0, -num_lines)
     data, start_ts = load_cached_data_for_updating(test_filename,
                                                    '1m',
                                                    timerange)
@@ -211,7 +212,7 @@ def test_load_cached_data_for_updating(mocker) -> None:
 
     # timeframe starts after the chached data
     # should return the chached data w/o the last item
-    timerange = (('date', None), test_data[-1][0] / 1000 + 1, None)
+    timerange = TimeRange('date', None, test_data[-1][0] / 1000 + 1, 0)
     data, start_ts = load_cached_data_for_updating(test_filename,
                                                    '1m',
                                                    timerange)
@@ -220,7 +221,7 @@ def test_load_cached_data_for_updating(mocker) -> None:
 
     # same with 'line' timeframe
     num_lines = 30
-    timerange = ((None, 'line'), None, -num_lines)
+    timerange = TimeRange(None, 'line', 0, -num_lines)
     data, start_ts = load_cached_data_for_updating(test_filename,
                                                    '1m',
                                                    timerange)
@@ -230,7 +231,7 @@ def test_load_cached_data_for_updating(mocker) -> None:
     # no timeframe is set
     # should return the chached data w/o the last item
     num_lines = 30
-    timerange = ((None, 'line'), None, -num_lines)
+    timerange = TimeRange(None, 'line', 0, -num_lines)
     data, start_ts = load_cached_data_for_updating(test_filename,
                                                    '1m',
                                                    timerange)
@@ -239,7 +240,7 @@ def test_load_cached_data_for_updating(mocker) -> None:
 
     # no datafile exist
     # should return timestamp start time
-    timerange = (('date', None), now_ts - 10000, None)
+    timerange = TimeRange('date', None, now_ts - 10000, 0)
     data, start_ts = load_cached_data_for_updating(test_filename + 'unexist',
                                                    '1m',
                                                    timerange)
@@ -248,7 +249,7 @@ def test_load_cached_data_for_updating(mocker) -> None:
 
     # same with 'line' timeframe
     num_lines = 30
-    timerange = ((None, 'line'), None, -num_lines)
+    timerange = TimeRange(None, 'line', 0, -num_lines)
     data, start_ts = load_cached_data_for_updating(test_filename + 'unexist',
                                                    '1m',
                                                    timerange)
@@ -343,7 +344,7 @@ def test_trim_tickerlist() -> None:
 
     # Test the pattern ^(-\d+)$
     # This pattern uses the latest N elements
-    timerange = ((None, 'line'), None, -5)
+    timerange = TimeRange(None, 'line', 0, -5)
     ticker = trim_tickerlist(ticker_list, timerange)
     ticker_len = len(ticker)
 
@@ -353,7 +354,7 @@ def test_trim_tickerlist() -> None:
 
     # 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)
 
@@ -363,7 +364,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)
 
@@ -374,7 +375,7 @@ def test_trim_tickerlist() -> None:
 
     # Test the pattern ^(\d{8})-(\d{8})$
     # This pattern extract a window between the dates
-    timerange = (('date', 'date'), ticker_list[5][0] / 1000, ticker_list[10][0] / 1000 - 1)
+    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)
 
@@ -385,7 +386,7 @@ def test_trim_tickerlist() -> None:
 
     # Test the pattern ^-(\d{8})$
     # This pattern extracts elements from the start to the date
-    timerange = ((None, 'date'), None, ticker_list[10][0] / 1000 - 1)
+    timerange = TimeRange(None, 'date', 0, ticker_list[10][0] / 1000 - 1)
     ticker = trim_tickerlist(ticker_list, timerange)
     ticker_len = len(ticker)
 
@@ -395,7 +396,7 @@ def test_trim_tickerlist() -> None:
 
     # Test the pattern ^(\d{8})-$
     # This pattern extracts elements from the date to now
-    timerange = (('date', None), ticker_list[10][0] / 1000 - 1, None)
+    timerange = TimeRange('date', None, ticker_list[10][0] / 1000 - 1, None)
     ticker = trim_tickerlist(ticker_list, timerange)
     ticker_len = len(ticker)
 
@@ -405,7 +406,7 @@ def test_trim_tickerlist() -> None:
 
     # 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)
 

freqtrade/tests/rpc/test_rpc.py

@@ -7,8 +7,6 @@ Unit test file for rpc/rpc.py
 from datetime import datetime
 from unittest.mock import MagicMock
 
-from sqlalchemy import create_engine
-
 from freqtrade.freqtradebot import FreqtradeBot
 from freqtrade.persistence import Trade
 from freqtrade.rpc.rpc import RPC
@@ -39,7 +37,7 @@ def test_rpc_trade_status(default_conf, ticker, fee, mocker) -> None:
         get_fee=fee
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     rpc = RPC(freqtradebot)
 
     freqtradebot.state = State.STOPPED
@@ -89,7 +87,7 @@ def test_rpc_status_table(default_conf, ticker, fee, mocker) -> None:
         get_fee=fee
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     rpc = RPC(freqtradebot)
 
     freqtradebot.state = State.STOPPED
@@ -125,7 +123,7 @@ def test_rpc_daily_profit(default_conf, update, ticker, fee,
         get_fee=fee
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     stake_currency = default_conf['stake_currency']
     fiat_display_currency = default_conf['fiat_display_currency']
 
@@ -182,7 +180,7 @@ def test_rpc_trade_statistics(default_conf, ticker, ticker_sell_up, fee,
         get_fee=fee
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     stake_currency = default_conf['stake_currency']
     fiat_display_currency = default_conf['fiat_display_currency']
 
@@ -208,15 +206,30 @@ def test_rpc_trade_statistics(default_conf, ticker, ticker_sell_up, fee,
     trade.close_date = datetime.utcnow()
     trade.is_open = False
 
+    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.freqtradebot.exchange',
+        validate_pairs=MagicMock(),
+        get_ticker=ticker_sell_up
+    )
+    trade.update(limit_sell_order)
+    trade.close_date = datetime.utcnow()
+    trade.is_open = False
+
     (error, stats) = rpc.rpc_trade_statistics(stake_currency, fiat_display_currency)
     assert not error
     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_coin'], 5.632e-05)
-    assert prec_satoshi(stats['profit_all_percent'], 6.2)
+    assert prec_satoshi(stats['profit_all_percent'], 2.81)
-    assert prec_satoshi(stats['profit_all_fiat'], 0.93255)
+    assert prec_satoshi(stats['profit_all_fiat'], 0.8448)
-    assert stats['trade_count'] == 1
+    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'
@@ -245,7 +258,7 @@ def test_rpc_trade_statistics_closed(mocker, default_conf, ticker, fee,
         get_fee=fee
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     stake_currency = default_conf['stake_currency']
     fiat_display_currency = default_conf['fiat_display_currency']
 
@@ -316,7 +329,7 @@ def test_rpc_balance_handle(default_conf, mocker):
         get_balances=MagicMock(return_value=mock_balance)
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     rpc = RPC(freqtradebot)
 
     (error, res) = rpc.rpc_balance(default_conf['fiat_display_currency'])
@@ -346,7 +359,7 @@ def test_rpc_start(mocker, default_conf) -> None:
         get_ticker=MagicMock()
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     rpc = RPC(freqtradebot)
     freqtradebot.state = State.STOPPED
 
@@ -374,7 +387,7 @@ def test_rpc_stop(mocker, default_conf) -> None:
         get_ticker=MagicMock()
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     rpc = RPC(freqtradebot)
     freqtradebot.state = State.RUNNING
 
@@ -413,7 +426,7 @@ def test_rpc_forcesell(default_conf, ticker, fee, mocker) -> None:
         get_fee=fee,
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     rpc = RPC(freqtradebot)
 
     freqtradebot.state = State.STOPPED
@@ -523,7 +536,7 @@ def test_performance_handle(default_conf, ticker, limit_buy_order, fee,
         get_fee=fee
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     rpc = RPC(freqtradebot)
 
     # Create some test data
@@ -562,7 +575,7 @@ def test_rpc_count(mocker, default_conf, ticker, fee) -> None:
         get_fee=fee,
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     rpc = RPC(freqtradebot)
 
     (error, trades) = rpc.rpc_count()

freqtrade/tests/rpc/test_rpc_telegram.py

@@ -11,7 +11,6 @@ from datetime import datetime
 from random import randint
 from unittest.mock import MagicMock
 
-from sqlalchemy import create_engine
 from telegram import Update, Message, Chat
 from telegram.error import NetworkError
 
@@ -71,12 +70,12 @@ def test_init(default_conf, mocker, caplog) -> None:
     assert start_polling.call_count == 0
 
     # number of handles registered
-    assert start_polling.dispatcher.add_handler.call_count == 11
+    assert start_polling.dispatcher.add_handler.call_count > 0
     assert start_polling.start_polling.call_count == 1
 
     message_str = "rpc.telegram is listening for following commands: [['status'], ['profit'], " \
                   "['balance'], ['start'], ['stop'], ['forcesell'], ['performance'], ['daily'], " \
-                  "['count'], ['help'], ['version']]"
+                  "['count'], ['reload_conf'], ['help'], ['version']]"
 
     assert log_has(message_str, caplog.record_tuples)
 
@@ -156,7 +155,7 @@ def test_authorized_only(default_conf, mocker, caplog) -> None:
 
     conf = deepcopy(default_conf)
     conf['telegram']['enabled'] = False
-    dummy = DummyCls(FreqtradeBot(conf, create_engine('sqlite://')))
+    dummy = DummyCls(FreqtradeBot(conf))
     dummy.dummy_handler(bot=MagicMock(), update=update)
     assert dummy.state['called'] is True
     assert log_has(
@@ -187,7 +186,7 @@ def test_authorized_only_unauthorized(default_conf, mocker, caplog) -> None:
 
     conf = deepcopy(default_conf)
     conf['telegram']['enabled'] = False
-    dummy = DummyCls(FreqtradeBot(conf, create_engine('sqlite://')))
+    dummy = DummyCls(FreqtradeBot(conf))
     dummy.dummy_handler(bot=MagicMock(), update=update)
     assert dummy.state['called'] is False
     assert not log_has(
@@ -217,7 +216,7 @@ def test_authorized_only_exception(default_conf, mocker, caplog) -> None:
 
     conf = deepcopy(default_conf)
     conf['telegram']['enabled'] = False
-    dummy = DummyCls(FreqtradeBot(conf, create_engine('sqlite://')))
+    dummy = DummyCls(FreqtradeBot(conf))
     dummy.dummy_exception(bot=MagicMock(), update=update)
     assert dummy.state['called'] is False
     assert not log_has(
@@ -263,7 +262,7 @@ def test_status(default_conf, update, mocker, fee, ticker) -> None:
     )
     mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
 
-    freqtradebot = FreqtradeBot(conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(conf)
     telegram = Telegram(freqtradebot)
 
     # Create some test data
@@ -301,7 +300,7 @@ def test_status_handle(default_conf, update, ticker, fee, mocker) -> None:
     )
     mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     telegram = Telegram(freqtradebot)
 
     freqtradebot.state = State.STOPPED
@@ -348,7 +347,7 @@ def test_status_table_handle(default_conf, update, ticker, fee, mocker) -> None:
 
     conf = deepcopy(default_conf)
     conf['stake_amount'] = 15.0
-    freqtradebot = FreqtradeBot(conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(conf)
     telegram = Telegram(freqtradebot)
 
     freqtradebot.state = State.STOPPED
@@ -402,7 +401,7 @@ def test_daily_handle(default_conf, update, ticker, limit_buy_order, fee,
     )
     mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     telegram = Telegram(freqtradebot)
 
     # Create some test data
@@ -470,7 +469,7 @@ def test_daily_wrong_input(default_conf, update, ticker, mocker) -> None:
     )
     mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     telegram = Telegram(freqtradebot)
 
     # Try invalid data
@@ -511,7 +510,7 @@ def test_profit_handle(default_conf, update, ticker, ticker_sell_up, fee,
     )
     mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     telegram = Telegram(freqtradebot)
 
     telegram._profit(bot=MagicMock(), update=update)
@@ -608,7 +607,7 @@ def test_telegram_balance_handle(default_conf, update, mocker) -> None:
         send_msg=msg_mock
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     telegram = Telegram(freqtradebot)
 
     telegram._balance(bot=MagicMock(), update=update)
@@ -638,7 +637,7 @@ def test_zero_balance_handle(default_conf, update, mocker) -> None:
         send_msg=msg_mock
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     telegram = Telegram(freqtradebot)
 
     telegram._balance(bot=MagicMock(), update=update)
@@ -661,7 +660,7 @@ def test_start_handle(default_conf, update, mocker) -> None:
     )
     mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     telegram = Telegram(freqtradebot)
 
     freqtradebot.state = State.STOPPED
@@ -685,7 +684,7 @@ def test_start_handle_already_running(default_conf, update, mocker) -> None:
     )
     mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     telegram = Telegram(freqtradebot)
 
     freqtradebot.state = State.RUNNING
@@ -710,7 +709,7 @@ def test_stop_handle(default_conf, update, mocker) -> None:
     )
     mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     telegram = Telegram(freqtradebot)
 
     freqtradebot.state = State.RUNNING
@@ -735,7 +734,7 @@ def test_stop_handle_already_stopped(default_conf, update, mocker) -> None:
     )
     mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     telegram = Telegram(freqtradebot)
 
     freqtradebot.state = State.STOPPED
@@ -746,6 +745,29 @@ def test_stop_handle_already_stopped(default_conf, update, mocker) -> None:
     assert 'already stopped' in msg_mock.call_args_list[0][0][0]
 
 
+def test_reload_conf_handle(default_conf, update, mocker) -> None:
+    """ Test _reload_conf() method """
+    patch_coinmarketcap(mocker)
+    mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
+    msg_mock = MagicMock()
+    mocker.patch.multiple(
+        'freqtrade.rpc.telegram.Telegram',
+        _init=MagicMock(),
+        send_msg=msg_mock
+    )
+    mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
+
+    freqtradebot = FreqtradeBot(default_conf)
+    telegram = Telegram(freqtradebot)
+
+    freqtradebot.state = State.RUNNING
+    assert freqtradebot.state == State.RUNNING
+    telegram._reload_conf(bot=MagicMock(), update=update)
+    assert freqtradebot.state == State.RELOAD_CONF
+    assert msg_mock.call_count == 1
+    assert 'Reloading config' in msg_mock.call_args_list[0][0][0]
+
+
 def test_forcesell_handle(default_conf, update, ticker, fee, ticker_sell_up, mocker) -> None:
     """
     Test _forcesell() method
@@ -762,7 +784,7 @@ def test_forcesell_handle(default_conf, update, ticker, fee, ticker_sell_up, moc
         get_fee=fee
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     telegram = Telegram(freqtradebot)
 
     # Create some test data
@@ -802,7 +824,7 @@ def test_forcesell_down_handle(default_conf, update, ticker, fee, ticker_sell_do
         get_fee=fee
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     telegram = Telegram(freqtradebot)
 
     # Create some test data
@@ -847,7 +869,7 @@ def test_forcesell_all_handle(default_conf, update, ticker, fee, mocker) -> None
         get_fee=fee
     )
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     telegram = Telegram(freqtradebot)
 
     # Create some test data
@@ -880,7 +902,7 @@ def test_forcesell_handle_invalid(default_conf, update, mocker) -> None:
     )
     mocker.patch('freqtrade.freqtradebot.exchange.validate_pairs', MagicMock())
 
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     telegram = Telegram(freqtradebot)
 
     # Trader is not running
@@ -927,7 +949,7 @@ def test_performance_handle(default_conf, update, ticker, fee,
         get_fee=fee
     )
     mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     telegram = Telegram(freqtradebot)
 
     # Create some test data
@@ -962,7 +984,7 @@ def test_performance_handle_invalid(default_conf, update, mocker) -> None:
         send_msg=msg_mock
     )
     mocker.patch('freqtrade.freqtradebot.exchange.validate_pairs', MagicMock())
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     telegram = Telegram(freqtradebot)
 
     # Trader is not running
@@ -991,7 +1013,7 @@ def test_count_handle(default_conf, update, ticker, fee, mocker) -> None:
         buy=MagicMock(return_value={'id': 'mocked_order_id'})
     )
     mocker.patch('freqtrade.optimize.backtesting.exchange.get_fee', fee)
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     telegram = Telegram(freqtradebot)
 
     freqtradebot.state = State.STOPPED
@@ -1027,7 +1049,7 @@ def test_help_handle(default_conf, update, mocker) -> None:
         _init=MagicMock(),
         send_msg=msg_mock
     )
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     telegram = Telegram(freqtradebot)
 
     telegram._help(bot=MagicMock(), update=update)
@@ -1047,7 +1069,7 @@ def test_version_handle(default_conf, update, mocker) -> None:
         _init=MagicMock(),
         send_msg=msg_mock
     )
-    freqtradebot = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(default_conf)
     telegram = Telegram(freqtradebot)
 
     telegram._version(bot=MagicMock(), update=update)
@@ -1064,7 +1086,7 @@ def test_send_msg(default_conf, mocker) -> None:
     mocker.patch('freqtrade.rpc.telegram.Telegram._init', MagicMock())
     conf = deepcopy(default_conf)
     bot = MagicMock()
-    freqtradebot = FreqtradeBot(conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(conf)
     telegram = Telegram(freqtradebot)
 
     telegram._config['telegram']['enabled'] = False
@@ -1087,7 +1109,7 @@ def test_send_msg_network_error(default_conf, mocker, caplog) -> None:
     conf = deepcopy(default_conf)
     bot = MagicMock()
     bot.send_message = MagicMock(side_effect=NetworkError('Oh snap'))
-    freqtradebot = FreqtradeBot(conf, create_engine('sqlite://'))
+    freqtradebot = FreqtradeBot(conf)
     telegram = Telegram(freqtradebot)
 
     telegram._config['telegram']['enabled'] = True

freqtrade/tests/test_analyze.py

@@ -13,6 +13,7 @@ from pandas import DataFrame
 
 from freqtrade.analyze import Analyze, SignalType
 from freqtrade.optimize.__init__ import load_tickerdata_file
+from freqtrade.arguments import TimeRange
 from freqtrade.tests.conftest import log_has
 
 # Avoid to reinit the same object again and again
@@ -45,7 +46,7 @@ def test_analyze_object() -> None:
 
 def test_dataframe_correct_length(result):
     dataframe = Analyze.parse_ticker_dataframe(result)
-    assert len(result.index) == len(dataframe.index)
+    assert len(result.index) - 1 == len(dataframe.index)    # last partial candle removed
 
 
 def test_dataframe_correct_columns(result):
@@ -183,8 +184,8 @@ def test_tickerdata_to_dataframe(default_conf) -> None:
     """
     analyze = Analyze(default_conf)
 
-    timerange = ((None, 'line'), None, -100)
+    timerange = TimeRange(None, 'line', 0, -100)
     tick = load_tickerdata_file(None, 'UNITTEST/BTC', '1m', timerange=timerange)
     tickerlist = {'UNITTEST/BTC': tick}
     data = analyze.tickerdata_to_dataframe(tickerlist)
-    assert len(data['UNITTEST/BTC']) == 100
+    assert len(data['UNITTEST/BTC']) == 99       # partial candle was removed

freqtrade/tests/test_arguments.py

@@ -9,7 +9,7 @@ import logging
 
 import pytest
 
-from freqtrade.arguments import Arguments
+from freqtrade.arguments import Arguments, TimeRange
 
 
 def test_arguments_object() -> None:
@@ -46,6 +46,11 @@ 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
@@ -107,20 +112,24 @@ 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 TimeRange(None, 'line', 0, -200) == Arguments.parse_timerange('-200')
-    assert (('line', None), 200, None) == Arguments.parse_timerange('200-')
+    assert TimeRange('line', None, 200, 0) == Arguments.parse_timerange('200-')
-    assert (('index', 'index'), 200, 500) == Arguments.parse_timerange('200-500')
+    assert TimeRange('index', 'index', 200, 500) == Arguments.parse_timerange('200-500')
 
-    assert (('date', None), 1274486400, None) == Arguments.parse_timerange('20100522-')
+    assert TimeRange('date', None, 1274486400, 0) == Arguments.parse_timerange('20100522-')
-    assert ((None, 'date'), None, 1274486400) == Arguments.parse_timerange('-20100522')
+    assert TimeRange(None, 'date', 0, 1274486400) == Arguments.parse_timerange('-20100522')
     timerange = Arguments.parse_timerange('20100522-20150730')
-    assert timerange == (('date', 'date'), 1274486400, 1438214400)
+    assert timerange == TimeRange('date', 'date', 1274486400, 1438214400)
 
     # Added test for unix timestamp - BTC genesis date
-    assert (('date', None), 1231006505, None) == Arguments.parse_timerange('1231006505-')
+    assert TimeRange('date', None, 1231006505, 0) == Arguments.parse_timerange('1231006505-')
-    assert ((None, 'date'), None, 1233360000) == Arguments.parse_timerange('-1233360000')
+    assert TimeRange(None, 'date', 0, 1233360000) == Arguments.parse_timerange('-1233360000')
     timerange = Arguments.parse_timerange('1231006505-1233360000')
-    assert timerange == (('date', 'date'), 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('-')
@@ -165,3 +174,19 @@ def test_parse_args_hyperopt_custom() -> None:
     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

@@ -85,7 +85,7 @@ def test_load_config_max_open_trades_zero(default_conf, mocker, caplog) -> None:
     assert log_has('Validating configuration ...', caplog.record_tuples)
 
 
-def test_load_config_file_exception(mocker, caplog) -> None:
+def test_load_config_file_exception(mocker) -> None:
     """
     Test Configuration._load_config_file() method
     """
@@ -95,12 +95,8 @@ def test_load_config_file_exception(mocker, caplog) -> None:
     )
     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:
@@ -118,7 +114,6 @@ 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:
@@ -133,7 +128,7 @@ def test_load_config_with_params(default_conf, mocker) -> None:
         '--dynamic-whitelist', '10',
         '--strategy', 'TestStrategy',
         '--strategy-path', '/some/path',
-        '--dry-run-db',
+        '--db-url', 'sqlite:///someurl',
     ]
     args = Arguments(arglist, '').get_parsed_arg()
 
@@ -143,7 +138,7 @@ def test_load_config_with_params(default_conf, mocker) -> None:
     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'
 
 
 def test_load_custom_strategy(default_conf, mocker) -> None:
@@ -178,7 +173,7 @@ def test_show_info(default_conf, mocker, caplog) -> None:
     arglist = [
         '--dynamic-whitelist', '10',
         '--strategy', 'TestStrategy',
-        '--dry-run-db'
+        '--db-url', 'sqlite:///tmp/testdb',
     ]
     args = Arguments(arglist, '').get_parsed_arg()
 
@@ -192,23 +187,8 @@ def test_show_info(default_conf, mocker, caplog) -> None:
         caplog.record_tuples
     )
 
-    assert log_has(
+    assert log_has('Using DB: "sqlite:///tmp/testdb"', caplog.record_tuples)
-        'Parameter --dry-run-db detected ...',
+    assert log_has('Dry run is enabled', caplog.record_tuples)
-        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})  # type: ignore
-    configuration._load_common_config(configuration.config)  # type: ignore
-    assert log_has(
-        'Dry run is disabled. (--dry_run_db ignored)',
-        caplog.record_tuples
-    )
 
 
 def test_setup_configuration_without_arguments(mocker, default_conf, caplog) -> None:

freqtrade/tests/test_fiat_convert.py

@@ -9,7 +9,7 @@ import pytest
 from requests.exceptions import RequestException
 
 from freqtrade.fiat_convert import CryptoFiat, CryptoToFiatConverter
-from freqtrade.tests.conftest import patch_coinmarketcap
+from freqtrade.tests.conftest import log_has, patch_coinmarketcap
 
 
 def test_pair_convertion_object():
@@ -90,6 +90,13 @@ 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=[])
+    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,
@@ -161,7 +168,8 @@ def test_fiat_init_network_exception(mocker):
     fiat_convert._cryptomap = {}
     fiat_convert._load_cryptomap()
 
-    assert len(fiat_convert._cryptomap) == 0
+    length_cryptomap = len(fiat_convert._cryptomap)
+    assert length_cryptomap == 0
 
 
 def test_fiat_convert_without_network():
@@ -175,3 +183,22 @@ def test_fiat_convert_without_network():
     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_convert_amount(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_freqtradebot.py

@@ -13,7 +13,6 @@ from unittest.mock import MagicMock
 import arrow
 import pytest
 import requests
-from sqlalchemy import create_engine
 
 from freqtrade import DependencyException, OperationalException, TemporaryError
 from freqtrade.freqtradebot import FreqtradeBot
@@ -36,7 +35,7 @@ def get_patched_freqtradebot(mocker, config) -> FreqtradeBot:
     mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
     patch_coinmarketcap(mocker)
 
-    return FreqtradeBot(config, create_engine('sqlite://'))
+    return FreqtradeBot(config)
 
 
 def patch_get_signal(mocker, value=(True, False)) -> None:
@@ -69,7 +68,7 @@ def test_freqtradebot_object() -> None:
     Test the FreqtradeBot object has the mandatory public methods
     """
     assert hasattr(FreqtradeBot, 'worker')
-    assert hasattr(FreqtradeBot, 'clean')
+    assert hasattr(FreqtradeBot, 'cleanup')
     assert hasattr(FreqtradeBot, 'create_trade')
     assert hasattr(FreqtradeBot, 'get_target_bid')
     assert hasattr(FreqtradeBot, 'process_maybe_execute_buy')
@@ -94,7 +93,7 @@ def test_freqtradebot(mocker, default_conf) -> None:
     assert freqtrade.state is State.STOPPED
 
 
-def test_clean(mocker, default_conf, caplog) -> None:
+def test_cleanup(mocker, default_conf, caplog) -> None:
     """
     Test clean() method
     """
@@ -102,11 +101,8 @@ def test_clean(mocker, default_conf, caplog) -> None:
     mocker.patch('freqtrade.persistence.cleanup', mock_cleanup)
 
     freqtrade = get_patched_freqtradebot(mocker, default_conf)
-    assert freqtrade.state == State.RUNNING
+    freqtrade.cleanup()
-
+    assert log_has('Cleaning up modules ...', caplog.record_tuples)
-    assert freqtrade.clean()
-    assert freqtrade.state == State.STOPPED
-    assert log_has('Stopping trader and cleaning up modules...', caplog.record_tuples)
     assert mock_cleanup.call_count == 1
 
 
@@ -237,7 +233,7 @@ def test_create_trade(default_conf, ticker, limit_buy_order, fee, mocker) -> Non
 
     # Save state of current whitelist
     whitelist = deepcopy(default_conf['exchange']['pair_whitelist'])
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
     freqtrade.create_trade()
 
     trade = Trade.query.first()
@@ -274,7 +270,7 @@ def test_create_trade_minimal_amount(default_conf, ticker, limit_buy_order, fee,
 
     conf = deepcopy(default_conf)
     conf['stake_amount'] = 0.0005
-    freqtrade = FreqtradeBot(conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(conf)
 
     freqtrade.create_trade()
     rate, amount = buy_mock.call_args[0][1], buy_mock.call_args[0][2]
@@ -296,7 +292,7 @@ def test_create_trade_no_stake_amount(default_conf, ticker, limit_buy_order, fee
         get_balance=MagicMock(return_value=default_conf['stake_amount'] * 0.5),
         get_fee=fee,
     )
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
 
     with pytest.raises(DependencyException, match=r'.*stake amount.*'):
         freqtrade.create_trade()
@@ -320,7 +316,7 @@ def test_create_trade_no_pairs(default_conf, ticker, limit_buy_order, fee, mocke
     conf = deepcopy(default_conf)
     conf['exchange']['pair_whitelist'] = ["ETH/BTC"]
     conf['exchange']['pair_blacklist'] = ["ETH/BTC"]
-    freqtrade = FreqtradeBot(conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(conf)
 
     freqtrade.create_trade()
 
@@ -347,7 +343,7 @@ def test_create_trade_no_pairs_after_blacklist(default_conf, ticker,
     conf = deepcopy(default_conf)
     conf['exchange']['pair_whitelist'] = ["ETH/BTC"]
     conf['exchange']['pair_blacklist'] = ["ETH/BTC"]
-    freqtrade = FreqtradeBot(conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(conf)
 
     freqtrade.create_trade()
 
@@ -375,7 +371,7 @@ def test_create_trade_no_signal(default_conf, fee, mocker) -> None:
 
     conf = deepcopy(default_conf)
     conf['stake_amount'] = 10
-    freqtrade = FreqtradeBot(conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(conf)
 
     Trade.query = MagicMock()
     Trade.query.filter = MagicMock()
@@ -399,7 +395,7 @@ def test_process_trade_creation(default_conf, ticker, limit_buy_order,
         get_order=MagicMock(return_value=limit_buy_order),
         get_fee=fee,
     )
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
 
     trades = Trade.query.filter(Trade.is_open.is_(True)).all()
     assert not trades
@@ -440,7 +436,7 @@ def test_process_exchange_failures(default_conf, ticker, markets, mocker) -> Non
     )
     sleep_mock = mocker.patch('time.sleep', side_effect=lambda _: None)
 
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
     result = freqtrade._process()
     assert result is False
     assert sleep_mock.has_calls()
@@ -460,7 +456,7 @@ def test_process_operational_exception(default_conf, ticker, markets, mocker) ->
         get_markets=markets,
         buy=MagicMock(side_effect=OperationalException)
     )
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
     assert freqtrade.state == State.RUNNING
 
     result = freqtrade._process()
@@ -486,7 +482,7 @@ def test_process_trade_handling(
         get_order=MagicMock(return_value=limit_buy_order),
         get_fee=fee,
     )
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
 
     trades = Trade.query.filter(Trade.is_open.is_(True)).all()
     assert not trades
@@ -503,27 +499,27 @@ def test_balance_fully_ask_side(mocker) -> None:
     """
     Test get_target_bid() method
     """
-    freqtrade = get_patched_freqtradebot(mocker, {'bid_strategy': {'ask_last_balance': 0.0}})
+    freqtrade = get_patched_freqtradebot(mocker, {'bid_strategy': {'use_book_order':False,'book_order_top':6,'ask_last_balance': 0.0}})
 
-    assert freqtrade.get_target_bid({'ask': 20, 'last': 10}) == 20
+    assert freqtrade.get_target_bid('ETH/BTC') >= 0.07
 
 
 def test_balance_fully_last_side(mocker) -> None:
     """
     Test get_target_bid() method
     """
-    freqtrade = get_patched_freqtradebot(mocker, {'bid_strategy': {'ask_last_balance': 1.0}})
+    freqtrade = get_patched_freqtradebot(mocker, {'bid_strategy': {'use_book_order':False,'book_order_top':6,'ask_last_balance': 1.0}})
 
-    assert freqtrade.get_target_bid({'ask': 20, 'last': 10}) == 10
+    assert freqtrade.get_target_bid('ETH/BTC') >= 0.07
 
 
 def test_balance_bigger_last_ask(mocker) -> None:
     """
     Test get_target_bid() method
     """
-    freqtrade = get_patched_freqtradebot(mocker, {'bid_strategy': {'ask_last_balance': 1.0}})
+    freqtrade = get_patched_freqtradebot(mocker, {'bid_strategy': {'use_book_order':False,'book_order_top':6,'ask_last_balance': 1.0}})
 
-    assert freqtrade.get_target_bid({'ask': 5, 'last': 10}) == 5
+    assert freqtrade.get_target_bid('ETH/BTC') >= 0.07
 
 
 def test_process_maybe_execute_buy(mocker, default_conf) -> None:
@@ -570,8 +566,10 @@ def test_process_maybe_execute_sell(mocker, default_conf, limit_buy_order, caplo
     trade.open_fee = 0.001
     assert not freqtrade.process_maybe_execute_sell(trade)
     # Test amount not modified by fee-logic
-    assert not log_has('Applying fee to amount for Trade {} from 90.99181073 to 90.81'.format(
+    assert not log_has(
-                       trade), caplog.record_tuples)
+        'Applying fee to amount for Trade {} from 90.99181073 to 90.81'.format(trade),
+        caplog.record_tuples
+    )
 
     mocker.patch('freqtrade.freqtradebot.FreqtradeBot.get_real_amount', return_value=90.81)
     # test amount modified by fee-logic
@@ -582,6 +580,38 @@ def test_process_maybe_execute_sell(mocker, default_conf, limit_buy_order, caplo
     # Assert we call handle_trade() if trade is feasible for execution
     assert freqtrade.process_maybe_execute_sell(trade)
 
+    regexp = re.compile('Found open order for.*')
+    assert filter(regexp.match, caplog.record_tuples)
+
+
+def test_process_maybe_execute_sell_exception(mocker, default_conf,
+                                              limit_buy_order, caplog) -> None:
+    """
+    Test the exceptions in process_maybe_execute_sell()
+    """
+    freqtrade = get_patched_freqtradebot(mocker, default_conf)
+    mocker.patch('freqtrade.freqtradebot.exchange.get_order', return_value=limit_buy_order)
+
+    trade = MagicMock()
+    trade.open_order_id = '123'
+    trade.open_fee = 0.001
+
+    # Test raise of OperationalException exception
+    mocker.patch(
+        'freqtrade.freqtradebot.FreqtradeBot.get_real_amount',
+        side_effect=OperationalException()
+    )
+    freqtrade.process_maybe_execute_sell(trade)
+    assert log_has('could not update trade amount: ', caplog.record_tuples)
+
+    # Test raise of DependencyException exception
+    mocker.patch(
+        'freqtrade.freqtradebot.FreqtradeBot.get_real_amount',
+        side_effect=DependencyException()
+    )
+    freqtrade.process_maybe_execute_sell(trade)
+    assert log_has('Unable to sell trade: ', caplog.record_tuples)
+
 
 def test_handle_trade(default_conf, limit_buy_order, limit_sell_order, fee, mocker) -> None:
     """
@@ -603,7 +633,7 @@ def test_handle_trade(default_conf, limit_buy_order, limit_sell_order, fee, mock
     )
     patch_coinmarketcap(mocker, value={'price_usd': 15000.0})
 
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
 
     freqtrade.create_trade()
 
@@ -646,7 +676,7 @@ def test_handle_overlpapping_signals(default_conf, ticker, limit_buy_order, fee,
         get_fee=fee,
     )
 
-    freqtrade = FreqtradeBot(conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(conf)
 
     freqtrade.create_trade()
 
@@ -705,7 +735,7 @@ def test_handle_trade_roi(default_conf, ticker, limit_buy_order, fee, mocker, ca
     )
 
     mocker.patch('freqtrade.freqtradebot.Analyze.min_roi_reached', return_value=True)
-    freqtrade = FreqtradeBot(conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(conf)
     freqtrade.create_trade()
 
     trade = Trade.query.first()
@@ -742,7 +772,7 @@ def test_handle_trade_experimental(
     )
     mocker.patch('freqtrade.freqtradebot.Analyze.min_roi_reached', return_value=False)
 
-    freqtrade = FreqtradeBot(conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(conf)
     freqtrade.create_trade()
 
     trade = Trade.query.first()
@@ -770,7 +800,7 @@ def test_close_trade(default_conf, ticker, limit_buy_order, limit_sell_order, fe
         buy=MagicMock(return_value={'id': limit_buy_order['id']}),
         get_fee=fee,
     )
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
 
     # Create trade and sell it
     freqtrade.create_trade()
@@ -801,7 +831,7 @@ def test_check_handle_timedout_buy(default_conf, ticker, limit_buy_order_old, fe
         cancel_order=cancel_order_mock,
         get_fee=fee
     )
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
 
     trade_buy = Trade(
         pair='ETH/BTC',
@@ -841,7 +871,7 @@ def test_check_handle_timedout_sell(default_conf, ticker, limit_sell_order_old,
         get_order=MagicMock(return_value=limit_sell_order_old),
         cancel_order=cancel_order_mock
     )
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
 
     trade_sell = Trade(
         pair='ETH/BTC',
@@ -881,7 +911,7 @@ def test_check_handle_timedout_partial(default_conf, ticker, limit_buy_order_old
         get_order=MagicMock(return_value=limit_buy_order_old_partial),
         cancel_order=cancel_order_mock
     )
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
 
     trade_buy = Trade(
         pair='ETH/BTC',
@@ -929,7 +959,7 @@ def test_check_handle_timedout_exception(default_conf, ticker, mocker, caplog) -
         get_order=MagicMock(side_effect=requests.exceptions.RequestException('Oh snap')),
         cancel_order=cancel_order_mock
     )
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
 
     trade_buy = Trade(
         pair='ETH/BTC',
@@ -968,7 +998,7 @@ def test_handle_timedout_limit_buy(mocker, default_conf) -> None:
         cancel_order=cancel_order_mock
     )
 
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
 
     Trade.session = MagicMock()
     trade = MagicMock()
@@ -994,7 +1024,7 @@ def test_handle_timedout_limit_sell(mocker, default_conf) -> None:
         cancel_order=cancel_order_mock
     )
 
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
 
     trade = MagicMock()
     order = {'remaining': 1,
@@ -1021,7 +1051,7 @@ def test_execute_sell_up(default_conf, ticker, fee, ticker_sell_up, mocker) -> N
         get_fee=fee
     )
     mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
 
     # Create some test data
     freqtrade.create_trade()
@@ -1062,7 +1092,7 @@ def test_execute_sell_down(default_conf, ticker, fee, ticker_sell_down, mocker)
         get_ticker=ticker,
         get_fee=fee
     )
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
 
     # Create some test data
     freqtrade.create_trade()
@@ -1102,7 +1132,7 @@ def test_execute_sell_without_conf_sell_up(default_conf, ticker, fee,
         get_ticker=ticker,
         get_fee=fee
     )
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
 
     # Create some test data
     freqtrade.create_trade()
@@ -1143,7 +1173,7 @@ def test_execute_sell_without_conf_sell_down(default_conf, ticker, fee,
         get_ticker=ticker,
         get_fee=fee
     )
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
 
     # Create some test data
     freqtrade.create_trade()
@@ -1192,7 +1222,7 @@ def test_sell_profit_only_enable_profit(default_conf, limit_buy_order, fee, mock
         'use_sell_signal': True,
         'sell_profit_only': True,
     }
-    freqtrade = FreqtradeBot(conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(conf)
     freqtrade.create_trade()
 
     trade = Trade.query.first()
@@ -1225,7 +1255,7 @@ def test_sell_profit_only_disable_profit(default_conf, limit_buy_order, fee, moc
         'use_sell_signal': True,
         'sell_profit_only': False,
     }
-    freqtrade = FreqtradeBot(conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(conf)
     freqtrade.create_trade()
 
     trade = Trade.query.first()
@@ -1258,7 +1288,7 @@ def test_sell_profit_only_enable_loss(default_conf, limit_buy_order, fee, mocker
         'use_sell_signal': True,
         'sell_profit_only': True,
     }
-    freqtrade = FreqtradeBot(conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(conf)
     freqtrade.create_trade()
 
     trade = Trade.query.first()
@@ -1293,7 +1323,7 @@ def test_sell_profit_only_disable_loss(default_conf, limit_buy_order, fee, mocke
         'sell_profit_only': False,
     }
 
-    freqtrade = FreqtradeBot(conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(conf)
     freqtrade.create_trade()
 
     trade = Trade.query.first()
@@ -1321,7 +1351,7 @@ def test_get_real_amount_quote(default_conf, trades_for_order, buy_order_fee, ca
         open_rate=0.245441,
         open_order_id="123456"
         )
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
     # Amount is reduced by "fee"
     assert freqtrade.get_real_amount(trade, buy_order_fee) == amount - (amount * 0.001)
     assert log_has('Applying fee on amount for Trade(id=None, pair=LTC/ETH, amount=8.00000000, '
@@ -1348,7 +1378,7 @@ def test_get_real_amount_no_trade(default_conf, buy_order_fee, caplog, mocker):
         open_rate=0.245441,
         open_order_id="123456"
     )
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
     # Amount is reduced by "fee"
     assert freqtrade.get_real_amount(trade, buy_order_fee) == amount
     assert log_has('Applying fee on amount for Trade(id=None, pair=LTC/ETH, amount=8.00000000, '
@@ -1356,7 +1386,7 @@ def test_get_real_amount_no_trade(default_conf, buy_order_fee, caplog, mocker):
                    caplog.record_tuples)
 
 
-def test_get_real_amount_stake(default_conf, trades_for_order, buy_order_fee, caplog, mocker):
+def test_get_real_amount_stake(default_conf, trades_for_order, buy_order_fee, mocker):
     """
     Test get_real_amount - fees in Stake currency
     """
@@ -1375,7 +1405,7 @@ def test_get_real_amount_stake(default_conf, trades_for_order, buy_order_fee, ca
         open_rate=0.245441,
         open_order_id="123456"
     )
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
     # Amount does not change
     assert freqtrade.get_real_amount(trade, buy_order_fee) == amount
 
@@ -1401,7 +1431,7 @@ def test_get_real_amount_BNB(default_conf, trades_for_order, buy_order_fee, mock
         open_rate=0.245441,
         open_order_id="123456"
     )
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
     # Amount does not change
     assert freqtrade.get_real_amount(trade, buy_order_fee) == amount
 
@@ -1424,7 +1454,7 @@ def test_get_real_amount_multi(default_conf, trades_for_order2, buy_order_fee, c
         open_rate=0.245441,
         open_order_id="123456"
     )
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
     # Amount is reduced by "fee"
     assert freqtrade.get_real_amount(trade, buy_order_fee) == amount - (amount * 0.001)
     assert log_has('Applying fee on amount for Trade(id=None, pair=LTC/ETH, amount=8.00000000, '
@@ -1452,7 +1482,7 @@ def test_get_real_amount_fromorder(default_conf, trades_for_order, buy_order_fee
         open_rate=0.245441,
         open_order_id="123456"
     )
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
     # Amount is reduced by "fee"
     assert freqtrade.get_real_amount(trade, limit_buy_order) == amount - 0.004
     assert log_has('Applying fee on amount for Trade(id=None, pair=LTC/ETH, amount=8.00000000, '
@@ -1480,7 +1510,7 @@ def test_get_real_amount_invalid_order(default_conf, trades_for_order, buy_order
         open_rate=0.245441,
         open_order_id="123456"
     )
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
     # Amount does not change
     assert freqtrade.get_real_amount(trade, limit_buy_order) == amount
 
@@ -1505,6 +1535,31 @@ def test_get_real_amount_invalid(default_conf, trades_for_order, buy_order_fee,
         open_rate=0.245441,
         open_order_id="123456"
     )
-    freqtrade = FreqtradeBot(default_conf, create_engine('sqlite://'))
+    freqtrade = FreqtradeBot(default_conf)
     # Amount does not change
     assert freqtrade.get_real_amount(trade, buy_order_fee) == amount
+
+
+def test_get_real_amount_open_trade(default_conf, mocker):
+    """
+    Test get_real_amount condition trade.fee_open == 0 or order['status'] == 'open'
+    """
+    patch_get_signal(mocker)
+    patch_RPCManager(mocker)
+    patch_coinmarketcap(mocker)
+    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    amount = 12345
+    trade = Trade(
+        pair='LTC/ETH',
+        amount=amount,
+        exchange='binance',
+        open_rate=0.245441,
+        open_order_id="123456"
+    )
+    order = {
+        'id': 'mocked_order',
+        'amount': amount,
+        'status': 'open',
+    }
+    freqtrade = FreqtradeBot(default_conf)
+    assert freqtrade.get_real_amount(trade, order) == amount

freqtrade/tests/test_main.py

@@ -3,11 +3,16 @@ Unit test file for main.py
 """
 
 import logging
+from copy import deepcopy
 from unittest.mock import MagicMock
 
 import pytest
 
-from freqtrade.main import main, set_loggers
+from freqtrade import OperationalException
+from freqtrade.arguments import Arguments
+from freqtrade.freqtradebot import FreqtradeBot
+from freqtrade.main import main, set_loggers, reconfigure
+from freqtrade.state import State
 from freqtrade.tests.conftest import log_has
 
 
@@ -60,7 +65,7 @@ def test_set_loggers() -> None:
     assert value2 is logging.INFO
 
 
-def test_main(mocker, caplog) -> None:
+def test_main_fatal_exception(mocker, default_conf, caplog) -> None:
     """
     Test main() function
     In this test we are skipping the while True loop by throwing an exception.
@@ -68,26 +73,140 @@ def test_main(mocker, caplog) -> None:
     mocker.patch.multiple(
         'freqtrade.freqtradebot.FreqtradeBot',
         _init_modules=MagicMock(),
-        worker=MagicMock(
+        worker=MagicMock(side_effect=Exception),
-            side_effect=KeyboardInterrupt
+        cleanup=MagicMock(),
-        ),
-        clean=MagicMock(),
     )
+    mocker.patch(
+        'freqtrade.configuration.Configuration._load_config_file',
+        lambda *args, **kwargs: default_conf
+    )
+    mocker.patch('freqtrade.freqtradebot.CryptoToFiatConverter', MagicMock())
+    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:
+    """
+    Test main() function
+    In this test we are skipping the while True loop by throwing an exception.
+    """
+    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.CryptoToFiatConverter', MagicMock())
+    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:
+    """
+    Test main() function
+    In this test we are skipping the while True loop by throwing an exception.
+    """
+    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.CryptoToFiatConverter', MagicMock())
+    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:
+    """
+    Test main() function
+    In this test we are skipping the while True loop by throwing an exception.
+    """
+    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.CryptoToFiatConverter', MagicMock())
+    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:
+    """ Test recreate() function """
+    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.CryptoToFiatConverter', MagicMock())
+    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

@@ -39,7 +39,7 @@ 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) -> None:

freqtrade/tests/test_persistence.py

@@ -1,9 +1,11 @@
 # pragma pylint: disable=missing-docstring, C0103
-import os
+from copy import deepcopy
+from unittest.mock import MagicMock
 
 import pytest
 from sqlalchemy import create_engine
 
+from freqtrade import constants, OperationalException
 from freqtrade.persistence import Trade, init, clean_dry_run_db
 
 
@@ -21,77 +23,54 @@ def test_init_create_session(default_conf, mocker):
     assert 'Session' in type(Trade.session).__name__
 
 
-def test_init_dry_run_db(default_conf, mocker):
+def test_init_custom_db_url(default_conf, mocker):
-    default_conf.update({'dry_run_db': True})
+    conf = deepcopy(default_conf)
-    mocker.patch.dict('freqtrade.persistence._CONF', default_conf)
 
-    # First, protect the existing 'tradesv3.dry_run.sqlite' (Do not delete user data)
+    # Update path to a value other than default, but still in-memory
-    dry_run_db = 'tradesv3.dry_run.sqlite'
+    conf.update({'db_url': 'sqlite:///tmp/freqtrade2_test.sqlite'})
-    dry_run_db_swp = dry_run_db + '.swp'
+    create_engine_mock = mocker.patch('freqtrade.persistence.create_engine', MagicMock())
+    mocker.patch.dict('freqtrade.persistence._CONF', conf)
 
-    if os.path.isfile(dry_run_db):
+    init(conf)
-        os.rename(dry_run_db, dry_run_db_swp)
+    assert create_engine_mock.call_count == 1
-
+    assert create_engine_mock.mock_calls[0][1][0] == 'sqlite:///tmp/freqtrade2_test.sqlite'
-    # 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)
 
 
-def test_init_dry_run_without_db(default_conf, mocker):
+def test_init_invalid_db_url(default_conf, mocker):
-    default_conf.update({'dry_run_db': False})
+    conf = deepcopy(default_conf)
-    mocker.patch.dict('freqtrade.persistence._CONF', default_conf)
 
-    # First, protect the existing 'tradesv3.dry_run.sqlite' (Do not delete user data)
+    # Update path to a value other than default, but still in-memory
-    dry_run_db = 'tradesv3.dry_run.sqlite'
+    conf.update({'db_url': 'unknown:///some.url'})
-    dry_run_db_swp = dry_run_db + '.swp'
+    mocker.patch.dict('freqtrade.persistence._CONF', conf)
 
-    if os.path.isfile(dry_run_db):
+    with pytest.raises(OperationalException, match=r'.*no valid database URL*'):
-        os.rename(dry_run_db, dry_run_db_swp)
+        init(conf)
-
-    # Check if the new tradesv3.dry_run.sqlite was created
-    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})
+    conf = deepcopy(default_conf)
-    mocker.patch.dict('freqtrade.persistence._CONF', default_conf)
+    conf.update({'dry_run': False})
+    conf.update({'db_url': constants.DEFAULT_DB_PROD_URL})
 
-    # First, protect the existing 'tradesv3.sqlite' (Do not delete user data)
+    create_engine_mock = mocker.patch('freqtrade.persistence.create_engine', MagicMock())
-    prod_db = 'tradesv3.sqlite'
+    mocker.patch.dict('freqtrade.persistence._CONF', conf)
-    prod_db_swp = prod_db + '.swp'
 
-    if os.path.isfile(prod_db):
+    init(conf)
-        os.rename(prod_db, prod_db_swp)
+    assert create_engine_mock.call_count == 1
+    assert create_engine_mock.mock_calls[0][1][0] == 'sqlite:///tradesv3.sqlite'
 
-    # Check if the new tradesv3.sqlite was created
-    init(default_conf)
-    assert os.path.isfile(prod_db) is True
 
-    # Delete the file made for this unitest and rollback to the previous tradesv3.sqlite file
+def test_init_dryrun_db(default_conf, mocker):
+    conf = deepcopy(default_conf)
+    conf.update({'dry_run': True})
+    conf.update({'db_url': constants.DEFAULT_DB_DRYRUN_URL})
 
-    # 1. Delete file from the test
+    create_engine_mock = mocker.patch('freqtrade.persistence.create_engine', MagicMock())
-    if os.path.isfile(prod_db):
+    mocker.patch.dict('freqtrade.persistence._CONF', conf)
-        os.remove(prod_db)
 
-    # Rollback to the initial 'tradesv3.sqlite' file
+    init(conf)
-    if os.path.isfile(prod_db_swp):
+    assert create_engine_mock.call_count == 1
-        os.rename(prod_db_swp, prod_db)
+    assert create_engine_mock.mock_calls[0][1][0] == 'sqlite://'
 
 
 @pytest.mark.usefixtures("init_persistence")
@@ -328,7 +307,7 @@ def test_calc_profit_percent(limit_buy_order, limit_sell_order, fee):
 
 
 def test_clean_dry_run_db(default_conf, fee):
-    init(default_conf, create_engine('sqlite://'))
+    init(default_conf)
 
     # Simulate dry_run entries
     trade = Trade(
@@ -377,7 +356,7 @@ def test_clean_dry_run_db(default_conf, fee):
     assert len(Trade.query.filter(Trade.open_order_id.isnot(None)).all()) == 1
 
 
-def test_migrate_old(default_conf, fee):
+def test_migrate_old(mocker, default_conf, fee):
     """
     Test Database migration(starting with old pairformat)
     """
@@ -409,11 +388,13 @@ def test_migrate_old(default_conf, fee):
                                      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, engine)
+    init(default_conf)
 
     assert len(Trade.query.filter(Trade.id == 1).all()) == 1
     trade = Trade.query.filter(Trade.id == 1).first()
@@ -428,7 +409,7 @@ def test_migrate_old(default_conf, fee):
     assert trade.exchange == "bittrex"
 
 
-def test_migrate_new(default_conf, fee):
+def test_migrate_new(mocker, default_conf, fee):
     """
     Test Database migration (starting with new pairformat)
     """
@@ -462,11 +443,13 @@ def test_migrate_new(default_conf, fee):
                                      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, engine)
+    init(default_conf)
 
     assert len(Trade.query.filter(Trade.id == 1).all()) == 1
     trade = Trade.query.filter(Trade.id == 1).first()

install_ta-lib.sh

@@ -1,5 +1,4 @@
 if [ ! -f "ta-lib/CHANGELOG.TXT" ]; then
-  curl -O -L http://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz
   tar zxvf ta-lib-0.4.0-src.tar.gz
   cd ta-lib && ./configure && make && sudo make install && cd ..
 else

requirements.txt

@@ -1,4 +1,4 @@
-ccxt==1.14.121
+ccxt==1.14.177
 SQLAlchemy==1.2.8
 python-telegram-bot==10.1.0
 arrow==0.12.1
@@ -10,14 +10,14 @@ pandas==0.23.0
 scikit-learn==0.19.1
 scipy==1.1.0
 jsonschema==2.6.0
-numpy==1.14.3
+numpy==1.14.4
 TA-Lib==0.4.17
-pytest==3.6.0
+pytest==3.6.1
 pytest-mock==1.10.0
 pytest-cov==2.5.1
 hyperopt==0.1
 # do not upgrade networkx before this is fixed https://github.com/hyperopt/hyperopt/issues/325
-networkx==1.11
+networkx==1.11 # pyup: ignore
 tabulate==0.8.2
 coinmarketcap==5.0.3
 

scripts/download_backtest_data.py

@@ -8,147 +8,30 @@ import arrow
 
 from freqtrade import (exchange, arguments, misc)
 
-DEFAULT_DL_PATH = 'freqtrade/tests/testdata'
+DEFAULT_DL_PATH = 'user_data/data'
 
 arguments = arguments.Arguments(sys.argv[1:], 'download utility')
 arguments.testdata_dl_options()
 args = arguments.parse_args()
 
-TICKER_INTERVALS = ['1m', '5m', '1h', '4h']
+timeframes = args.timeframes
-PAIRS = [
-    "ETH/BTC",
-    "LTC/BTC",
-    "BNB/BTC",
-    "NEO/BTC",
-    "GAS/BTC",
-    "MCO/BTC",
-    "WTC/BTC",
-    "QTUM/BTC",
-    "OMG/BTC",
-    "ZRX/BTC",
-    "STRAT/BTC",
-    "SNGLS/BTC",
-    "BQX/BTC",
-    "KNC/BTC",
-    "FUN/BTC",
-    "SNM/BTC",
-    "LINK/BTC",
-    "XVG/BTC",
-    "SALT/BTC",
-    "IOTA/BTC",
-    "MDA/BTC",
-    "MTL/BTC",
-    "SUB/BTC",
-    "EOS/BTC",
-    "SNT/BTC",
-    "ETC/BTC",
-    "MTH/BTC",
-    "ENG/BTC",
-    "DNT/BTC",
-    "BNT/BTC",
-    "AST/BTC",
-    "DASH/BTC",
-    "ICN/BTC",
-    "OAX/BTC",
-    "BTG/BTC",
-    "EVX/BTC",
-    "REQ/BTC",
-    "LRC/BTC",
-    "VIB/BTC",
-    "HSR/BTC",
-    "TRX/BTC",
-    "POWR/BTC",
-    "ARK/BTC",
-    "XRP/BTC",
-    "MOD/BTC",
-    "ENJ/BTC",
-    "STORJ/BTC",
-    "VEN/BTC",
-    "KMD/BTC",
-    "RCN/BTC",
-    "NULS/BTC",
-    "RDN/BTC",
-    "XMR/BTC",
-    "DLT/BTC",
-    "AMB/BTC",
-    "BAT/BTC",
-    "ZEC/BTC",
-    "BCPT/BTC",
-    "ARN/BTC",
-    "GVT/BTC",
-    "CDT/BTC",
-    "GXS/BTC",
-    "POE/BTC",
-    "QSP/BTC",
-    "BTS/BTC",
-    "XZC/BTC",
-    "LSK/BTC",
-    "TNT/BTC",
-    "FUEL/BTC",
-    "MANA/BTC",
-    "BCD/BTC",
-    "DGD/BTC",
-    "ADX/BTC",
-    "ADA/BTC",
-    "PPT/BTC",
-    "CMT/BTC",
-    "XLM/BTC",
-    "CND/BTC",
-    "LEND/BTC",
-    "WABI/BTC",
-    "TNB/BTC",
-    "WAVES/BTC",
-    "ICX/BTC",
-    "GTO/BTC",
-    "OST/BTC",
-    "ELF/BTC",
-    "AION/BTC",
-    "NEBL/BTC",
-    "BRD/BTC",
-    "EDO/BTC",
-    "WINGS/BTC",
-    "NAV/BTC",
-    "LUN/BTC",
-    "TRIG/BTC",
-    "APPC/BTC",
-    "VIBE/BTC",
-    "RLC/BTC",
-    "INS/BTC",
-    "PIVX/BTC",
-    "IOST/BTC",
-    "CHAT/BTC",
-    "STEEM/BTC",
-    "VIA/BTC",
-    "BLZ/BTC",
-    "AE/BTC",
-    "RPX/BTC",
-    "NCASH/BTC",
-    "POA/BTC",
-    "ZIL/BTC",
-    "ONT/BTC",
-    "STORM/BTC",
-    "XEM/BTC",
-    "WAN/BTC",
-    "QLC/BTC",
-    "SYS/BTC",
-    "WPR/BTC",
-    "GRS/BTC",
-    "CLOAK/BTC",
-    "GNT/BTC",
-    "LOOM/BTC",
-    "BCN/BTC",
-    "REP/BTC"
-]
 
-if args.pairs_file:
+dl_path = os.path.join(DEFAULT_DL_PATH, args.exchange)
-    with open(args.pairs_file) as file:
+if args.export:
-        PAIRS = json.load(file)
-PAIRS = list(set(PAIRS))
-
-dl_path = DEFAULT_DL_PATH
-if args.export and os.path.exists(args.export):
     dl_path = args.export
 
+if not os.path.isdir(dl_path):
+    sys.exit(f'Directory {dl_path} does not exist.')
+
+pairs_file = args.pairs_file if args.pairs_file else os.path.join(dl_path, 'pairs.json')
+if not os.path.isfile(pairs_file):
+    sys.exit(f'No pairs file found with path {pairs_file}.')
+
+with open(pairs_file) as file:
+    PAIRS = list(set(json.load(file)))
+
+PAIRS.sort()
+
 since_time = None
 if args.days:
     since_time = arrow.utcnow().shift(days=-args.days).timestamp * 1000
@@ -159,9 +42,16 @@ print(f'About to download pairs: {PAIRS} to {dl_path}')
 exchange._API = exchange.init_ccxt({'key': '',
                                     'secret': '',
                                     'name': args.exchange})
+pairs_not_available = []
+# Make sure API markets is initialized
+exchange._API.load_markets()
 
 for pair in PAIRS:
-    for tick_interval in TICKER_INTERVALS:
+    if pair not in exchange._API.markets:
+        pairs_not_available.append(pair)
+        print(f"skipping pair {pair}")
+        continue
+    for tick_interval in timeframes:
         print(f'downloading pair {pair}, interval {tick_interval}')
 
         data = exchange.get_ticker_history(pair, tick_interval, since_ms=since_time)
@@ -177,3 +67,7 @@ for pair in PAIRS:
         pair_print = pair.replace('/', '_')
         filename = f'{pair_print}-{tick_interval}.json'
         misc.file_dump_json(os.path.join(dl_path, filename), data)
+
+
+if pairs_not_available:
+    print(f"Pairs [{','.join(pairs_not_available)}] not availble.")

scripts/plot_profit.py

@@ -8,9 +8,12 @@ Mandatory Cli parameters:
 Optional Cli parameters
 -c / --config: specify configuration file
 -s / --strategy: strategy to use
---timerange: specify what timerange of data to use.
+-d / --datadir: path to pair backtest data
+--timerange: specify what timerange of data to use
+--export-filename: Specify where the backtest export is located.
 """
 import logging
+import os
 import sys
 import json
 from argparse import Namespace
@@ -90,7 +93,18 @@ def plot_profit(args: Namespace) -> None:
             'Impossible to load the strategy. Please check the file "user_data/strategies/%s.py"',
             config.get('strategy')
         )
-        exit()
+        exit(1)
+
+    # Load the profits results
+    try:
+        filename = args.exportfilename
+        with open(filename) as file:
+            data = json.load(file)
+    except FileNotFoundError:
+        logger.critical(
+            'File "backtest-result.json" not found. This script require backtesting '
+            'results to run.\nPlease run a backtesting with the parameter --export.')
+        exit(1)
 
     # Take pairs from the cli otherwise switch to the pair in the config file
     if args.pair:
@@ -140,18 +154,7 @@ def plot_profit(args: Namespace) -> None:
         num += 1
     avgclose /= num
 
-    # Load the profits results
+    # make an profits-growth array
-    # And make an profits-growth array
-
-    try:
-        filename = 'backtest-result.json'
-        with open(filename) as file:
-            data = json.load(file)
-    except FileNotFoundError:
-        logger.critical('File "backtest-result.json" not found. This script require backtesting '
-                        'results to run.\nPlease run a backtesting with the parameter --export.')
-        exit(0)
-
     pg = make_profit_array(data, num_iterations, min_date, tick_interval, filter_pairs)
 
     #
@@ -184,7 +187,7 @@ def plot_profit(args: Namespace) -> None:
         )
         fig.append_trace(pair_profit, 3, 1)
 
-    plot(fig, filename='freqtrade-profit-plot.html')
+    plot(fig, filename=os.path.join('user_data', 'freqtrade-profit-plot.html'))
 
 
 def define_index(min_date: int, max_date: int, interval: str) -> int:

setup.cfg

@@ -5,3 +5,6 @@ max-complexity = 12
 
 [mypy]
 ignore_missing_imports = True
+
+[mypy-freqtrade.tests.*]
+ignore_errors = True

setup.py

@@ -12,7 +12,7 @@ from freqtrade import __version__
 setup(name='freqtrade',
       version=__version__,
       description='Simple High Frequency Trading Bot for crypto currencies',
-      url='https://github.com/gcarq/freqtrade',
+      url='https://github.com/freqtrade/freqtrade',
       author='gcarq and contributors',
       author_email='michael.egger@tsn.at',
       license='GPLv3',

user_data/strategies/test_strategy.py

@@ -14,7 +14,7 @@ import numpy # noqa
 class TestStrategy(IStrategy):
     """
     This is a test strategy to inspire you.
-    More information in https://github.com/gcarq/freqtrade/blob/develop/docs/bot-optimization.md
+    More information in https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-optimization.md
 
     You can:
     - Rename the class name (Do not forget to update class_name)