Merge pull request #2070 from freqtrade/new_release

New release 2019.7

.pyup.yml

@@ -11,7 +11,10 @@ update: all
 # allowed: True, False
 pin: True
 
-schedule: "every day"
+# update schedule
+# default: empty
+# allowed: "every day", "every week", ..
+schedule: "every week"
 
 
 search: False
@@ -22,7 +25,7 @@ requirements:
   - requirements.txt
   - requirements-dev.txt
   - requirements-plot.txt
-  - requirements-pi.txt
+  - requirements-common.txt
 
 
 # configure the branch prefix the bot is using

.travis.yml

@@ -19,7 +19,6 @@ addons:
 install:
 - cd build_helpers && ./install_ta-lib.sh; cd ..
 - export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH
-- pip install --upgrade pytest-random-order
 - pip install -r requirements-dev.txt
 - pip install -e .
 jobs:
@@ -27,17 +26,17 @@ jobs:
   include:
     - stage: tests
       script:
-      - pytest --cov=freqtrade --cov-config=.coveragerc freqtrade/tests/
+      - pytest --random-order --cov=freqtrade --cov-config=.coveragerc freqtrade/tests/
       # Allow failure for coveralls
       - coveralls || true
       name: pytest
     - script:
       - cp config.json.example config.json
-      - python freqtrade --datadir freqtrade/tests/testdata backtesting
+      - freqtrade --datadir freqtrade/tests/testdata backtesting
       name: backtest
     - script:
       - cp config.json.example config.json
-      - python freqtrade --datadir freqtrade/tests/testdata hyperopt -e 5
+      - freqtrade --datadir freqtrade/tests/testdata hyperopt -e 5
       name: hyperopt
     - script: flake8 freqtrade scripts
       name: flake8
@@ -56,4 +55,4 @@ notifications:
 cache:
   pip: True
   directories:
-    - /usr/local/lib
+    - /usr/local/lib/

CONTRIBUTING.md

@@ -11,7 +11,7 @@ Few pointers for contributions:
 - Create your PR against the `develop` branch, not `master`.
 - New features need to contain unit tests and must be PEP8 conformant (max-line-length = 100).
 
-If you are unsure, discuss the feature on our [Slack](https://join.slack.com/t/highfrequencybot/shared_invite/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE)
+If you are unsure, discuss the feature on our [Slack](https://join.slack.com/t/highfrequencybot/shared_invite/enQtNjU5ODcwNjI1MDU3LWEyODBiNzkzNzcyNzU0MWYyYzE5NjIyOTQxMzBmMGUxOTIzM2YyN2Y4NWY1YTEwZDgwYTRmMzE2NmM5ZmY2MTg)
 or in a [issue](https://github.com/freqtrade/freqtrade/issues) before a PR.
 
 ## Getting started

Dockerfile

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

Dockerfile.pi

@@ -27,9 +27,9 @@ RUN wget https://github.com/jjhelmus/berryconda/releases/download/v2.0.0/Berryco
  && rm Berryconda3-2.0.0-Linux-armv7l.sh
 
 # Install dependencies
-COPY requirements-pi.txt /freqtrade/
+COPY requirements-common.txt /freqtrade/
 RUN ~/berryconda3/bin/conda install -y numpy pandas scipy \
- && ~/berryconda3/bin/pip install -r requirements-pi.txt --no-cache-dir
+ && ~/berryconda3/bin/pip install -r requirements-common.txt --no-cache-dir
 
 # Install and execute
 COPY . /freqtrade/

Dockerfile.technical

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

README.md

@@ -129,7 +129,6 @@ The project is currently setup in two main branches:
 - `master` - This branch contains the latest stable release. The bot 'should' be stable on this branch, and is generally well tested.
 - `feat/*` - These are feature branches, which are being worked on heavily. Please don't use these unless you want to test a specific feature.
 
-
 ## A note on Binance
 
 For Binance, please add `"BNB/<STAKE>"` to your blacklist to avoid issues.
@@ -142,7 +141,7 @@ Accounts having BNB accounts use this to pay for fees - if your first trade happ
 For any questions not covered by the documentation or for further
 information about the bot, we encourage you to join our slack channel.
 
-- [Click here to join Slack channel](https://join.slack.com/t/highfrequencybot/shared_invite/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE).
+- [Click here to join Slack channel](https://join.slack.com/t/highfrequencybot/shared_invite/enQtNjU5ODcwNjI1MDU3LWEyODBiNzkzNzcyNzU0MWYyYzE5NjIyOTQxMzBmMGUxOTIzM2YyN2Y4NWY1YTEwZDgwYTRmMzE2NmM5ZmY2MTg).
 
 ### [Bugs / Issues](https://github.com/freqtrade/freqtrade/issues?q=is%3Aissue)
 
@@ -173,7 +172,7 @@ to understand the requirements before sending your pull-requests.
 Coding is not a neccessity to contribute - maybe start with improving our documentation?
 Issues labeled [good first issue](https://github.com/freqtrade/freqtrade/labels/good%20first%20issue) can be good first contributions, and will help get you familiar with the codebase.
 
-**Note** before starting any major new feature work, *please open an issue describing what you are planning to do* or talk to us on [Slack](https://join.slack.com/t/highfrequencybot/shared_invite/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE). This will ensure that interested parties can give valuable feedback on the feature, and let others know that you are working on it.
+**Note** before starting any major new feature work, *please open an issue describing what you are planning to do* or talk to us on [Slack](https://join.slack.com/t/highfrequencybot/shared_invite/enQtNjU5ODcwNjI1MDU3LWEyODBiNzkzNzcyNzU0MWYyYzE5NjIyOTQxMzBmMGUxOTIzM2YyN2Y4NWY1YTEwZDgwYTRmMzE2NmM5ZmY2MTg). This will ensure that interested parties can give valuable feedback on the feature, and let others know that you are working on it.
 
 **Important:** Always create your PR against the `develop` branch, not `master`.
 

bin/freqtrade

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

config_binance.json.example

@@ -11,8 +11,8 @@
         "sell": 30
     },
     "bid_strategy": {
-        "ask_last_balance": 0.0,
         "use_order_book": false,
+        "ask_last_balance": 0.0,
         "order_book_top": 1,
         "check_depth_of_market": {
             "enabled": false,

config_full.json.example

@@ -22,8 +22,8 @@
         "sell": 30
     },
     "bid_strategy": {
-        "ask_last_balance": 0.0,
         "use_order_book": false,
+        "ask_last_balance": 0.0,
         "order_book_top": 1,
         "check_depth_of_market": {
             "enabled": false,
@@ -56,8 +56,10 @@
     },
     "exchange": {
         "name": "bittrex",
+        "sandbox": false,
         "key": "your_exchange_key",
         "secret": "your_exchange_secret",
+        "password": "",
         "ccxt_config": {"enableRateLimit": true},
         "ccxt_async_config": {
             "enableRateLimit": false,
@@ -107,6 +109,13 @@
         "token": "your_telegram_token",
         "chat_id": "your_telegram_chat_id"
     },
+    "api_server": {
+        "enabled": false,
+        "listen_ip_address": "127.0.0.1",
+        "listen_port": 8080,
+        "username": "freqtrader",
+        "password": "SuperSecurePassword"
+    },
     "db_url": "sqlite:///tradesv3.sqlite",
     "initial_state": "running",
     "forcebuy_enable": false,
@@ -114,5 +123,5 @@
         "process_throttle_secs": 5
     },
     "strategy": "DefaultStrategy",
-    "strategy_path": "/some/folder/"
+    "strategy_path": "user_data/strategies/"
 }

config_kraken.json.example

@@ -5,15 +5,14 @@
     "fiat_display_currency": "EUR",
     "ticker_interval" : "5m",
     "dry_run": true,
-    "db_url": "sqlite:///tradesv3.dryrun.sqlite",
     "trailing_stop": false,
     "unfilledtimeout": {
         "buy": 10,
         "sell": 30
     },
     "bid_strategy": {
-        "ask_last_balance": 0.0,
         "use_order_book": false,
+        "ask_last_balance": 0.0,
         "order_book_top": 1,
         "check_depth_of_market": {
             "enabled": false,
@@ -60,8 +59,8 @@
     },
     "telegram": {
         "enabled": false,
-        "token": "",
-        "chat_id": ""
+        "token": "your_telegram_token",
+        "chat_id": "your_telegram_chat_id"
     },
     "initial_state": "running",
     "forcebuy_enable": false,

docs/backtesting.md

@@ -13,7 +13,7 @@ Backtesting will use the crypto-currencies (pair) from your config file
 and load static tickers located in
 [/freqtrade/tests/testdata](https://github.com/freqtrade/freqtrade/tree/develop/freqtrade/tests/testdata).
 If the 5 min and 1 min ticker for the crypto-currencies to test is not
-already in the `testdata` folder, backtesting will download them
+already in the `testdata` directory, backtesting will download them
 automatically. Testdata files will not be updated until you specify it.
 
 The result of backtesting will confirm you if your bot has better odds of making a profit than a loss.
@@ -24,37 +24,37 @@ The backtesting is very easy with freqtrade.
 #### With 5 min tickers (Per default)
 
 ```bash
-python3 freqtrade backtesting
+freqtrade backtesting
 ```
 
 #### With 1 min tickers
 
 ```bash
-python3 freqtrade backtesting --ticker-interval 1m
+freqtrade backtesting --ticker-interval 1m
 ```
 
 #### Update cached pairs with the latest data
 
 ```bash
-python3 freqtrade backtesting --refresh-pairs-cached
+freqtrade backtesting --refresh-pairs-cached
 ```
 
 #### With live data (do not alter your testdata files)
 
 ```bash
-python3 freqtrade backtesting --live
+freqtrade backtesting --live
 ```
 
 #### Using a different on-disk ticker-data source
 
 ```bash
-python3 freqtrade backtesting --datadir freqtrade/tests/testdata-20180101
+freqtrade backtesting --datadir freqtrade/tests/testdata-20180101
 ```
 
 #### With a (custom) strategy file
 
 ```bash
-python3 freqtrade -s TestStrategy backtesting
+freqtrade -s TestStrategy backtesting
 ```
 
 Where `-s TestStrategy` refers to the class name within the strategy file `test_strategy.py` found in the `freqtrade/user_data/strategies` directory
@@ -62,15 +62,15 @@ Where `-s TestStrategy` refers to the class name within the strategy file `test_
 #### Exporting trades to file
 
 ```bash
-python3 freqtrade backtesting --export trades
+freqtrade backtesting --export trades
 ```
 
-The exported trades can be used for [further analysis](#further-backtest-result-analysis), or can be used by the plotting script `plot_dataframe.py` in the scripts folder.
+The exported trades can be used for [further analysis](#further-backtest-result-analysis), or can be used by the plotting script `plot_dataframe.py` in the scripts directory.
 
 #### Exporting trades to file specifying a custom filename
 
 ```bash
-python3 freqtrade backtesting --export trades --export-filename=backtest_teststrategy.json
+freqtrade backtesting --export trades --export-filename=backtest_teststrategy.json
 ```
 
 #### Running backtest with smaller testset
@@ -81,7 +81,7 @@ you want to use. The last N ticks/timeframes will be used.
 Example:
 
 ```bash
-python3 freqtrade backtesting --timerange=-200
+freqtrade backtesting --timerange=-200
 ```
 
 #### Advanced use of timerange
@@ -107,7 +107,7 @@ To download new set of backtesting ticker data, you can use a download script.
 
 If you are using Binance for example:
 
-- create a folder `user_data/data/binance` and copy `pairs.json` in that folder.
+- create a directory `user_data/data/binance` and copy `pairs.json` in that directory.
 - update the `pairs.json` to contain the currency pairs you are interested in.
 
 ```bash
@@ -123,11 +123,12 @@ python scripts/download_backtest_data.py --exchange binance
 
 This will download ticker data for all the currency pairs you defined in `pairs.json`.
 
-- To use a different folder than the exchange specific default, use `--export user_data/data/some_directory`.
+- To use a different directory than the exchange specific default, use `--datadir user_data/data/some_directory`.
 - To change the exchange used to download the tickers, use `--exchange`. Default is `bittrex`.
-- To use `pairs.json` from some other folder, use `--pairs-file some_other_dir/pairs.json`.
+- To use `pairs.json` from some other directory, use `--pairs-file some_other_dir/pairs.json`.
 - To download ticker data for only 10 days, use `--days 10`.
 - Use `--timeframes` to specify which tickers to download. Default is `--timeframes 1m 5m` which will download 1-minute and 5-minute tickers.
+- To use exchange, timeframe and list of pairs as defined in your configuration file, use the `-c/--config` option. With this, the script uses the whitelist defined in the config as the list of currency pairs to download data for and does not require the pairs.json file. You can combine `-c/--config` with other options.
 
 For help about backtesting usage, please refer to [Backtesting commands](#backtesting-commands).
 
@@ -220,24 +221,8 @@ strategies, your configuration, and the crypto-currency you have set up.
 ### Further backtest-result analysis
 
 To further analyze your backtest results, you can [export the trades](#exporting-trades-to-file).
-You can then load the trades to perform further analysis.
+You can then load the trades to perform further analysis as shown in our [data analysis](data-analysis.md#backtesting) backtesting section.
 
-A good way for this is using Jupyter (notebook or lab) - which provides an interactive environment to analyze the data.
-
-Freqtrade provides an easy to load the backtest results, which is `load_backtest_data` - and takes a path to the backtest-results file.
-
-``` python
-from freqtrade.data.btanalysis import load_backtest_data
-df = load_backtest_data("user_data/backtest-result.json")
-
-# Show value-counts per pair
-df.groupby("pair")["sell_reason"].value_counts()
-
-```
-
-This will allow you to drill deeper into your backtest results, and perform analysis which would make the regular backtest-output unreadable.
-
-If you have some ideas for interesting / helpful backtest data analysis ideas, please submit a PR so the community can benefit from it.
 
 ## Backtesting multiple strategies
 
@@ -246,7 +231,7 @@ To backtest multiple strategies, a list of Strategies can be provided.
 This is limited to 1 ticker-interval per run, however, data is only loaded once from disk so if you have multiple
 strategies you'd like to compare, this should give a nice runtime boost.
 
-All listed Strategies need to be in the same folder.
+All listed Strategies need to be in the same directory.
 
 ``` bash
 freqtrade backtesting --timerange 20180401-20180410 --ticker-interval 5m --strategy-list Strategy001 Strategy002 --export trades

docs/bot-usage.md

@@ -2,13 +2,16 @@
 
 This page explains the different parameters of the bot and how to run it.
 
+!Note:
+    If you've used `setup.sh`, don't forget to activate your virtual environment (`source .env/bin/activate`) before running freqtrade commands.
+
 
 ## Bot commands
 
 ```
 usage: freqtrade [-h] [-v] [--logfile FILE] [--version] [-c PATH] [-d PATH]
-                 [-s NAME] [--strategy-path PATH] [--dynamic-whitelist [INT]]
-                 [--db-url PATH] [--sd-notify]
+                 [-s NAME] [--strategy-path PATH] [--db-url PATH]
+                 [--sd-notify]
                  {backtesting,edge,hyperopt} ...
 
 Free, open source crypto trading bot
@@ -23,19 +26,17 @@ optional arguments:
   -h, --help            show this help message and exit
   -v, --verbose         Verbose mode (-vv for more, -vvv to get all messages).
   --logfile FILE        Log to the file specified
-  --version             show program's version number and exit
+  -V, --version         show program's version number and exit
   -c PATH, --config PATH
                         Specify configuration file (default: None). Multiple
-                        --config options may be used.
+                        --config options may be used. Can be set to '-' to
+                        read config from stdin.
   -d PATH, --datadir PATH
                         Path to backtest data.
   -s NAME, --strategy NAME
                         Specify strategy class name (default:
                         DefaultStrategy).
   --strategy-path PATH  Specify additional strategy lookup path.
-  --dynamic-whitelist [INT]
-                        Dynamically generate and update whitelist based on 24h
-                        BaseVolume (default: 20). DEPRECATED.
   --db-url PATH         Override trades database URL, this is useful if
                         dry_run is enabled or in custom deployments (default:
                         None).
@@ -48,7 +49,7 @@ The bot allows you to select which configuration file you want to use. Per
 default, the bot will load the file `./config.json`
 
 ```bash
-python3 freqtrade -c path/far/far/away/config.json
+freqtrade -c path/far/far/away/config.json
 ```
 
 ### How to use multiple configuration files?
@@ -64,13 +65,13 @@ empty key and secrete values while running in the Dry Mode (which does not actua
 require them):
 
 ```bash
-python3 freqtrade -c ./config.json
+freqtrade -c ./config.json
 ```
 
 and specify both configuration files when running in the normal Live Trade Mode:
 
 ```bash
-python3 freqtrade -c ./config.json -c path/to/secrets/keys.config.json
+freqtrade -c ./config.json -c path/to/secrets/keys.config.json
 ```
 
 This could help you hide your private Exchange key and Exchange secrete on you local machine
@@ -96,39 +97,28 @@ In `user_data/strategies` you have a file `my_awesome_strategy.py` which has
 a strategy class called `AwesomeStrategy` to load it:
 
 ```bash
-python3 freqtrade --strategy AwesomeStrategy
+freqtrade --strategy AwesomeStrategy
 ```
 
 If the bot does not find your strategy file, it will display in an error
 message the reason (File not found, or errors in your code).
 
 Learn more about strategy file in
-[optimize your bot](bot-optimization.md).
+[Strategy Customization](strategy-customization.md).
 
 ### How to use **--strategy-path**?
 
 This parameter allows you to add an additional strategy lookup path, which gets
-checked before the default locations (The passed path must be a folder!):
+checked before the default locations (The passed path must be a directory!):
 ```bash
-python3 freqtrade --strategy AwesomeStrategy --strategy-path /some/folder
+freqtrade --strategy AwesomeStrategy --strategy-path /some/directory
 ```
 
 #### How to install a strategy?
 
-This is very simple. Copy paste your strategy file into the folder
+This is very simple. Copy paste your strategy file into the directory
 `user_data/strategies` or use `--strategy-path`. And voila, the bot is ready to use it.
 
-### How to use **--dynamic-whitelist**?
-
-!!! danger "DEPRECATED"
-    This command line option is deprecated. Please move your configurations using it
-to the configurations that utilize the `StaticPairList` or `VolumePairList` methods set
-in the configuration file
-as outlined [here](configuration/#dynamic-pairlists)
-
-Description of this deprecated feature was moved to [here](deprecated.md).
-Please no longer use it.
-
 ### How to use **--db-url**?
 
 When you run the bot in Dry-run mode, per default no transactions are
@@ -137,7 +127,7 @@ using `--db-url`. This can also be used to specify a custom database
 in production mode. Example command:
 
 ```bash
-python3 freqtrade -c config.json --db-url sqlite:///tradesv3.dry_run.sqlite
+freqtrade -c config.json --db-url sqlite:///tradesv3.dry_run.sqlite
 ```
 
 ## Backtesting commands
@@ -146,9 +136,11 @@ Backtesting also uses the config specified via `-c/--config`.
 
 ```
 usage: freqtrade backtesting [-h] [-i TICKER_INTERVAL] [--timerange TIMERANGE]
-                             [--eps] [--dmmp] [-l] [-r]
-                             [--strategy-list STRATEGY_LIST [STRATEGY_LIST ...]]
-                             [--export EXPORT] [--export-filename PATH]
+                           [--max_open_trades MAX_OPEN_TRADES]
+                           [--stake_amount STAKE_AMOUNT] [-r] [--eps] [--dmmp]
+                           [-l]
+                           [--strategy-list STRATEGY_LIST [STRATEGY_LIST ...]]
+                           [--export EXPORT] [--export-filename PATH]
 
 optional arguments:
   -h, --help            show this help message and exit
@@ -156,6 +148,14 @@ optional arguments:
                         Specify ticker interval (1m, 5m, 30m, 1h, 1d).
   --timerange TIMERANGE
                         Specify what timerange of data to use.
+  --max_open_trades MAX_OPEN_TRADES
+                        Specify max_open_trades to use.
+  --stake_amount STAKE_AMOUNT
+                        Specify stake_amount.
+  -r, --refresh-pairs-cached
+                        Refresh the pairs files in tests/testdata with the
+                        latest data from the exchange. Use it if you want to
+                        run your optimization commands with up-to-date data.
   --eps, --enable-position-stacking
                         Allow buying the same pair multiple times (position
                         stacking).
@@ -164,10 +164,6 @@ optional arguments:
                         (same as setting `max_open_trades` to a very high
                         number).
   -l, --live            Use live data.
-  -r, --refresh-pairs-cached
-                        Refresh the pairs files in tests/testdata with the
-                        latest data from the exchange. Use it if you want to
-                        run your backtesting with up-to-date data.
   --strategy-list STRATEGY_LIST [STRATEGY_LIST ...]
                         Provide a commaseparated list of strategies to
                         backtest Please note that ticker-interval needs to be
@@ -188,7 +184,7 @@ optional arguments:
 ### How to use **--refresh-pairs-cached** parameter?
 
 The first time your run Backtesting, it will take the pairs you have
-set in your config file and download data from Bittrex.
+set in your config file and download data from the Exchange.
 
 If for any reason you want to update your data set, you use
 `--refresh-pairs-cached` to force Backtesting to update the data it has.
@@ -206,30 +202,66 @@ to find optimal parameter values for your stategy.
 
 ```
 usage: freqtrade hyperopt [-h] [-i TICKER_INTERVAL] [--timerange TIMERANGE]
-                          [--customhyperopt NAME] [--eps] [--dmmp] [-e INT]
+                          [--max_open_trades INT]
+                          [--stake_amount STAKE_AMOUNT] [-r]
+                          [--customhyperopt NAME] [--hyperopt-path PATH]
+                          [--eps] [-e INT]
                           [-s {all,buy,sell,roi,stoploss} [{all,buy,sell,roi,stoploss} ...]]
+                          [--dmmp] [--print-all] [-j JOBS]
+                          [--random-state INT] [--min-trades INT] [--continue]
+                          [--hyperopt-loss NAME]
 
 optional arguments:
   -h, --help            show this help message and exit
   -i TICKER_INTERVAL, --ticker-interval TICKER_INTERVAL
-                        Specify ticker interval (1m, 5m, 30m, 1h, 1d).
+                        Specify ticker interval (`1m`, `5m`, `30m`, `1h`,
+                        `1d`).
   --timerange TIMERANGE
                         Specify what timerange of data to use.
+  --max_open_trades INT
+                        Specify max_open_trades to use.
+  --stake_amount STAKE_AMOUNT
+                        Specify stake_amount.
+  -r, --refresh-pairs-cached
+                        Refresh the pairs files in tests/testdata with the
+                        latest data from the exchange. Use it if you want to
+                        run your optimization commands with up-to-date data.
   --customhyperopt NAME
                         Specify hyperopt class name (default:
-                        DefaultHyperOpts).
+                        `DefaultHyperOpts`).
+  --hyperopt-path PATH  Specify additional lookup path for Hyperopts and
+                        Hyperopt Loss functions.
   --eps, --enable-position-stacking
                         Allow buying the same pair multiple times (position
                         stacking).
+  -e INT, --epochs INT  Specify number of epochs (default: 100).
+  -s {all,buy,sell,roi,stoploss} [{all,buy,sell,roi,stoploss} ...], --spaces {all,buy,sell,roi,stoploss} [{all,buy,sell,roi,stoploss} ...]
+                        Specify which parameters to hyperopt. Space-separated
+                        list. Default: `all`.
   --dmmp, --disable-max-market-positions
                         Disable applying `max_open_trades` during backtest
                         (same as setting `max_open_trades` to a very high
                         number).
-  -e INT, --epochs INT  Specify number of epochs (default: 100).
-  -s {all,buy,sell,roi,stoploss} [{all,buy,sell,roi,stoploss} ...], --spaces {all,buy,sell,roi,stoploss} [{all,buy,sell,roi,stoploss} ...]
-                        Specify which parameters to hyperopt. Space separate
-                        list. Default: all.
-
+  --print-all           Print all results, not only the best ones.
+  -j JOBS, --job-workers JOBS
+                        The number of concurrently running jobs for
+                        hyperoptimization (hyperopt worker processes). If -1
+                        (default), all CPUs are used, for -2, all CPUs but one
+                        are used, etc. If 1 is given, no parallel computing
+                        code is used at all.
+  --random-state INT    Set random state to some positive integer for
+                        reproducible hyperopt results.
+  --min-trades INT      Set minimal desired number of trades for evaluations
+                        in the hyperopt optimization path (default: 1).
+  --continue            Continue hyperopt from previous runs. By default,
+                        temporary files will be removed and hyperopt will
+                        start from scratch.
+  --hyperopt-loss       NAME
+                        Specify the class name of the hyperopt loss function
+                        class (IHyperOptLoss). Different functions can
+                        generate completely different results, since the
+                        target for optimization is different. (default:
+                        `DefaultHyperOptLoss`).
 ```
 
 ## Edge commands
@@ -237,8 +269,10 @@ optional arguments:
 To know your trade expectacny and winrate against historical data, you can use Edge.
 
 ```
-usage: freqtrade edge [-h] [-i TICKER_INTERVAL] [--timerange TIMERANGE] [-r]
-                      [--stoplosses STOPLOSS_RANGE]
+usage: freqtrade edge [-h] [-i TICKER_INTERVAL] [--timerange TIMERANGE]
+                    [--max_open_trades MAX_OPEN_TRADES]
+                    [--stake_amount STAKE_AMOUNT] [-r]
+                    [--stoplosses STOPLOSS_RANGE]
 
 optional arguments:
   -h, --help            show this help message and exit
@@ -246,10 +280,14 @@ optional arguments:
                         Specify ticker interval (1m, 5m, 30m, 1h, 1d).
   --timerange TIMERANGE
                         Specify what timerange of data to use.
+  --max_open_trades MAX_OPEN_TRADES
+                        Specify max_open_trades to use.
+  --stake_amount STAKE_AMOUNT
+                        Specify stake_amount.
   -r, --refresh-pairs-cached
                         Refresh the pairs files in tests/testdata with the
                         latest data from the exchange. Use it if you want to
-                        run your edge with up-to-date data.
+                        run your optimization commands with up-to-date data.
   --stoplosses STOPLOSS_RANGE
                         Defines a range of stoploss against which edge will
                         assess the strategy the format is "min,max,step"
@@ -259,12 +297,7 @@ optional arguments:
 
 To understand edge and how to read the results, please read the [edge documentation](edge.md).
 
-## A parameter missing in the configuration?
-
-All parameters for `main.py`, `backtesting`, `hyperopt` are referenced
-in [misc.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/misc.py#L84)
-
 ## Next step
 
 The optimal strategy of the bot will change with time depending of the market trends. The next step is to
-[optimize your bot](bot-optimization.md).
+[Strategy Customization](strategy-customization.md).

docs/configuration.md

@@ -40,12 +40,12 @@ Mandatory Parameters are marked as **Required**.
 | `ask_strategy.order_book_max` | 0 | Bot will scan from the top min to max Order Book Asks searching for a profitable rate.
 | `order_types` | None | Configure order-types depending on the action (`"buy"`, `"sell"`, `"stoploss"`, `"stoploss_on_exchange"`). [More information below](#understand-order_types). [Strategy Override](#parameters-in-the-strategy).
 | `order_time_in_force` | None | Configure time in force for buy and sell orders. [More information below](#understand-order_time_in_force). [Strategy Override](#parameters-in-the-strategy).
-| `exchange.name` | bittrex | **Required.** Name of the exchange class to use. [List below](#user-content-what-values-for-exchangename).
+| `exchange.name` |  | **Required.** Name of the exchange class to use. [List below](#user-content-what-values-for-exchangename).
 | `exchange.sandbox` | false | Use the 'sandbox' version of the exchange, where the exchange provides a sandbox for risk-free integration. See [here](sandbox-testing.md) in more details.
-| `exchange.key` | key | API key to use for the exchange. Only required when you are in production mode.
-| `exchange.secret` | secret | API secret to use for the exchange. Only required when you are in production mode.
-| `exchange.pair_whitelist` | [] | List of currency to use by the bot. Can be overrided with `--dynamic-whitelist` param.
-| `exchange.pair_blacklist` | [] | List of currency the bot must avoid. Useful when using `--dynamic-whitelist` param.
+| `exchange.key` | '' | API key to use for the exchange. Only required when you are in production mode.
+| `exchange.secret` | '' | API secret to use for the exchange. Only required when you are in production mode.
+| `exchange.pair_whitelist` | [] | List of pairs to use by the bot for trading and to check for potential trades during backtesting. Can be overriden by dynamic pairlists (see [below](#dynamic-pairlists)).
+| `exchange.pair_blacklist` | [] | List of pairs the bot must absolutely avoid for trading and backtesting. Can be overriden by dynamic pairlists (see [below](#dynamic-pairlists)).
 | `exchange.ccxt_config` | None | Additional CCXT parameters passed to the regular ccxt instance. Parameters may differ from exchange to exchange and are documented in the [ccxt documentation](https://ccxt.readthedocs.io/en/latest/manual.html#instantiation)
 | `exchange.ccxt_async_config` | None | Additional CCXT parameters passed to the async ccxt instance. Parameters may differ from exchange to exchange  and are documented in the [ccxt documentation](https://ccxt.readthedocs.io/en/latest/manual.html#instantiation)
 | `exchange.markets_refresh_interval` | 60 | The interval in minutes in which markets are reloaded.
@@ -53,7 +53,7 @@ Mandatory Parameters are marked as **Required**.
 | `experimental.use_sell_signal` | false | Use your sell strategy in addition of the `minimal_roi`. [Strategy Override](#parameters-in-the-strategy).
 | `experimental.sell_profit_only` | false | Waits until you have made a positive profit before taking a sell decision. [Strategy Override](#parameters-in-the-strategy).
 | `experimental.ignore_roi_if_buy_signal` | false | Does not sell if the buy-signal is still active. Takes preference over `minimal_roi` and `use_sell_signal`. [Strategy Override](#parameters-in-the-strategy).
-| `pairlist.method` | StaticPairList | Use Static whitelist. [More information below](#dynamic-pairlists).
+| `pairlist.method` | StaticPairList | Use static or dynamic volume-based pairlist. [More information below](#dynamic-pairlists).
 | `pairlist.config` | None | Additional configuration for dynamic pairlists. [More information below](#dynamic-pairlists).
 | `telegram.enabled` | true | **Required.** Enable or not the usage of Telegram.
 | `telegram.token` | token | Your Telegram bot token. Only required if `telegram.enabled` is `true`.
@@ -67,7 +67,7 @@ Mandatory Parameters are marked as **Required**.
 | `initial_state` | running | Defines the initial application state. More information below.
 | `forcebuy_enable` | false | Enables the RPC Commands to force a buy. More information below.
 | `strategy` | DefaultStrategy | Defines Strategy class to use.
-| `strategy_path` | null | Adds an additional strategy lookup path (must be a folder).
+| `strategy_path` | null | Adds an additional strategy lookup path (must be a directory).
 | `internals.process_throttle_secs` | 5 | **Required.** Set the process throttle. Value in second.
 | `internals.sd_notify` | false | Enables use of the sd_notify protocol to tell systemd service manager about changes in the bot state and issue keep-alive pings. See [here](installation.md#7-optional-configure-freqtrade-as-a-systemd-service) for more details.
 | `logfile` | | Specify Logfile. Uses a rolling strategy of 10 files, with 1Mb per file.
@@ -131,17 +131,11 @@ If it is not set in either Strategy or Configuration, a default of 1000% `{"0":
 
 ### Understand stoploss
 
-The `stoploss` configuration parameter is loss in percentage that should trigger a sale.
-For example, value `-0.10` will cause immediate sell if the
-profit dips below -10% for a given trade. This parameter is optional.
-
-Most of the strategy files already include the optimal `stoploss`
-value. This parameter is optional. If you use it in the configuration file, it will take over the
-`stoploss` value from the strategy file.
+Go to the [stoploss documentation](stoploss.md) for more details.
 
 ### Understand trailing stoploss
 
-Go to the [trailing stoploss Documentation](stoploss.md) for details on trailing stoploss.
+Go to the [trailing stoploss Documentation](stoploss.md#trailing-stop-loss) for details on trailing stoploss.
 
 ### Understand initial_state
 
@@ -191,14 +185,28 @@ If this is configured, all 4 values (`buy`, `sell`, `stoploss` and
 `stoploss_on_exchange`) need to be present, otherwise the bot will warn about it and fail to start.
 The below is the default which is used if this is not configured in either strategy or configuration file.
 
+Syntax for Strategy:
+
 ```python
-"order_types": {
+order_types = {
     "buy": "limit",
     "sell": "limit",
     "stoploss": "market",
     "stoploss_on_exchange": False,
     "stoploss_on_exchange_interval": 60
-},
+}
+```
+
+Configuration:
+
+```json
+"order_types": {
+    "buy": "limit",
+    "sell": "limit",
+    "stoploss": "market",
+    "stoploss_on_exchange": false,
+    "stoploss_on_exchange_interval": 60
+}
 ```
 
 !!! Note
@@ -287,8 +295,27 @@ This configuration enables binance, as well as rate limiting to avoid bans from
 
 !!! Note
     Optimal settings for rate limiting depend on the exchange and the size of the whitelist, so an ideal parameter will vary on many other settings.
-    We try to provide sensible defaults per exchange where possible, if you encounter bans please make sure that `"enableRateLimit"` is enabled and increase the `"rateLimit"` parameter step by step. 
+    We try to provide sensible defaults per exchange where possible, if you encounter bans please make sure that `"enableRateLimit"` is enabled and increase the `"rateLimit"` parameter step by step.
 
+#### Advanced FreqTrade Exchange configuration
+
+Advanced options can be configured using the `_ft_has_params` setting, which will override Defaults and exchange-specific behaviours.
+
+Available options are listed in the exchange-class as `_ft_has_default`.
+
+For example, to test the order type `FOK` with Kraken, and modify candle_limit to 200 (so you only get 200 candles per call):
+
+```json
+"exchange": {
+    "name": "kraken",
+    "_ft_has_params": {
+        "order_time_in_force": ["gtc", "fok"],
+        "ohlcv_candle_limit": 200
+        }
+```
+
+!!! Warning
+    Please make sure to fully understand the impacts of these settings before modifying them.
 
 ### What values can be used for fiat_display_currency?
 
@@ -353,8 +380,6 @@ section of the configuration.
 * `StaticPairList`
   * It uses configuration from `exchange.pair_whitelist` and `exchange.pair_blacklist`.
 * `VolumePairList`
-  * Formerly available as `--dynamic-whitelist [<number_assets>]`. This command line
-option is deprecated and should no longer be used.
   * It selects `number_assets` top pairs based on `sort_key`, which can be one of
 `askVolume`, `bidVolume` and `quoteVolume`, defaults to `quoteVolume`.
   * There is a possibility to filter low-value coins that would not allow setting a stop loss

docs/data-analysis.md

@@ -0,0 +1,42 @@
+# Analyzing bot data
+
+After performing backtests, or after running the bot for some time, it will be interesting to analyze the results your bot generated.
+
+A good way for this is using Jupyter (notebook or lab) - which provides an interactive environment to analyze the data.
+
+The following helpers will help you loading the data into Pandas DataFrames, and may also give you some starting points in analyzing the results.
+
+## Backtesting
+
+To analyze your backtest results, you can [export the trades](#exporting-trades-to-file).
+You can then load the trades to perform further analysis.
+
+Freqtrade provides the `load_backtest_data()` helper function to easily load the backtest results, which takes the path to the the backtest-results file as parameter.
+
+``` python
+from freqtrade.data.btanalysis import load_backtest_data
+df = load_backtest_data("user_data/backtest-result.json")
+
+# Show value-counts per pair
+df.groupby("pair")["sell_reason"].value_counts()
+
+```
+
+This will allow you to drill deeper into your backtest results, and perform analysis which otherwise would make the regular backtest-output very difficult to digest due to information overload.
+
+If you have some ideas for interesting / helpful backtest data analysis ideas, please submit a Pull Request so the community can benefit from it.
+
+## Live data
+
+To analyze the trades your bot generated, you can load them to a DataFrame as follows:
+
+``` python
+from freqtrade.data.btanalysis import load_trades_from_db
+
+df = load_trades_from_db("sqlite:///tradesv3.sqlite")
+
+df.groupby("pair")["sell_reason"].value_counts()
+
+```
+
+Feel free to submit an issue or Pull Request enhancing this document if you would like to share ideas on how to best analyze the data.

docs/deprecated.md

@@ -4,28 +4,16 @@ This page contains description of the command line arguments, configuration para
 and the bot features that were declared as DEPRECATED by the bot development team
 and are no longer supported. Please avoid their usage in your configuration.
 
+### the `--live` command line option
+
+`--live` in the context of backtesting allows to download the latest tick data for backtesting.
+Since this only downloads one set of data (by default 500 candles) - this is not really suitable for extendet backtesting, and has therefore been deprecated.
+
+This command was deprecated in `2019.6-dev` and will be removed after the next release.
+
+## Removed features
+
 ### The **--dynamic-whitelist** command line option
 
-Per default `--dynamic-whitelist` will retrieve the 20 currencies based
-on BaseVolume. This value can be changed when you run the script.
-
-**By Default**
-Get the 20 currencies based on BaseVolume.
-
-```bash
-python3 freqtrade --dynamic-whitelist
-```
-
-**Customize the number of currencies to retrieve**
-Get the 30 currencies based on BaseVolume.
-
-```bash
-python3 freqtrade --dynamic-whitelist 30
-```
-
-**Exception**
-`--dynamic-whitelist` must be greater than 0. If you enter 0 or a
-negative value (e.g -2), `--dynamic-whitelist` will use the default
-value (20).
-
-
+This command line option was deprecated in 2018 and removed freqtrade 2019.6-dev (develop branch)
+and in freqtrade 2019.7 (master branch).

docs/developer.md

@@ -2,7 +2,7 @@
 
 This page is intended for developers of FreqTrade, people who want to contribute to the FreqTrade codebase or documentation, or people who want to understand the source code of the application they're running.
 
-All contributions, bug reports, bug fixes, documentation improvements, enhancements and ideas are welcome. We [track issues](https://github.com/freqtrade/freqtrade/issues) on [GitHub](https://github.com) and also have a dev channel in [slack](https://join.slack.com/t/highfrequencybot/shared_invite/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE) where you can ask questions.
+All contributions, bug reports, bug fixes, documentation improvements, enhancements and ideas are welcome. We [track issues](https://github.com/freqtrade/freqtrade/issues) on [GitHub](https://github.com) and also have a dev channel in [slack](https://join.slack.com/t/highfrequencybot/shared_invite/enQtNjU5ODcwNjI1MDU3LWEyODBiNzkzNzcyNzU0MWYyYzE5NjIyOTQxMzBmMGUxOTIzM2YyN2Y4NWY1YTEwZDgwYTRmMzE2NmM5ZmY2MTg) where you can ask questions.
 
 ## Documentation
 
@@ -81,11 +81,56 @@ Please also run `self._validate_whitelist(pairs)` and to check and remove pairs
 This is a simple method used by `VolumePairList` - however serves as a good example.
 It implements caching (`@cached(TTLCache(maxsize=1, ttl=1800))`) as well as a configuration option to allow different (but similar) strategies to work with the same PairListProvider.
 
+## Implement a new Exchange (WIP)
+
+!!! Note
+    This section is a Work in Progress and is not a complete guide on how to test a new exchange with FreqTrade.
+
+Most exchanges supported by CCXT should work out of the box.
+
+### Stoploss On Exchange
+
+Check if the new exchange supports Stoploss on Exchange orders through their API.
+
+Since CCXT does not provide unification for Stoploss On Exchange yet, we'll need to implement the exchange-specific parameters ourselfs. Best look at `binance.py` for an example implementation of this. You'll need to dig through the documentation of the Exchange's API on how exactly this can be done. [CCXT Issues](https://github.com/ccxt/ccxt/issues) may also provide great help, since others may have implemented something similar for their projects.
+
+### Incomplete candles
+
+While fetching OHLCV data, we're may end up getting incomplete candles (Depending on the exchange).
+To demonstrate this, we'll use daily candles (`"1d"`) to keep things simple.
+We query the api (`ct.fetch_ohlcv()`) for the timeframe and look at the date of the last entry. If this entry changes or shows the date of a "incomplete" candle, then we should drop this since having incomplete candles is problematic because indicators assume that only complete candles are passed to them, and will generate a lot of false buy signals. By default, we're therefore removing the last candle assuming it's incomplete.
+
+To check how the new exchange behaves, you can use the following snippet:
+
+``` python
+import ccxt
+from datetime import datetime
+from freqtrade.data.converter import parse_ticker_dataframe
+ct = ccxt.binance()
+timeframe = "1d"
+pair = "XLM/BTC"  # Make sure to use a pair that exists on that exchange!
+raw = ct.fetch_ohlcv(pair, timeframe=timeframe)
+
+# convert to dataframe
+df1 = parse_ticker_dataframe(raw, timeframe, pair=pair, drop_incomplete=False)
+
+print(df1["date"].tail(1))
+print(datetime.utcnow())
+```
+
+``` output
+19   2019-06-08 00:00:00+00:00
+2019-06-09 12:30:27.873327
+```
+
+The output will show the last entry from the Exchange as well as the current UTC date.
+If the day shows the same day, then the last candle can be assumed as incomplete and should be dropped (leave the setting `"ohlcv_partial_candle"` from the exchange-class untouched / True). Otherwise, set `"ohlcv_partial_candle"` to `False` to not drop Candles (shown in the example above).
+
 ## Creating a release
 
 This part of the documentation is aimed at maintainers, and shows how to create a release.
 
-### create release branch
+### Create release branch
 
 ``` bash
 # make sure you're in develop branch
@@ -95,11 +140,14 @@ git checkout develop
 git checkout -b new_release
 ```
 
-* edit `freqtrade/__init__.py` and add the desired version (for example `0.18.0`)
+* Edit `freqtrade/__init__.py` and add the version matching the current date (for example `2019.7` for July 2019). Minor versions can be `2019.7-1` should we need to do a second release that month.
 * Commit this part
-* push that branch to the remote and create a PR
+* push that branch to the remote and create a PR against the master branch
 
-### create changelog from git commits
+### Create changelog from git commits
+
+!!! Note
+    Make sure that both master and develop are up-todate!.
 
 ``` bash
 # Needs to be done before merging / pulling that branch.
@@ -108,10 +156,12 @@ git log --oneline --no-decorate --no-merges master..develop
 
 ### Create github release / tag
 
+* Use the button "Draft a new release" in the Github UI (subsection releases)
 * Use the version-number specified as tag. 
 * Use "master" as reference (this step comes after the above PR is merged).
-* use the above changelog as release comment (as codeblock)
+* Use the above changelog as release comment (as codeblock)
 
 ### After-release
 
-* update version in develop to next valid version and postfix that with `-dev` (`0.18.0 -> 0.18.1-dev`)
+* Update version in develop by postfixing that with `-dev` (`2019.6 -> 2019.6-dev`).
+* Create a PR against develop to update that branch.

docs/docker.md

@@ -0,0 +1,204 @@
+# Using FreqTrade with Docker
+
+## Install Docker
+
+Start by downloading and installing Docker CE for your platform:
+
+* [Mac](https://docs.docker.com/docker-for-mac/install/)
+* [Windows](https://docs.docker.com/docker-for-windows/install/)
+* [Linux](https://docs.docker.com/install/)
+
+Once you have Docker installed, simply prepare the config file (e.g. `config.json`) and run the image for `freqtrade` as explained below.
+
+## Download the official FreqTrade docker image
+
+Pull the image from docker hub.
+
+Branches / tags available can be checked out on [Dockerhub](https://hub.docker.com/r/freqtradeorg/freqtrade/tags/).
+
+```bash
+docker pull freqtradeorg/freqtrade:develop
+# Optionally tag the repository so the run-commands remain shorter
+docker tag freqtradeorg/freqtrade:develop freqtrade
+```
+
+To update the image, simply run the above commands again and restart your running container.
+
+Should you require additional libraries, please [build the image yourself](#build-your-own-docker-image).
+
+### Prepare the configuration files
+
+Even though you will use docker, you'll still need some files from the github repository.
+
+#### Clone the git repository
+
+Linux/Mac/Windows with WSL
+
+```bash
+git clone https://github.com/freqtrade/freqtrade.git
+```
+
+Windows with docker
+
+```bash
+git clone --config core.autocrlf=input https://github.com/freqtrade/freqtrade.git
+```
+
+#### Copy `config.json.example` to `config.json`
+
+```bash
+cd freqtrade
+cp -n config.json.example config.json
+```
+
+> To understand the configuration options, please refer to the [Bot Configuration](configuration.md) page.
+
+#### Create your database file
+
+Production
+
+```bash
+touch tradesv3.sqlite
+````
+
+Dry-Run
+
+```bash
+touch tradesv3.dryrun.sqlite
+```
+
+!!! Note
+    Make sure to use the path to this file when starting the bot in docker.
+
+### Build your own Docker image
+
+Best start by pulling the official docker image from dockerhub as explained [here](#download-the-official-docker-image) to speed up building.
+
+To add additional libraries to your docker image, best check out [Dockerfile.technical](https://github.com/freqtrade/freqtrade/blob/develop/Dockerfile.technical) which adds the [technical](https://github.com/freqtrade/technical) module to the image.
+
+```bash
+docker build -t freqtrade -f Dockerfile.technical .
+```
+
+If you are developing using Docker, use `Dockerfile.develop` to build a dev Docker image, which will also set up develop dependencies:
+
+```bash
+docker build -f Dockerfile.develop -t freqtrade-dev .
+```
+
+!!! Note
+    For security reasons, your configuration file will not be included in the image, you will need to bind mount it. It is also advised to bind mount an SQLite database file (see the "5. Run a restartable docker image" section) to keep it between  updates.
+
+#### Verify the Docker image
+
+After the build process you can verify that the image was created with:
+
+```bash
+docker images
+```
+
+The output should contain the freqtrade image.
+
+### Run the Docker image
+
+You can run a one-off container that is immediately deleted upon exiting with the following command (`config.json` must be in the current working directory):
+
+```bash
+docker run --rm -v `pwd`/config.json:/freqtrade/config.json -it freqtrade
+```
+
+!!! Warning
+    In this example, the database will be created inside the docker instance and will be lost when you will refresh your image.
+
+#### Adjust timezone
+
+By default, the container will use UTC timezone.
+Should you find this irritating please add the following to your docker commands:
+
+##### Linux
+
+``` bash
+-v /etc/timezone:/etc/timezone:ro
+
+# Complete command:
+docker run --rm -v /etc/timezone:/etc/timezone:ro -v `pwd`/config.json:/freqtrade/config.json -it freqtrade
+```
+
+##### MacOS
+
+There is known issue in OSX Docker versions after 17.09.1, whereby `/etc/localtime` cannot be shared causing Docker to not start. A work-around for this is to start with the following cmd.
+
+```bash
+docker run --rm -e TZ=`ls -la /etc/localtime | cut -d/ -f8-9` -v `pwd`/config.json:/freqtrade/config.json -it freqtrade
+```
+
+More information on this docker issue and work-around can be read [here](https://github.com/docker/for-mac/issues/2396).
+
+### Run a restartable docker image
+
+To run a restartable instance in the background (feel free to place your configuration and database files wherever it feels comfortable on your filesystem).
+
+#### Move your config file and database
+
+The following will assume that you place your configuration / database files to `~/.freqtrade`, which is a hidden directory in your home directory. Feel free to use a different directory and replace the directory in the upcomming commands.
+
+```bash
+mkdir ~/.freqtrade
+mv config.json ~/.freqtrade
+mv tradesv3.sqlite ~/.freqtrade
+```
+
+#### Run the docker image
+
+```bash
+docker run -d \
+  --name freqtrade \
+  -v ~/.freqtrade/config.json:/freqtrade/config.json \
+  -v ~/.freqtrade/user_data/:/freqtrade/user_data \
+  -v ~/.freqtrade/tradesv3.sqlite:/freqtrade/tradesv3.sqlite \
+  freqtrade --db-url sqlite:///tradesv3.sqlite --strategy MyAwesomeStrategy
+```
+
+!!! Note
+    db-url defaults to `sqlite:///tradesv3.sqlite` but it defaults to `sqlite://` if `dry_run=True` is being used.
+    To override this behaviour use a custom db-url value: i.e.: `--db-url sqlite:///tradesv3.dryrun.sqlite`
+
+!!! Note
+    All available bot command line parameters can be added to the end of the `docker run` command.
+
+### Monitor your Docker instance
+
+You can use the following commands to monitor and manage your container:
+
+```bash
+docker logs freqtrade
+docker logs -f freqtrade
+docker restart freqtrade
+docker stop freqtrade
+docker start freqtrade
+```
+
+For more information on how to operate Docker, please refer to the [official Docker documentation](https://docs.docker.com/).
+
+!!! Note
+    You do not need to rebuild the image for configuration changes, it will suffice to edit `config.json` and restart the container.
+
+### Backtest with docker
+
+The following assumes that the download/setup of the docker image have been completed successfully.
+Also, backtest-data should be available at `~/.freqtrade/user_data/`.
+
+```bash
+docker run -d \
+  --name freqtrade \
+  -v /etc/localtime:/etc/localtime:ro \
+  -v ~/.freqtrade/config.json:/freqtrade/config.json \
+  -v ~/.freqtrade/tradesv3.sqlite:/freqtrade/tradesv3.sqlite \
+  -v ~/.freqtrade/user_data/:/freqtrade/user_data/ \
+  freqtrade --strategy AwsomelyProfitableStrategy backtesting
+```
+
+Head over to the [Backtesting Documentation](backtesting.md) for more details.
+
+!!! Note
+    Additional bot command line parameters can be appended after the image name (`freqtrade` in the above example).

docs/edge.md

@@ -3,7 +3,7 @@
 This page explains how to use Edge Positioning module in your bot in order to enter into a trade only if the trade has a reasonable win rate and risk reward ratio, and consequently adjust your position size and stoploss.
 
 !!! Warning
-    Edge positioning is not compatible with dynamic whitelist. If enabled, it overrides the dynamic whitelist option.
+    Edge positioning is not compatible with dynamic (volume-based) whitelist.
 
 !!! Note
     Edge does not consider anything else than buy/sell/stoploss signals. So trailing stoploss, ROI, and everything else are ignored in its calculation.
@@ -209,7 +209,7 @@ Edge will remove sudden pumps in a given market while going through historical d
 You can run Edge independently in order to see in details the result. Here is an example:
 
 ```bash
-python3 freqtrade edge
+freqtrade edge
 ```
 
 An example of its output:
@@ -235,19 +235,19 @@ An example of its output:
 ### Update cached pairs with the latest data
 
 ```bash
-python3 freqtrade edge --refresh-pairs-cached
+freqtrade edge --refresh-pairs-cached
 ```
 
 ### Precising stoploss range
 
 ```bash
-python3 freqtrade edge --stoplosses=-0.01,-0.1,-0.001 #min,max,step
+freqtrade edge --stoplosses=-0.01,-0.1,-0.001 #min,max,step
 ```
 
 ### Advanced use of timerange
 
 ```bash
-python3 freqtrade edge --timerange=20181110-20181113
+freqtrade edge --timerange=20181110-20181113
 ```
 
 Doing `--timerange=-200` will get the last 200 timeframes from your inputdata. You can also specify specific dates, or a range span indexed by start and stop.

docs/faq.md

@@ -1,14 +1,25 @@
 # Freqtrade FAQ
 
-### Freqtrade commons
+## Freqtrade common issues
 
-#### I have waited 5 minutes, why hasn't the bot made any trades yet?!
+### The bot does not start
+
+Running the bot with `freqtrade --config config.json` does show the output `freqtrade: command not found`.
+
+This could have the following reasons:
+
+* The virtual environment is not active
+  * run `source .env/bin/activate` to activate the virtual environment
+* The installation did not work correctly.
+  * Please check the [Installation documentation](installation.md).
+
+### I have waited 5 minutes, why hasn't the bot made any trades yet?!
 
 Depending on the buy strategy, the amount of whitelisted coins, the
 situation of the market etc, it can take up to hours to find good entry
 position for a trade. Be patient!
 
-#### I have made 12 trades already, why is my total profit negative?!
+### I have made 12 trades already, why is my total profit negative?!
 
 I understand your disappointment but unfortunately 12 trades is just
 not enough to say anything. If you run backtesting, you can see that our
@@ -19,24 +30,24 @@ of course constantly aim to improve the bot but it will _always_ be a
 gamble, which should leave you with modest wins on monthly basis but
 you can't say much from few trades.
 
-#### I’d like to change the stake amount. Can I just stop the bot with /stop and then change the config.json and run it again?
+### I’d like to change the stake amount. Can I just stop the bot with /stop and then change the config.json and run it again?
 
 Not quite. Trades are persisted to a database but the configuration is
 currently only read when the bot is killed and restarted. `/stop` more
 like pauses. You can stop your bot, adjust settings and start it again.
 
-#### I want to improve the bot with a new strategy
+### I want to improve the bot with a new strategy
 
 That's great. We have a nice backtesting and hyperoptimizing setup. See
 the tutorial [here|Testing-new-strategies-with-Hyperopt](bot-usage.md#hyperopt-commands).
 
-#### Is there a setting to only SELL the coins being held and not perform anymore BUYS?
+### Is there a setting to only SELL the coins being held and not perform anymore BUYS?
 
 You can use the `/forcesell all` command from Telegram.
 
-### Hyperopt module
+## Hyperopt module
 
-#### How many epoch do I need to get a good Hyperopt result?
+### How many epoch do I need to get a good Hyperopt result?
 
 Per default Hyperopts without `-e` or `--epochs` parameter will only
 run 100 epochs, means 100 evals of your triggers, guards, ... Too few
@@ -47,16 +58,16 @@ compute.
 We recommend you to run it at least 10.000 epochs:
 
 ```bash
-python3 freqtrade hyperopt -e 10000
+freqtrade hyperopt -e 10000
 ```
 
 or if you want intermediate result to see
 
 ```bash
-for i in {1..100}; do python3 freqtrade hyperopt -e 100; done
+for i in {1..100}; do freqtrade hyperopt -e 100; done
 ```
 
-#### Why it is so long to run hyperopt?
+### Why it is so long to run hyperopt?
 
 Finding a great Hyperopt results takes time.
 
@@ -74,13 +85,14 @@ already 8\*10^9\*10 evaluations. A roughly total of 80 billion evals.
 Did you run 100 000 evals? Congrats, you've done roughly 1 / 100 000 th
 of the search space.
 
-### Edge module
+## Edge module
 
-#### Edge implements interesting approach for controlling position size, is there any theory behind it?
+### Edge implements interesting approach for controlling position size, is there any theory behind it?
 
 The Edge module is mostly a result of brainstorming of [@mishaker](https://github.com/mishaker) and [@creslinux](https://github.com/creslinux) freqtrade team members.
 
 You can find further info on expectancy, winrate, risk management and position size in the following sources:
+
 - https://www.tradeciety.com/ultimate-math-guide-for-traders/
 - http://www.vantharp.com/tharp-concepts/expectancy.asp
 - https://samuraitradingacademy.com/trading-expectancy/

docs/hyperopt.md

@@ -12,7 +12,7 @@ and still take a long time.
 ## Prepare Hyperopting
 
 Before we start digging into Hyperopt, we recommend you to take a look at
-an example hyperopt file located into [user_data/hyperopts/](https://github.com/freqtrade/freqtrade/blob/develop/user_data/hyperopts/test_hyperopt.py)
+an example hyperopt file located into [user_data/hyperopts/](https://github.com/freqtrade/freqtrade/blob/develop/user_data/hyperopts/sample_hyperopt.py)
 
 Configuring hyperopt is similar to writing your own strategy, and many tasks will be similar and a lot of code can be copied across from the strategy.
 
@@ -34,7 +34,7 @@ Depending on the space you want to optimize, only some of the below are required
 
 ### 1. Install a Custom Hyperopt File
 
-Put your hyperopt file into the folder`user_data/hyperopts`.
+Put your hyperopt file into the directory `user_data/hyperopts`.
 
 Let assume you want a hyperopt file `awesome_hyperopt.py`:  
 Copy the file `user_data/hyperopts/sample_hyperopt.py` into `user_data/hyperopts/awesome_hyperopt.py`
@@ -71,6 +71,11 @@ Place the corresponding settings into the following methods
 The configuration and rules are the same than for buy signals.
 To avoid naming collisions in the search-space, please prefix all sell-spaces with `sell-`.
 
+#### Using ticker-interval as part of the Strategy
+
+The Strategy exposes the ticker-interval as `self.ticker_interval`. The same value is available as class-attribute `HyperoptName.ticker_interval`.
+In the case of the linked sample-value this would be `SampleHyperOpts.ticker_interval`.
+
 ## Solving a Mystery
 
 Let's say you are curious: should you use MACD crossings or lower Bollinger
@@ -122,9 +127,10 @@ So let's write the buy strategy using these values:
                         dataframe['macd'], dataframe['macdsignal']
                     ))
 
-            dataframe.loc[
-                reduce(lambda x, y: x & y, conditions),
-                'buy'] = 1
+            if conditions:
+                dataframe.loc[
+                    reduce(lambda x, y: x & y, conditions),
+                    'buy'] = 1
 
             return dataframe
 
@@ -138,21 +144,90 @@ it will end with telling you which paramter combination produced the best profit
 
 The search for best parameters starts with a few random combinations and then uses a
 regressor algorithm (currently ExtraTreesRegressor) to quickly find a parameter combination
-that minimizes the value of the objective function `calculate_loss` in `hyperopt.py`.
+that minimizes the value of the [loss function](#loss-functions).
 
 The above setup expects to find ADX, RSI and Bollinger Bands in the populated indicators.
 When you want to test an indicator that isn't used by the bot currently, remember to
 add it to the `populate_indicators()` method in `hyperopt.py`.
 
+## Loss-functions
+
+Each hyperparameter tuning requires a target. This is usually defined as a loss function (sometimes also called objective function), which should decrease for more desirable results, and increase for bad results.
+
+By default, FreqTrade uses a loss function, which has been with freqtrade since the beginning and optimizes mostly for short trade duration and avoiding losses.
+
+A different loss function can be specified by using the `--hyperopt-loss <Class-name>` argument.
+This class should be in its own file within the `user_data/hyperopts/` directory.
+
+Currently, the following loss functions are builtin: `DefaultHyperOptLoss` (default legacy Freqtrade hyperoptimization loss function), `SharpeHyperOptLoss` (optimizes Sharpe Ratio calculated on the trade returns) and `OnlyProfitHyperOptLoss` (which takes only amount of profit into consideration).
+
+### Creating and using a custom loss function
+
+To use a custom loss function class, make sure that the function `hyperopt_loss_function` is defined in your custom hyperopt loss class.
+For the sample below, you then need to add the command line parameter `--hyperopt-loss SuperDuperHyperOptLoss` to your hyperopt call so this fuction is being used.
+
+A sample of this can be found below, which is identical to the Default Hyperopt loss implementation. A full sample can be found [user_data/hyperopts/](https://github.com/freqtrade/freqtrade/blob/develop/user_data/hyperopts/sample_hyperopt_loss.py)
+
+``` python
+from freqtrade.optimize.hyperopt import IHyperOptLoss
+
+TARGET_TRADES = 600
+EXPECTED_MAX_PROFIT = 3.0
+MAX_ACCEPTED_TRADE_DURATION = 300
+
+class SuperDuperHyperOptLoss(IHyperOptLoss):
+    """
+    Defines the default loss function for hyperopt
+    """
+
+    @staticmethod
+    def hyperopt_loss_function(results: DataFrame, trade_count: int,
+                               min_date: datetime, max_date: datetime,
+                               *args, **kwargs) -> float:
+        """
+        Objective function, returns smaller number for better results
+        This is the legacy algorithm (used until now in freqtrade).
+        Weights are distributed as follows:
+        * 0.4 to trade duration
+        * 0.25: Avoiding trade loss
+        * 1.0 to total profit, compared to the expected value (`EXPECTED_MAX_PROFIT`) defined above
+        """
+        total_profit = results.profit_percent.sum()
+        trade_duration = results.trade_duration.mean()
+
+        trade_loss = 1 - 0.25 * exp(-(trade_count - TARGET_TRADES) ** 2 / 10 ** 5.8)
+        profit_loss = max(0, 1 - total_profit / EXPECTED_MAX_PROFIT)
+        duration_loss = 0.4 * min(trade_duration / MAX_ACCEPTED_TRADE_DURATION, 1)
+        result = trade_loss + profit_loss + duration_loss
+        return result
+```
+
+Currently, the arguments are:
+
+* `results`: DataFrame containing the result  
+    The following columns are available in results (corresponds to the output-file of backtesting when used with `--export trades`):  
+    `pair, profit_percent, profit_abs, open_time, close_time, open_index, close_index, trade_duration, open_at_end, open_rate, close_rate, sell_reason`
+* `trade_count`: Amount of trades (identical to `len(results)`)
+* `min_date`: Start date of the hyperopting TimeFrame
+* `min_date`: End date of the hyperopting TimeFrame
+
+This function needs to return a floating point number (`float`). Smaller numbers will be interpreted as better results. The parameters and balancing for this is up to you.
+
+!!! Note
+    This function is called once per iteration - so please make sure to have this as optimized as possible to not slow hyperopt down unnecessarily.
+
+!!! Note
+    Please keep the arguments `*args` and `**kwargs` in the interface to allow us to extend this interface later.
+
 ## Execute Hyperopt
 
 Once you have updated your hyperopt configuration you can run it.
-Because hyperopt tries a lot of combinations to find the best parameters it will take time you will have the result (more than 30 mins).
+Because hyperopt tries a lot of combinations to find the best parameters it will take time to get a good result. More time usually results in better results.
 
 We strongly recommend to use `screen` or `tmux` to prevent any connection loss.
 
 ```bash
-python3 freqtrade -c config.json hyperopt --customhyperopt <hyperoptname> -e 5000 --spaces all
+freqtrade -c config.json hyperopt --customhyperopt <hyperoptname> -e 5000 --spaces all
 ```
 
 Use  `<hyperoptname>` as the name of the custom hyperopt used.
@@ -162,8 +237,11 @@ running at least several thousand evaluations.
 
 The `--spaces all` flag determines that all possible parameters should be optimized. Possibilities are listed below.
 
+!!! Note
+    By default, hyperopt will erase previous results and start from scratch. Continuation can be archived by using `--continue`.
+
 !!! Warning
-    When switching parameters or changing configuration options, the file `user_data/hyperopt_results.pickle` should be removed. It's used to be able to continue interrupted calculations, but does not detect changes to settings or the hyperopt file.
+    When switching parameters or changing configuration options, make sure to not use the argument `--continue` so temporary results can be removed.
 
 ### Execute Hyperopt with Different Ticker-Data Source
 
@@ -173,12 +251,11 @@ use data from directory `user_data/data`.
 
 ### Running Hyperopt with Smaller Testset
 
-Use the `--timerange` argument to change how much of the testset
-you want to use. The last N ticks/timeframes will be used.
-Example:
+Use the `--timerange` argument to change how much of the testset you want to use.
+For example, to use one month of data, pass the following parameter to the hyperopt call:
 
 ```bash
-python3 freqtrade hyperopt --timerange -200
+freqtrade hyperopt --timerange 20180401-20180501
 ```
 
 ### Running Hyperopt with Smaller Search Space
@@ -191,12 +268,33 @@ new buy strategy you have.
 
 Legal values are:
 
-- `all`: optimize everything
-- `buy`: just search for a new buy strategy
-- `sell`: just search for a new sell strategy
-- `roi`: just optimize the minimal profit table for your strategy
-- `stoploss`: search for the best stoploss value
-- space-separated list of any of the above values for example `--spaces roi stoploss`
+* `all`: optimize everything
+* `buy`: just search for a new buy strategy
+* `sell`: just search for a new sell strategy
+* `roi`: just optimize the minimal profit table for your strategy
+* `stoploss`: search for the best stoploss value
+* space-separated list of any of the above values for example `--spaces roi stoploss`
+
+### Position stacking and disabling max market positions
+
+In some situations, you may need to run Hyperopt (and Backtesting) with the 
+`--eps`/`--enable-position-staking` and `--dmmp`/`--disable-max-market-positions` arguments.
+
+By default, hyperopt emulates the behavior of the Freqtrade Live Run/Dry Run, where only one
+open trade is allowed for every traded pair. The total number of trades open for all pairs 
+is also limited by the `max_open_trades` setting. During Hyperopt/Backtesting this may lead to
+some potential trades to be hidden (or masked) by previosly open trades.
+
+The `--eps`/`--enable-position-stacking` argument allows emulation of buying the same pair multiple times,
+while `--dmmp`/`--disable-max-market-positions` disables applying `max_open_trades` 
+during Hyperopt/Backtesting (which is equal to setting `max_open_trades` to a very high
+number).
+
+!!! Note
+    Dry/live runs will **NOT** use position stacking - therefore it does make sense to also validate the strategy without this as it's closer to reality.
+
+You can also enable position stacking in the configuration file by explicitly setting 
+`"position_stacking"=true`.
 
 ## Understand the Hyperopt Result
 
@@ -225,7 +323,7 @@ method, what those values match to.
 
 So for example you had `rsi-value: 29.0` so we would look at `rsi`-block, that translates to the following code block:
 
-```
+``` python
 (dataframe['rsi'] < 29.0)
 ```
 
@@ -282,19 +380,11 @@ This would translate to the following ROI table:
     }
 ```
 
-### Validate backtest result
+### Validate backtesting results
 
 Once the optimized strategy has been implemented into your strategy, you should backtest this strategy to make sure everything is working as expected.
-To archive the same results (number of trades, ...) than during hyperopt, please use the command line flags `--disable-max-market-positions` and `--enable-position-stacking` for backtesting.
 
-This configuration is the default in hyperopt for performance reasons.
-
-You can overwrite position stacking in the configuration by explicitly setting `"position_stacking"=false` or by changing the relevant line in your hyperopt file [here](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/optimize/hyperopt.py#L191).
-
-Enabling the market-position for hyperopt is currently not possible.
-
-!!! Note
-    Dry/live runs will **NOT** use position stacking - therefore it does make sense to also validate the strategy without this as it's closer to reality.
+To achieve same results (number of trades, their durations, profit, etc.) than during Hyperopt, please use same set of arguments `--dmmp`/`--disable-max-market-positions` and `--eps`/`--enable-position-stacking` for Backtesting.
 
 ## Next Step
 

docs/index.md

@@ -21,8 +21,8 @@ Freqtrade is a cryptocurrency trading bot written in Python.
 
     We strongly recommend you to have basic coding skills and Python knowledge. Do not hesitate to read the source code and understand the mechanisms of this bot, algorithms and techniques implemented in it.
 
-
 ## Features
+
  - Based on Python 3.6+: For botting on any operating system — Windows, macOS and Linux.
  - Persistence: Persistence is achieved through sqlite database.
  - Dry-run mode: Run the bot without playing money.
@@ -31,17 +31,19 @@ Freqtrade is a cryptocurrency trading bot written in Python.
  - Edge position sizing: Calculate your win rate, risk reward ratio, the best stoploss and adjust your position size before taking a position for each specific market.
  - Whitelist crypto-currencies: Select which crypto-currency you want to trade or use dynamic whitelists based on market (pair) trade volume.
  - Blacklist crypto-currencies: Select which crypto-currency you want to avoid.
- - Manageable via Telegram: Manage the bot with Telegram.
+ - Manageable via Telegram or REST APi: Manage the bot with Telegram or via the builtin REST API.
  - Display profit/loss in fiat: Display your profit/loss in any of 33 fiat currencies supported.
  - Daily summary of profit/loss: Receive the daily summary of your profit/loss.
  - Performance status report: Receive the performance status of your current trades.
 
-
 ## Requirements
+
 ### Up to date clock
+
 The clock on the system running the bot must be accurate, synchronized to a NTP server frequently enough to avoid problems with communication to the exchanges.
 
 ### Hardware requirements
+
 To run this bot we recommend you a cloud instance with a minimum of:
 
 - 2GB RAM
@@ -49,6 +51,7 @@ To run this bot we recommend you a cloud instance with a minimum of:
 - 2vCPU
 
 ### Software requirements
+
 - Python 3.6.x
 - pip (pip3)
 - git
@@ -56,12 +59,13 @@ To run this bot we recommend you a cloud instance with a minimum of:
 - virtualenv (Recommended)
 - Docker (Recommended)
 
-
 ## Support
+
 Help / Slack
 For any questions not covered by the documentation or for further information about the bot, we encourage you to join our Slack channel.
 
-Click [here](https://join.slack.com/t/highfrequencybot/shared_invite/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE) to join Slack channel.
+Click [here](https://join.slack.com/t/highfrequencybot/shared_invite/enQtNjU5ODcwNjI1MDU3LWEyODBiNzkzNzcyNzU0MWYyYzE5NjIyOTQxMzBmMGUxOTIzM2YyN2Y4NWY1YTEwZDgwYTRmMzE2NmM5ZmY2MTg) to join Slack channel.
 
 ## Ready to try?
+
 Begin by reading our installation guide [here](installation).

docs/installation.md

@@ -1,72 +1,49 @@
 # Installation
+
 This page explains how to prepare your environment for running the bot.
 
 ## Prerequisite
-Before running your bot in production you will need to setup few
-external API. In production mode, the bot required valid Bittrex API
-credentials and a Telegram bot (optional but recommended).
 
-- [Setup your exchange account](#setup-your-exchange-account)
-- [Backtesting commands](#setup-your-telegram-bot)
+### Requirements
+
+Click each one for install guide:
+
+* [Python >= 3.6.x](http://docs.python-guide.org/en/latest/starting/installation/)
+* [pip](https://pip.pypa.io/en/stable/installing/)
+* [git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
+* [virtualenv](https://virtualenv.pypa.io/en/stable/installation/) (Recommended)
+* [TA-Lib](https://mrjbq7.github.io/ta-lib/install.html) (install instructions below)
+
+### API keys
+
+Before running your bot in production you will need to setup few
+external API. In production mode, the bot will require valid Exchange API
+credentials. We also recommend a [Telegram bot](telegram-usage.md#setup-your-telegram-bot) (optional but recommended).
 
 ### Setup your exchange account
-*To be completed, please feel free to complete this section.*
 
-### Setup your Telegram bot
-The only things you need is a working Telegram bot and its API token.
-Below we explain how to create your Telegram Bot, and how to get your
-Telegram user id.
+You will need to create API Keys (Usually you get `key` and `secret`) from the Exchange website and insert this into the appropriate fields in the configuration or when asked by the installation script.
 
-### 1. Create your Telegram bot
-
-**1.1. Start a chat with https://telegram.me/BotFather**
-
-**1.2. Send the message `/newbot`. ** *BotFather response:*
-```
-Alright, a new bot. How are we going to call it? Please choose a name for your bot.
-```
-
-**1.3. Choose the public name of your bot (e.x. `Freqtrade bot`)**
-*BotFather response:*
-```
-Good. Now let's choose a username for your bot. It must end in `bot`. Like this, for example: TetrisBot or tetris_bot.
-```
-**1.4. Choose the name id of your bot (e.x "`My_own_freqtrade_bot`")**
-
-**1.5. Father bot will return you the token (API key)**<br/>
-Copy it and keep it you will use it for the config parameter `token`.
-*BotFather response:*
-```hl_lines="4"
-Done! Congratulations on your new bot. You will find it at t.me/My_own_freqtrade_bot. You can now add a description, about section and profile picture for your bot, see /help for a list of commands. By the way, when you've finished creating your cool bot, ping our Bot Support if you want a better username for it. Just make sure the bot is fully operational before you do this.
-
-Use this token to access the HTTP API:
-521095879:AAEcEZEL7ADJ56FtG_qD0bQJSKETbXCBCi0
-
-For a description of the Bot API, see this page: https://core.telegram.org/bots/api
-```
-**1.6. Don't forget to start the conversation with your bot, by clicking /START button**
-
-### 2. Get your user id
-**2.1. Talk to https://telegram.me/userinfobot**
-
-**2.2. Get your "Id", you will use it for the config parameter
-`chat_id`.**
-<hr/>
 ## Quick start
+
 Freqtrade provides a Linux/MacOS script to install all dependencies and help you to configure the bot.
 
+!!! Note
+    Python3.6 or higher and the corresponding pip are assumed to be available. The install-script will warn and stop if that's not the case.
+
 ```bash
 git clone git@github.com:freqtrade/freqtrade.git
 cd freqtrade
 git checkout develop
 ./setup.sh --install
 ```
+
 !!! Note
     Windows installation is explained [here](#windows).
-<hr/>
+
 ## Easy Installation - Linux Script
 
-If you are on Debian, Ubuntu or MacOS a freqtrade provides a script to Install, Update, Configure, and Reset your bot.
+If you are on Debian, Ubuntu or MacOS freqtrade provides a script to Install, Update, Configure, and Reset your bot.
 
 ```bash
 $ ./setup.sh
@@ -81,7 +58,7 @@ usage:
 
 This script will install everything you need to run the bot:
 
-* Mandatory software as: `Python3`, `ta-lib`, `wget`
+* Mandatory software as: `ta-lib`
 * Setup your virtualenv
 * Configure your `config.json` file
 
@@ -101,212 +78,21 @@ Config parameter is a `config.json` configurator. This script will ask you quest
 
 ------
 
-## Automatic Installation - Docker
-
-Start by downloading Docker for your platform:
-
-* [Mac](https://www.docker.com/products/docker#/mac)
-* [Windows](https://www.docker.com/products/docker#/windows)
-* [Linux](https://www.docker.com/products/docker#/linux)
-
-Once you have Docker installed, simply create the config file (e.g. `config.json`) and then create a Docker image for `freqtrade` using the Dockerfile in this repo.
-
-### 1. Prepare the Bot
-
-**1.1. Clone the git repository**
-
-Linux/Mac/Windows with WSL
-```bash
-git clone https://github.com/freqtrade/freqtrade.git
-```
-
-Windows with docker
-```bash
-git clone --config core.autocrlf=input https://github.com/freqtrade/freqtrade.git
-```
-
-**1.2. (Optional) Checkout the develop branch**
-
-```bash
-git checkout develop
-```
-
-**1.3. Go into the new directory**
-
-```bash
-cd freqtrade
-```
-
-**1.4. Copy `config.json.example` to `config.json`**
-
-```bash
-cp -n config.json.example config.json
-```
-
-> To edit the config please refer to the [Bot Configuration](configuration.md) page.
-
-**1.5. Create your database file *(optional - the bot will create it if it is missing)**
-
-Production
-
-```bash
-touch tradesv3.sqlite
-````
-
-Dry-Run
-
-```bash
-touch tradesv3.dryrun.sqlite
-```
-
-### 2. Download or build the docker image
-
-Either use the prebuilt image from docker hub - or build the image yourself if you would like more control on which version is used.
-
-Branches / tags available can be checked out on [Dockerhub](https://hub.docker.com/r/freqtradeorg/freqtrade/tags/).
-
-**2.1. Download the docker image**
-
-Pull the image from docker hub and (optionally) change the name of the image
-
-```bash
-docker pull freqtradeorg/freqtrade:develop
-# Optionally tag the repository so the run-commands remain shorter
-docker tag freqtradeorg/freqtrade:develop freqtrade
-```
-
-To update the image, simply run the above commands again and restart your running container.
-
-**2.2. Build the Docker image**
-
-```bash
-cd freqtrade
-docker build -t freqtrade .
-```
-
-If you are developing using Docker, use `Dockerfile.develop` to build a dev Docker image, which will also set up develop dependencies:
-
-```bash
-docker build -f ./Dockerfile.develop -t freqtrade-dev .
-```
-
-For security reasons, your configuration file will not be included in the image, you will need to bind mount it. It is also advised to bind mount an SQLite database file (see the "5. Run a restartable docker image" section) to keep it between  updates.
-
-### 3. Verify the Docker image
-
-After the build process you can verify that the image was created with:
-
-```bash
-docker images
-```
-
-### 4. Run the Docker image
-
-You can run a one-off container that is immediately deleted upon exiting with the following command (`config.json` must be in the current working directory):
-
-```bash
-docker run --rm -v /etc/localtime:/etc/localtime:ro -v `pwd`/config.json:/freqtrade/config.json -it freqtrade
-```
-
-There is known issue in OSX Docker versions after 17.09.1, whereby /etc/localtime cannot be shared causing Docker to not start. A work-around for this is to start with the following cmd.
-
-```bash
-docker run --rm -e TZ=`ls -la /etc/localtime | cut -d/ -f8-9` -v `pwd`/config.json:/freqtrade/config.json -it freqtrade
-```
-
-More information on this docker issue and work-around can be read [here](https://github.com/docker/for-mac/issues/2396).
-
-In this example, the database will be created inside the docker instance and will be lost when you will refresh your image.
-
-### 5. Run a restartable docker image
-
-To run a restartable instance in the background (feel free to place your configuration and database files wherever it feels comfortable on your filesystem).
-
-**5.1. Move your config file and database**
-
-```bash
-mkdir ~/.freqtrade
-mv config.json ~/.freqtrade
-mv tradesv3.sqlite ~/.freqtrade
-```
-
-**5.2. Run the docker image**
-
-```bash
-docker run -d \
-  --name freqtrade \
-  -v /etc/localtime:/etc/localtime:ro \
-  -v ~/.freqtrade/config.json:/freqtrade/config.json \
-  -v ~/.freqtrade/tradesv3.sqlite:/freqtrade/tradesv3.sqlite \
-  freqtrade --db-url sqlite:///tradesv3.sqlite
-```
-
-!!! Note
-    db-url defaults to `sqlite:///tradesv3.sqlite` but it defaults to `sqlite://` if `dry_run=True` is being used.
-    To override this behaviour use a custom db-url value: i.e.: `--db-url sqlite:///tradesv3.dryrun.sqlite`
-
-### 6. Monitor your Docker instance
-
-You can then use the following commands to monitor and manage your container:
-
-```bash
-docker logs freqtrade
-docker logs -f freqtrade
-docker restart freqtrade
-docker stop freqtrade
-docker start freqtrade
-```
-
-For more information on how to operate Docker, please refer to the [official Docker documentation](https://docs.docker.com/).
-
-!!! Note
-    You do not need to rebuild the image for configuration changes, it will suffice to edit `config.json` and restart the container.
-
-### 7. Backtest with docker
-
-The following assumes that the above steps (1-4) have been completed successfully.
-Also, backtest-data should be available at `~/.freqtrade/user_data/`.
-
-```bash
-docker run -d \
-  --name freqtrade \
-  -v /etc/localtime:/etc/localtime:ro \
-  -v ~/.freqtrade/config.json:/freqtrade/config.json \
-  -v ~/.freqtrade/tradesv3.sqlite:/freqtrade/tradesv3.sqlite \
-  -v ~/.freqtrade/user_data/:/freqtrade/user_data/ \
-  freqtrade --strategy AwsomelyProfitableStrategy backtesting
-```
-
-Head over to the [Backtesting Documentation](backtesting.md) for more details.
-
-!!! Note
-    Additional parameters can be appended after the image name (`freqtrade` in the above example).
-
-------
-
 ## Custom Installation
 
 We've included/collected install instructions for Ubuntu 16.04, MacOS, and Windows. These are guidelines and your success may vary with other distros.
 OS Specific steps are listed first, the [Common](#common) section below is necessary for all systems.
 
-### Requirements
-
-Click each one for install guide:
-
-* [Python >= 3.6.x](http://docs.python-guide.org/en/latest/starting/installation/)
-* [pip](https://pip.pypa.io/en/stable/installing/)
-* [git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
-* [virtualenv](https://virtualenv.pypa.io/en/stable/installation/) (Recommended)
-* [TA-Lib](https://mrjbq7.github.io/ta-lib/install.html)
+!!! Note
+    Python3.6 or higher and the corresponding pip are assumed to be available.
 
 ### Linux - Ubuntu 16.04
 
-#### Install Python 3.6, Git, and wget
+#### Install necessary dependencies
 
 ```bash
-sudo add-apt-repository ppa:jonathonf/python-3.6
 sudo apt-get update
-sudo apt-get install python3.6 python3.6-venv python3.6-dev build-essential autoconf libtool pkg-config make wget git
+sudo apt-get install build-essential git
 ```
 
 #### Raspberry Pi / Raspbian
@@ -326,18 +112,10 @@ conda activate freqtrade
 conda install scipy pandas numpy
 
 sudo apt install libffi-dev
-python3 -m pip install -r requirements-pi.txt
+python3 -m pip install -r requirements-common.txt
 python3 -m pip install -e .
 ```
 
-### MacOS
-
-#### Install Python 3.6, git and wget
-
-```bash
-brew install python3 git wget
-```
-
 ### Common
 
 #### 1. Install TA-Lib
@@ -378,7 +156,7 @@ git clone https://github.com/freqtrade/freqtrade.git
 
 ```
 
-Optionally checkout the stable/master branch:
+Optionally checkout the master branch to get the latest stable release:
 
 ```bash
 git checkout master
@@ -396,9 +174,9 @@ cp config.json.example config.json
 #### 5. Install python dependencies
 
 ``` bash
-pip3 install --upgrade pip
-pip3 install -r requirements.txt
-pip3 install -e .
+python3 -m pip install --upgrade pip
+python3 -m pip install -r requirements.txt
+python3 -m pip install -e .
 ```
 
 #### 6. Run the Bot
@@ -406,10 +184,10 @@ pip3 install -e .
 If this is the first time you run the bot, ensure you are running it in Dry-run `"dry_run": true,` otherwise it will start to buy and sell coins.
 
 ```bash
-python3.6 freqtrade -c config.json
+freqtrade -c config.json
 ```
 
-*Note*: If you run the bot on a server, you should consider using [Docker](#automatic-installation---docker) a terminal multiplexer like `screen` or [`tmux`](https://en.wikipedia.org/wiki/Tmux) to avoid that the bot is stopped on logout.
+*Note*: If you run the bot on a server, you should consider using [Docker](docker.md) or a terminal multiplexer like `screen` or [`tmux`](https://en.wikipedia.org/wiki/Tmux) to avoid that the bot is stopped on logout.
 
 #### 7. [Optional] Configure `freqtrade` as a `systemd` service
 
@@ -436,15 +214,14 @@ when it changes.
 The `freqtrade.service.watchdog` file contains an example of the service unit configuration file which uses systemd 
 as the watchdog.
 
-!!! Note 
-  The sd_notify communication between the bot and the systemd service manager will not work if the bot runs in a 
-  Docker container.
+!!! Note
+    The sd_notify communication between the bot and the systemd service manager will not work if the bot runs in a Docker container.
 
 ------
 
 ## Windows
 
-We recommend that Windows users use [Docker](#docker) as this will work much easier and smoother (also more secure).
+We recommend that Windows users use [Docker](docker.md) as this will work much easier and smoother (also more secure).
 
 If that is not possible, try using the Windows Linux subsystem (WSL) - for which the Ubuntu instructions should work.
 If that is not available on your system, feel free to try the instructions below, which led to success for some.
@@ -457,8 +234,6 @@ If that is not available on your system, feel free to try the instructions below
 git clone https://github.com/freqtrade/freqtrade.git
 ```
 
-copy paste `config.json` to ``\path\freqtrade-develop\freqtrade`
-
 #### Install ta-lib
 
 Install ta-lib according to the [ta-lib documentation](https://github.com/mrjbq7/ta-lib#windows).
@@ -488,7 +263,7 @@ error: Microsoft Visual C++ 14.0 is required. Get it with "Microsoft Visual C++
 
 Unfortunately, many packages requiring compilation don't provide a pre-build wheel. It is therefore mandatory to have a C/C++ compiler installed and available for your python environment to use.
 
-The easiest way is to download install Microsoft Visual Studio Community [here](https://visualstudio.microsoft.com/downloads/) and make sure to install "Common Tools for Visual C++" to enable building c code on Windows. Unfortunately, this is a heavy download / dependency (~4Gb) so you might want to consider WSL or docker first.
+The easiest way is to download install Microsoft Visual Studio Community [here](https://visualstudio.microsoft.com/downloads/) and make sure to install "Common Tools for Visual C++" to enable building c code on Windows. Unfortunately, this is a heavy download / dependency (~4Gb) so you might want to consider WSL or [docker](docker.md) first.
 
 ---
 

docs/plotting.md

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

docs/rest-api.md

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

docs/stoploss.md

@@ -1,4 +1,13 @@
-# Stop Loss support
+# Stop Loss
+
+The `stoploss` configuration parameter is loss in percentage that should trigger a sale.
+For example, value `-0.10` will cause immediate sell if the profit dips below -10% for a given trade. This parameter is optional.
+
+Most of the strategy files already include the optimal `stoploss`
+value. This parameter is optional. If you use it in the configuration file, it will take over the
+`stoploss` value from the strategy file.
+
+## Stop Loss support
 
 At this stage the bot contains the following stoploss support modes:
 
@@ -16,13 +25,12 @@ In case of stoploss on exchange there is another parameter called `stoploss_on_e
 !!! Note
     Stoploss on exchange is only supported for Binance as of now.
 
-
 ## Static Stop Loss
 
 This is very simple, basically you define a stop loss of x in your strategy file or alternative in the configuration, which
 will overwrite the strategy definition. This will basically try to sell your asset, the second the loss exceeds the defined loss.
 
-## Trail Stop Loss
+## Trailing Stop Loss
 
 The initial value for this stop loss, is defined in your strategy or configuration. Just as you would define your Stop Loss normally.
 To enable this Feauture all you have to do is to define the configuration element:
@@ -63,3 +71,13 @@ The 0.01 would translate to a 1% stop loss, once you hit 1.1% profit.
 You should also make sure to have this value (`trailing_stop_positive_offset`) lower than your minimal ROI, otherwise minimal ROI will apply first and sell your trade.
 
 If `"trailing_only_offset_is_reached": true` then the trailing stoploss is only activated once the offset is reached. Until then, the stoploss remains at the configured`stoploss`.
+
+## Changing stoploss on open trades
+
+A stoploss on an open trade can be changed by changing the value in the configuration or strategy and use the `/reload_conf` command (alternatively, completely stopping and restarting the bot also works).
+
+The new stoploss value will be applied to open trades (and corresponding log-messages will be generated).
+
+### Limitations
+
+Stoploss values cannot be changed if `trailing_stop` is enabled and the stoploss has already been adjusted, or if [Edge](edge.md) is enabled (since Edge would recalculate stoploss based on the current market situation).

docs/strategy-customization.md

@@ -5,8 +5,7 @@ indicators.
 
 ## Install a custom strategy file
 
-This is very simple. Copy paste your strategy file into the folder
-`user_data/strategies`.
+This is very simple. Copy paste your strategy file into the directory `user_data/strategies`.
 
 Let assume you have a class called `AwesomeStrategy` in the file `awesome-strategy.py`:
 
@@ -14,7 +13,7 @@ Let assume you have a class called `AwesomeStrategy` in the file `awesome-strate
 2. Start the bot with the param `--strategy AwesomeStrategy` (the parameter is the class name)
 
 ```bash
-python3 freqtrade --strategy AwesomeStrategy
+freqtrade --strategy AwesomeStrategy
 ```
 
 ## Change your strategy
@@ -22,7 +21,7 @@ python3 freqtrade --strategy AwesomeStrategy
 The bot includes a default strategy file. However, we recommend you to
 use your own file to not have to lose your parameters every time the default
 strategy file will be updated on Github. Put your custom strategy file
-into the folder `user_data/strategies`.
+into the directory `user_data/strategies`.
 
 Best copy the test-strategy and modify this copy to avoid having bot-updates override your changes.
 `cp  user_data/strategies/test_strategy.py user_data/strategies/awesome-strategy.py`
@@ -41,7 +40,7 @@ The bot also include a sample strategy called `TestStrategy` you can update: `us
 You can test it with the parameter: `--strategy TestStrategy`
 
 ```bash
-python3 freqtrade --strategy AwesomeStrategy
+freqtrade --strategy AwesomeStrategy
 ```
 
 **For the following section we will use the [user_data/strategies/test_strategy.py](https://github.com/freqtrade/freqtrade/blob/develop/user_data/strategies/test_strategy.py)
@@ -53,6 +52,12 @@ file as reference.**
     It is therefore best to use vectorized operations (across the whole dataframe, not loops) and
     avoid index referencing (`df.iloc[-1]`), but instead use `df.shift()` to get to the previous candle.
 
+!!! Warning Using future data
+    Since backtesting passes the full time interval to the `populate_*()` methods, the strategy author
+    needs to take care to avoid having the strategy utilize data from the future.
+    Samples for usage of future data are `dataframe.shift(-1)`, `dataframe.resample("1h")` (this uses the left border of the interval, so moves data from an hour to the start of the hour).
+    They all use data which is not available during regular operations, so these strategies will perform well during backtesting, but will fail / perform badly in dry-runs.
+
 ### Customize Indicators
 
 Buy and sell strategies need indicators. You can add more indicators by extending the list contained in the method `populate_indicators()` from your strategy file.
@@ -212,9 +217,12 @@ stoploss = -0.10
 ```
 
 This would signify a stoploss of -10%.
+
+For the full documentation on stoploss features, look at the dedicated [stoploss page](stoploss.md).
+
 If your exchange supports it, it's recommended to also set `"stoploss_on_exchange"` in the order dict, so your stoploss is on the exchange and cannot be missed for network-problems (or other problems).
 
-For more information on order_types please look [here](https://github.com/freqtrade/freqtrade/blob/develop/docs/configuration.md#understand-order_types).
+For more information on order_types please look [here](configuration.md#understand-order_types).
 
 ### Ticker interval
 
@@ -292,6 +300,18 @@ if self.dp:
 !!! Warning Warning in hyperopt
     This option cannot currently be used during hyperopt.
 
+#### Orderbook
+
+``` python
+if self.dp:
+    if self.dp.runmode in ('live', 'dry_run'):
+        ob = self.dp.orderbook(metadata['pair'], 1)
+        dataframe['best_bid'] = ob['bids'][0][0]
+        dataframe['best_ask'] = ob['asks'][0][0]
+```
+!Warning The order book is not part of the historic data which means backtesting and hyperopt will not work if this
+ method is used.
+
 #### Available Pairs
 
 ``` python
@@ -300,6 +320,7 @@ if self.dp:
         print(f"available {pair}, {ticker}")
 ```
 
+
 #### Get data for non-tradeable pairs
 
 Data for additional, informative pairs (reference pairs) can be beneficial for some strategies.
@@ -345,6 +366,30 @@ if self.wallets:
 - `get_used(asset)` - currently tied up balance (open orders)
 - `get_total(asset)` - total available balance - sum of the 2 above
 
+### Print created dataframe
+
+To inspect the created dataframe, you can issue a print-statement in either `populate_buy_trend()` or `populate_sell_trend()`.
+You may also want to print the pair so it's clear what data is currently shown.
+
+``` python
+def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
+    dataframe.loc[
+        (
+            #>> whatever condition<<<
+        ),
+        'buy'] = 1
+
+    # Print the Analyzed pair
+    print(f"result for {metadata['pair']}")
+
+    # Inspect the last 5 rows
+    print(dataframe.tail())
+
+    return dataframe
+```
+
+Printing more than a few rows is also possible (simply use  `print(dataframe)` instead of `print(dataframe.tail())`), however not recommended, as that will be very verbose (~500 lines per pair every 5 seconds).
+
 ### Where is the default strategy?
 
 The default buy strategy is located in the file
@@ -352,10 +397,10 @@ The default buy strategy is located in the file
 
 ### Specify custom strategy location
 
-If you want to use a strategy from a different folder you can pass `--strategy-path`
+If you want to use a strategy from a different directory you can pass `--strategy-path`
 
 ```bash
-python3 freqtrade --strategy AwesomeStrategy --strategy-path /some/folder
+freqtrade --strategy AwesomeStrategy --strategy-path /some/directory
 ```
 
 ### Further strategy ideas
@@ -364,7 +409,7 @@ To get additional Ideas for strategies, head over to our [strategy repository](h
 Feel free to use any of them as inspiration for your own strategies.
 We're happy to accept Pull Requests containing new Strategies to that repo.
 
-We also got a *strategy-sharing* channel in our [Slack community](https://join.slack.com/t/highfrequencybot/shared_invite/enQtMjQ5NTM0OTYzMzY3LWMxYzE3M2MxNDdjMGM3ZTYwNzFjMGIwZGRjNTc3ZGU3MGE3NzdmZGMwNmU3NDM5ZTNmM2Y3NjRiNzk4NmM4OGE) which is a great place to get and/or share ideas.
+We also got a *strategy-sharing* channel in our [Slack community](https://join.slack.com/t/highfrequencybot/shared_invite/enQtNjU5ODcwNjI1MDU3LWEyODBiNzkzNzcyNzU0MWYyYzE5NjIyOTQxMzBmMGUxOTIzM2YyN2Y4NWY1YTEwZDgwYTRmMzE2NmM5ZmY2MTg) which is a great place to get and/or share ideas.
 
 ## Next step
 

docs/telegram-usage.md

@@ -1,10 +1,45 @@
 # Telegram usage
 
-## Prerequisite
+## Setup your Telegram bot
 
-To control your bot with Telegram, you need first to
-[set up a Telegram bot](installation.md)
-and add your Telegram API keys into your config file.
+Below we explain how to create your Telegram Bot, and how to get your
+Telegram user id.
+
+### 1. Create your Telegram bot
+
+Start a chat with the [Telegram BotFather](https://telegram.me/BotFather)
+
+Send the message `/newbot`. 
+
+*BotFather response:*
+
+> Alright, a new bot. How are we going to call it? Please choose a name for your bot.
+
+Choose the public name of your bot (e.x. `Freqtrade bot`)
+
+*BotFather response:*
+
+> Good. Now let's choose a username for your bot. It must end in `bot`. Like this, for example: TetrisBot or tetris_bot.
+
+Choose the name id of your bot and send it to the BotFather (e.g. "`My_own_freqtrade_bot`")
+
+*BotFather response:*
+
+> Done! Congratulations on your new bot. You will find it at `t.me/yourbots_name_bot`. You can now add a description, about section and profile picture for your bot, see /help for a list of commands. By the way, when you've finished creating your cool bot, ping our Bot Support if you want a better username for it. Just make sure the bot is fully operational before you do this.
+
+> Use this token to access the HTTP API: `22222222:APITOKEN`
+
+> For a description of the Bot API, see this page: https://core.telegram.org/bots/api Father bot will return you the token (API key)
+
+Copy the API Token (`22222222:APITOKEN` in the above example) and keep use it for the config parameter `token`.
+
+Don't forget to start the conversation with your bot, by clicking `/START` button
+
+### 2. Get your user id
+
+Talk to the [userinfobot](https://telegram.me/userinfobot)
+
+Get your "Id", you will use it for the config parameter `chat_id`.
 
 ## Telegram commands
 
@@ -116,7 +151,7 @@ Return a summary of your profit/loss and performance.
 
 ### /forcebuy <pair>
 
-> **BITTREX**: Buying ETH/BTC with limit `0.03400000` (`1.000000 ETH`, `225.290 USD`)
+> **BITTREX:** Buying ETH/BTC with limit `0.03400000` (`1.000000 ETH`, `225.290 USD`)
 
 Note that for this to work, `forcebuy_enable` needs to be set to true.
 

docs/webhook-config.md

@@ -43,6 +43,7 @@ Possible parameters are:
 * `stake_amount`
 * `stake_currency`
 * `fiat_currency`
+* `order_type`
 
 ### Webhooksell
 
@@ -61,6 +62,7 @@ Possible parameters are:
 * `stake_currency`
 * `fiat_currency`
 * `sell_reason`
+* `order_type`
 
 ### Webhookstatus
 

freqtrade/__init__.py

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

freqtrade/__main__.py

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

freqtrade/arguments.py

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

freqtrade/configuration.py

@@ -1,398 +0,0 @@
-"""
-This module contains the configuration class
-"""
-import json
-import logging
-import os
-import sys
-from argparse import Namespace
-from logging.handlers import RotatingFileHandler
-from typing import Any, Dict, List, Optional
-
-import ccxt
-from jsonschema import Draft4Validator, validate
-from jsonschema.exceptions import ValidationError, best_match
-
-from freqtrade import OperationalException, constants
-from freqtrade.misc import deep_merge_dicts
-from freqtrade.state import RunMode
-
-logger = logging.getLogger(__name__)
-
-
-def set_loggers(log_level: int = 0) -> None:
-    """
-    Set the logger level for Third party libs
-    :return: None
-    """
-
-    logging.getLogger('requests').setLevel(logging.INFO if log_level <= 1 else logging.DEBUG)
-    logging.getLogger("urllib3").setLevel(logging.INFO if log_level <= 1 else logging.DEBUG)
-    logging.getLogger('ccxt.base.exchange').setLevel(
-        logging.INFO if log_level <= 2 else logging.DEBUG)
-    logging.getLogger('telegram').setLevel(logging.INFO)
-
-
-class Configuration(object):
-    """
-    Class to read and init the bot configuration
-    Reuse this class for the bot, backtesting, hyperopt and every script that required configuration
-    """
-
-    def __init__(self, args: Namespace, runmode: RunMode = None) -> None:
-        self.args = args
-        self.config: Optional[Dict[str, Any]] = None
-        self.runmode = runmode
-
-    def load_config(self) -> Dict[str, Any]:
-        """
-        Extract information for sys.argv and load the bot configuration
-        :return: Configuration dictionary
-        """
-        config: Dict[str, Any] = {}
-        # Now expecting a list of config filenames here, not a string
-        for path in self.args.config:
-            logger.info('Using config: %s ...', path)
-            # Merge config options, overwriting old values
-            config = deep_merge_dicts(self._load_config_file(path), config)
-
-        if 'internals' not in config:
-            config['internals'] = {}
-
-        logger.info('Validating configuration ...')
-        self._validate_config_schema(config)
-        self._validate_config_consistency(config)
-
-        # Set strategy if not specified in config and or if it's non default
-        if self.args.strategy != constants.DEFAULT_STRATEGY or not config.get('strategy'):
-            config.update({'strategy': self.args.strategy})
-
-        if self.args.strategy_path:
-            config.update({'strategy_path': self.args.strategy_path})
-
-        # Load Common configuration
-        config = self._load_common_config(config)
-
-        # Load Backtesting
-        config = self._load_backtesting_config(config)
-
-        # Load Edge
-        config = self._load_edge_config(config)
-
-        # Load Hyperopt
-        config = self._load_hyperopt_config(config)
-
-        # Set runmode
-        if not self.runmode:
-            # Handle real mode, infer dry/live from config
-            self.runmode = RunMode.DRY_RUN if config.get('dry_run', True) else RunMode.LIVE
-
-        config.update({'runmode': self.runmode})
-
-        return config
-
-    def _load_config_file(self, path: str) -> Dict[str, Any]:
-        """
-        Loads a config file from the given path
-        :param path: path as str
-        :return: configuration as dictionary
-        """
-        try:
-            with open(path) as file:
-                conf = json.load(file)
-        except FileNotFoundError:
-            raise OperationalException(
-                f'Config file "{path}" not found!'
-                ' Please create a config file or check whether it exists.')
-
-        return conf
-
-    def _load_common_config(self, config: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Extract information for sys.argv and load common configuration
-        :return: configuration as dictionary
-        """
-
-        # Log level
-        if 'loglevel' in self.args and self.args.loglevel:
-            config.update({'verbosity': self.args.loglevel})
-        else:
-            config.update({'verbosity': 0})
-
-        # Log to stdout, not stderr
-        log_handlers: List[logging.Handler] = [logging.StreamHandler(sys.stdout)]
-        if 'logfile' in self.args and self.args.logfile:
-            config.update({'logfile': self.args.logfile})
-
-        # Allow setting this as either configuration or argument
-        if 'logfile' in config:
-            log_handlers.append(RotatingFileHandler(config['logfile'],
-                                                    maxBytes=1024 * 1024,  # 1Mb
-                                                    backupCount=10))
-
-        logging.basicConfig(
-            level=logging.INFO if config['verbosity'] < 1 else logging.DEBUG,
-            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-            handlers=log_handlers
-        )
-        set_loggers(config['verbosity'])
-        logger.info('Verbosity set to %s', config['verbosity'])
-
-        # Support for sd_notify
-        if self.args.sd_notify:
-            config['internals'].update({'sd_notify': True})
-
-        # Add dynamic_whitelist if found
-        if 'dynamic_whitelist' in self.args and self.args.dynamic_whitelist:
-            # Update to volumePairList (the previous default)
-            config['pairlist'] = {'method': 'VolumePairList',
-                                  'config': {'number_assets': self.args.dynamic_whitelist}
-                                  }
-            logger.warning(
-                'Parameter --dynamic-whitelist has been deprecated, '
-                'and will be completely replaced by the whitelist dict in the future. '
-                'For now: using dynamically generated whitelist based on VolumePairList. '
-                '(not applicable with Backtesting and Hyperopt)'
-            )
-
-        if self.args.db_url and self.args.db_url != constants.DEFAULT_DB_PROD_URL:
-            config.update({'db_url': self.args.db_url})
-            logger.info('Parameter --db-url detected ...')
-
-        if config.get('dry_run', False):
-            logger.info('Dry run is enabled')
-            if config.get('db_url') in [None, constants.DEFAULT_DB_PROD_URL]:
-                # Default to in-memory db for dry_run if not specified
-                config['db_url'] = constants.DEFAULT_DB_DRYRUN_URL
-        else:
-            if not config.get('db_url', None):
-                config['db_url'] = constants.DEFAULT_DB_PROD_URL
-            logger.info('Dry run is disabled')
-
-        if config.get('forcebuy_enable', False):
-            logger.warning('`forcebuy` RPC message enabled.')
-
-        # Setting max_open_trades to infinite if -1
-        if config.get('max_open_trades') == -1:
-            config['max_open_trades'] = float('inf')
-
-        logger.info(f'Using DB: "{config["db_url"]}"')
-
-        # Check if the exchange set by the user is supported
-        self.check_exchange(config)
-
-        return config
-
-    def _create_datadir(self, config: Dict[str, Any], datadir: Optional[str] = None) -> str:
-        if not datadir:
-            # set datadir
-            exchange_name = config.get('exchange', {}).get('name').lower()
-            datadir = os.path.join('user_data', 'data', exchange_name)
-
-        if not os.path.isdir(datadir):
-            os.makedirs(datadir)
-            logger.info(f'Created data directory: {datadir}')
-        return datadir
-
-    def _load_backtesting_config(self, config: Dict[str, Any]) -> Dict[str, Any]:  # noqa: C901
-        """
-        Extract information for sys.argv and load Backtesting configuration
-        :return: configuration as dictionary
-        """
-
-        # If -i/--ticker-interval is used we override the configuration parameter
-        # (that will override the strategy configuration)
-        if 'ticker_interval' in self.args and self.args.ticker_interval:
-            config.update({'ticker_interval': self.args.ticker_interval})
-            logger.info('Parameter -i/--ticker-interval detected ...')
-            logger.info('Using ticker_interval: %s ...', config.get('ticker_interval'))
-
-        # If -l/--live is used we add it to the configuration
-        if 'live' in self.args and self.args.live:
-            config.update({'live': True})
-            logger.info('Parameter -l/--live detected ...')
-
-        # If --enable-position-stacking is used we add it to the configuration
-        if 'position_stacking' in self.args and self.args.position_stacking:
-            config.update({'position_stacking': True})
-            logger.info('Parameter --enable-position-stacking detected ...')
-
-        # If --disable-max-market-positions or --max_open_trades is used we update configuration
-        if 'use_max_market_positions' in self.args and not self.args.use_max_market_positions:
-            config.update({'use_max_market_positions': False})
-            logger.info('Parameter --disable-max-market-positions detected ...')
-            logger.info('max_open_trades set to unlimited ...')
-        elif 'max_open_trades' in self.args and self.args.max_open_trades:
-            config.update({'max_open_trades': self.args.max_open_trades})
-            logger.info('Parameter --max_open_trades detected, '
-                        'overriding max_open_trades to: %s ...', config.get('max_open_trades'))
-        else:
-            logger.info('Using max_open_trades: %s ...', config.get('max_open_trades'))
-
-        # If --stake_amount is used we update configuration
-        if 'stake_amount' in self.args and self.args.stake_amount:
-            config.update({'stake_amount': self.args.stake_amount})
-            logger.info('Parameter --stake_amount detected, overriding stake_amount to: %s ...',
-                        config.get('stake_amount'))
-
-        # If --timerange is used we add it to the configuration
-        if 'timerange' in self.args and self.args.timerange:
-            config.update({'timerange': self.args.timerange})
-            logger.info('Parameter --timerange detected: %s ...', self.args.timerange)
-
-        # If --datadir is used we add it to the configuration
-        if 'datadir' in self.args and self.args.datadir:
-            config.update({'datadir': self._create_datadir(config, self.args.datadir)})
-        else:
-            config.update({'datadir': self._create_datadir(config, None)})
-        logger.info('Using data folder: %s ...', config.get('datadir'))
-
-        # If -r/--refresh-pairs-cached is used we add it to the configuration
-        if 'refresh_pairs' in self.args and self.args.refresh_pairs:
-            config.update({'refresh_pairs': True})
-            logger.info('Parameter -r/--refresh-pairs-cached detected ...')
-
-        if 'strategy_list' in self.args and self.args.strategy_list:
-            config.update({'strategy_list': self.args.strategy_list})
-            logger.info('Using strategy list of %s Strategies', len(self.args.strategy_list))
-
-        if 'ticker_interval' in self.args and self.args.ticker_interval:
-            config.update({'ticker_interval': self.args.ticker_interval})
-            logger.info('Overriding ticker interval with Command line argument')
-
-        # If --export is used we add it to the configuration
-        if 'export' in self.args and self.args.export:
-            config.update({'export': self.args.export})
-            logger.info('Parameter --export detected: %s ...', self.args.export)
-
-        # If --export-filename is used we add it to the configuration
-        if 'export' in config and 'exportfilename' in self.args and self.args.exportfilename:
-            config.update({'exportfilename': self.args.exportfilename})
-            logger.info('Storing backtest results to %s ...', self.args.exportfilename)
-
-        return config
-
-    def _load_edge_config(self, config: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Extract information for sys.argv and load Edge configuration
-        :return: configuration as dictionary
-        """
-
-        # If --timerange is used we add it to the configuration
-        if 'timerange' in self.args and self.args.timerange:
-            config.update({'timerange': self.args.timerange})
-            logger.info('Parameter --timerange detected: %s ...', self.args.timerange)
-
-        # If --timerange is used we add it to the configuration
-        if 'stoploss_range' in self.args and self.args.stoploss_range:
-            txt_range = eval(self.args.stoploss_range)
-            config['edge'].update({'stoploss_range_min': txt_range[0]})
-            config['edge'].update({'stoploss_range_max': txt_range[1]})
-            config['edge'].update({'stoploss_range_step': txt_range[2]})
-            logger.info('Parameter --stoplosses detected: %s ...', self.args.stoploss_range)
-
-        # If -r/--refresh-pairs-cached is used we add it to the configuration
-        if 'refresh_pairs' in self.args and self.args.refresh_pairs:
-            config.update({'refresh_pairs': True})
-            logger.info('Parameter -r/--refresh-pairs-cached detected ...')
-
-        return config
-
-    def _load_hyperopt_config(self, config: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Extract information for sys.argv and load Hyperopt configuration
-        :return: configuration as dictionary
-        """
-
-        if "hyperopt" in self.args:
-            # Add the hyperopt file to use
-            config.update({'hyperopt': self.args.hyperopt})
-
-        # If --epochs is used we add it to the configuration
-        if 'epochs' in self.args and self.args.epochs:
-            config.update({'epochs': self.args.epochs})
-            logger.info('Parameter --epochs detected ...')
-            logger.info('Will run Hyperopt with for %s epochs ...', config.get('epochs'))
-
-        # If --spaces is used we add it to the configuration
-        if 'spaces' in self.args and self.args.spaces:
-            config.update({'spaces': self.args.spaces})
-            logger.info('Parameter -s/--spaces detected: %s', config.get('spaces'))
-
-        return config
-
-    def _validate_config_schema(self, conf: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Validate the configuration follow the Config Schema
-        :param conf: Config in JSON format
-        :return: Returns the config if valid, otherwise throw an exception
-        """
-        try:
-            validate(conf, constants.CONF_SCHEMA, Draft4Validator)
-            return conf
-        except ValidationError as exception:
-            logger.critical(
-                'Invalid configuration. See config.json.example. Reason: %s',
-                exception
-            )
-            raise ValidationError(
-                best_match(Draft4Validator(constants.CONF_SCHEMA).iter_errors(conf)).message
-            )
-
-    def _validate_config_consistency(self, conf: Dict[str, Any]) -> None:
-        """
-        Validate the configuration consistency
-        :param conf: Config in JSON format
-        :return: Returns None if everything is ok, otherwise throw an OperationalException
-        """
-
-        # validating trailing stoploss
-        self._validate_trailing_stoploss(conf)
-
-    def _validate_trailing_stoploss(self, conf: Dict[str, Any]) -> None:
-        # Skip if trailing stoploss is not activated
-        if not conf.get('trailing_stop', False):
-            return
-
-        tsl_positive = float(conf.get('trailing_stop_positive', 0))
-        tsl_offset = float(conf.get('trailing_stop_positive_offset', 0))
-        tsl_only_offset = conf.get('trailing_only_offset_is_reached', False)
-
-        if tsl_only_offset:
-            if tsl_positive == 0.0:
-                raise OperationalException(
-                    f'The config trailing_only_offset_is_reached needs '
-                    'trailing_stop_positive_offset to be more than 0 in your config.')
-        if tsl_positive > 0 and 0 < tsl_offset <= tsl_positive:
-            raise OperationalException(
-                f'The config trailing_stop_positive_offset needs '
-                'to be greater than trailing_stop_positive_offset in your config.')
-
-    def get_config(self) -> Dict[str, Any]:
-        """
-        Return the config. Use this method to get the bot config
-        :return: Dict: Bot config
-        """
-        if self.config is None:
-            self.config = self.load_config()
-
-        return self.config
-
-    def check_exchange(self, config: Dict[str, Any]) -> bool:
-        """
-        Check if the exchange name in the config file is supported by Freqtrade
-        :return: True or raised an exception if the exchange if not supported
-        """
-        exchange = config.get('exchange', {}).get('name').lower()
-        if exchange not in ccxt.exchanges:
-
-            exception_msg = f'Exchange "{exchange}" not supported.\n' \
-                            f'The following exchanges are supported: {", ".join(ccxt.exchanges)}'
-
-            logger.critical(exception_msg)
-            raise OperationalException(
-                exception_msg
-            )
-
-        logger.debug('Exchange "%s" supported', exchange)
-        return True

freqtrade/configuration/__init__.py

@@ -0,0 +1,2 @@
+from freqtrade.configuration.arguments import Arguments, TimeRange  # noqa: F401
+from freqtrade.configuration.configuration import Configuration  # noqa: F401

freqtrade/configuration/arguments.py

@@ -0,0 +1,176 @@
+"""
+This module contains the argument manager class
+"""
+import argparse
+import re
+from typing import List, NamedTuple, Optional
+
+import arrow
+from freqtrade.configuration.cli_options import AVAILABLE_CLI_OPTIONS
+from freqtrade import constants
+
+ARGS_COMMON = ["verbosity", "logfile", "version", "config", "datadir"]
+
+ARGS_STRATEGY = ["strategy", "strategy_path"]
+
+ARGS_MAIN = ARGS_COMMON + ARGS_STRATEGY + ["db_url", "sd_notify"]
+
+ARGS_COMMON_OPTIMIZE = ["ticker_interval", "timerange",
+                        "max_open_trades", "stake_amount", "refresh_pairs"]
+
+ARGS_BACKTEST = ARGS_COMMON_OPTIMIZE + ["position_stacking", "use_max_market_positions",
+                                        "live", "strategy_list", "export", "exportfilename"]
+
+ARGS_HYPEROPT = ARGS_COMMON_OPTIMIZE + ["hyperopt", "hyperopt_path",
+                                        "position_stacking", "epochs", "spaces",
+                                        "use_max_market_positions", "print_all", "hyperopt_jobs",
+                                        "hyperopt_random_state", "hyperopt_min_trades",
+                                        "hyperopt_continue", "hyperopt_loss"]
+
+ARGS_EDGE = ARGS_COMMON_OPTIMIZE + ["stoploss_range"]
+
+ARGS_LIST_EXCHANGES = ["print_one_column"]
+
+ARGS_DOWNLOADER = ARGS_COMMON + ["pairs", "pairs_file", "days", "exchange", "timeframes", "erase"]
+
+ARGS_PLOT_DATAFRAME = (ARGS_COMMON + ARGS_STRATEGY +
+                       ["pairs", "indicators1", "indicators2", "plot_limit", "db_url",
+                        "trade_source", "export", "exportfilename", "timerange",
+                        "refresh_pairs", "live"])
+
+ARGS_PLOT_PROFIT = (ARGS_COMMON + ARGS_STRATEGY +
+                    ["pairs", "timerange", "export", "exportfilename", "db_url", "trade_source"])
+
+
+class TimeRange(NamedTuple):
+    """
+    NamedTuple defining timerange inputs.
+    [start/stop]type defines if [start/stop]ts shall be used.
+    if *type is None, don't use corresponding startvalue.
+    """
+    starttype: Optional[str] = None
+    stoptype: Optional[str] = None
+    startts: int = 0
+    stopts: int = 0
+
+
+class Arguments(object):
+    """
+    Arguments Class. Manage the arguments received by the cli
+    """
+    def __init__(self, args: Optional[List[str]], description: str,
+                 no_default_config: bool = False) -> None:
+        self.args = args
+        self._parsed_arg: Optional[argparse.Namespace] = None
+        self.parser = argparse.ArgumentParser(description=description)
+        self._no_default_config = no_default_config
+
+    def _load_args(self) -> None:
+        self._build_args(optionlist=ARGS_MAIN)
+        self._build_subcommands()
+
+    def get_parsed_arg(self) -> argparse.Namespace:
+        """
+        Return the list of arguments
+        :return: List[str] List of arguments
+        """
+        if self._parsed_arg is None:
+            self._load_args()
+            self._parsed_arg = self._parse_args()
+
+        return self._parsed_arg
+
+    def _parse_args(self) -> argparse.Namespace:
+        """
+        Parses given arguments and returns an argparse Namespace instance.
+        """
+        parsed_arg = self.parser.parse_args(self.args)
+
+        # Workaround issue in argparse with action='append' and default value
+        # (see https://bugs.python.org/issue16399)
+        if not self._no_default_config and parsed_arg.config is None:
+            parsed_arg.config = [constants.DEFAULT_CONFIG]
+
+        return parsed_arg
+
+    def _build_args(self, optionlist, parser=None):
+        parser = parser or self.parser
+
+        for val in optionlist:
+            opt = AVAILABLE_CLI_OPTIONS[val]
+            parser.add_argument(*opt.cli, dest=val, **opt.kwargs)
+
+    def _build_subcommands(self) -> None:
+        """
+        Builds and attaches all subcommands.
+        :return: None
+        """
+        from freqtrade.optimize import start_backtesting, start_hyperopt, start_edge
+        from freqtrade.utils import start_list_exchanges
+
+        subparsers = self.parser.add_subparsers(dest='subparser')
+
+        # Add backtesting subcommand
+        backtesting_cmd = subparsers.add_parser('backtesting', help='Backtesting module.')
+        backtesting_cmd.set_defaults(func=start_backtesting)
+        self._build_args(optionlist=ARGS_BACKTEST, parser=backtesting_cmd)
+
+        # Add edge subcommand
+        edge_cmd = subparsers.add_parser('edge', help='Edge module.')
+        edge_cmd.set_defaults(func=start_edge)
+        self._build_args(optionlist=ARGS_EDGE, parser=edge_cmd)
+
+        # Add hyperopt subcommand
+        hyperopt_cmd = subparsers.add_parser('hyperopt', help='Hyperopt module.')
+        hyperopt_cmd.set_defaults(func=start_hyperopt)
+        self._build_args(optionlist=ARGS_HYPEROPT, parser=hyperopt_cmd)
+
+        # Add list-exchanges subcommand
+        list_exchanges_cmd = subparsers.add_parser(
+            'list-exchanges',
+            help='Print available exchanges.'
+        )
+        list_exchanges_cmd.set_defaults(func=start_list_exchanges)
+        self._build_args(optionlist=ARGS_LIST_EXCHANGES, parser=list_exchanges_cmd)
+
+    @staticmethod
+    def parse_timerange(text: Optional[str]) -> TimeRange:
+        """
+        Parse the value of the argument --timerange to determine what is the range desired
+        :param text: value from --timerange
+        :return: Start and End range period
+        """
+        if text is None:
+            return TimeRange(None, None, 0, 0)
+        syntax = [(r'^-(\d{8})$', (None, 'date')),
+                  (r'^(\d{8})-$', ('date', None)),
+                  (r'^(\d{8})-(\d{8})$', ('date', 'date')),
+                  (r'^-(\d{10})$', (None, 'date')),
+                  (r'^(\d{10})-$', ('date', None)),
+                  (r'^(\d{10})-(\d{10})$', ('date', 'date')),
+                  (r'^(-\d+)$', (None, 'line')),
+                  (r'^(\d+)-$', ('line', None)),
+                  (r'^(\d+)-(\d+)$', ('index', 'index'))]
+        for rex, stype in syntax:
+            # Apply the regular expression to text
+            match = re.match(rex, text)
+            if match:  # Regex has matched
+                rvals = match.groups()
+                index = 0
+                start: int = 0
+                stop: int = 0
+                if stype[0]:
+                    starts = rvals[index]
+                    if stype[0] == 'date' and len(starts) == 8:
+                        start = arrow.get(starts, 'YYYYMMDD').timestamp
+                    else:
+                        start = int(starts)
+                    index += 1
+                if stype[1]:
+                    stops = rvals[index]
+                    if stype[1] == 'date' and len(stops) == 8:
+                        stop = arrow.get(stops, 'YYYYMMDD').timestamp
+                    else:
+                        stop = int(stops)
+                return TimeRange(stype[0], stype[1], start, stop)
+        raise Exception('Incorrect syntax for timerange "%s"' % text)

freqtrade/configuration/check_exchange.py

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

freqtrade/configuration/cli_options.py

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

freqtrade/configuration/configuration.py

@@ -0,0 +1,346 @@
+"""
+This module contains the configuration class
+"""
+import json
+import logging
+import sys
+import warnings
+from argparse import Namespace
+from typing import Any, Callable, Dict, Optional
+
+from freqtrade import OperationalException, constants
+from freqtrade.configuration.check_exchange import check_exchange
+from freqtrade.configuration.create_datadir import create_datadir
+from freqtrade.configuration.json_schema import validate_config_schema
+from freqtrade.loggers import setup_logging
+from freqtrade.misc import deep_merge_dicts
+from freqtrade.state import RunMode
+
+logger = logging.getLogger(__name__)
+
+
+class Configuration(object):
+    """
+    Class to read and init the bot configuration
+    Reuse this class for the bot, backtesting, hyperopt and every script that required configuration
+    """
+
+    def __init__(self, args: Namespace, runmode: RunMode = None) -> None:
+        self.args = args
+        self.config: Optional[Dict[str, Any]] = None
+        self.runmode = runmode
+
+    def get_config(self) -> Dict[str, Any]:
+        """
+        Return the config. Use this method to get the bot config
+        :return: Dict: Bot config
+        """
+        if self.config is None:
+            self.config = self.load_config()
+
+        return self.config
+
+    def _load_config_files(self) -> Dict[str, Any]:
+        """
+        Iterate through the config files passed in the args,
+        loading all of them and merging their contents.
+        """
+        config: Dict[str, Any] = {}
+
+        # We expect here a list of config filenames
+        for path in self.args.config:
+            logger.info('Using config: %s ...', path)
+
+            # Merge config options, overwriting old values
+            config = deep_merge_dicts(self._load_config_file(path), config)
+
+        return config
+
+    def _load_config_file(self, path: str) -> Dict[str, Any]:
+        """
+        Loads a config file from the given path
+        :param path: path as str
+        :return: configuration as dictionary
+        """
+        try:
+            # Read config from stdin if requested in the options
+            with open(path) if path != '-' else sys.stdin as file:
+                config = json.load(file)
+        except FileNotFoundError:
+            raise OperationalException(
+                f'Config file "{path}" not found!'
+                ' Please create a config file or check whether it exists.')
+
+        return config
+
+    def _normalize_config(self, config: Dict[str, Any]) -> None:
+        """
+        Make config more canonical -- i.e. for example add missing parts that we expect
+        to be normally in it...
+        """
+        if 'internals' not in config:
+            config['internals'] = {}
+
+    def load_config(self) -> Dict[str, Any]:
+        """
+        Extract information for sys.argv and load the bot configuration
+        :return: Configuration dictionary
+        """
+        # Load all configs
+        config: Dict[str, Any] = self._load_config_files()
+
+        # Make resulting config more canonical
+        self._normalize_config(config)
+
+        logger.info('Validating configuration ...')
+        validate_config_schema(config)
+
+        self._validate_config_consistency(config)
+
+        self._process_common_options(config)
+
+        self._process_optimize_options(config)
+
+        self._process_plot_options(config)
+
+        self._process_runmode(config)
+
+        return config
+
+    def _process_logging_options(self, config: Dict[str, Any]) -> None:
+        """
+        Extract information for sys.argv and load logging configuration:
+        the -v/--verbose, --logfile options
+        """
+        # Log level
+        if 'verbosity' in self.args and self.args.verbosity:
+            config.update({'verbosity': self.args.verbosity})
+        else:
+            config.update({'verbosity': 0})
+
+        if 'logfile' in self.args and self.args.logfile:
+            config.update({'logfile': self.args.logfile})
+
+        setup_logging(config)
+
+    def _process_strategy_options(self, config: Dict[str, Any]) -> None:
+
+        # Set strategy if not specified in config and or if it's non default
+        if self.args.strategy != constants.DEFAULT_STRATEGY or not config.get('strategy'):
+            config.update({'strategy': self.args.strategy})
+
+        self._args_to_config(config, argname='strategy_path',
+                             logstring='Using additional Strategy lookup path: {}')
+
+    def _process_common_options(self, config: Dict[str, Any]) -> None:
+
+        self._process_logging_options(config)
+        self._process_strategy_options(config)
+
+        if ('db_url' in self.args and self.args.db_url and
+                self.args.db_url != constants.DEFAULT_DB_PROD_URL):
+            config.update({'db_url': self.args.db_url})
+            logger.info('Parameter --db-url detected ...')
+
+        if config.get('dry_run', False):
+            logger.info('Dry run is enabled')
+            if config.get('db_url') in [None, constants.DEFAULT_DB_PROD_URL]:
+                # Default to in-memory db for dry_run if not specified
+                config['db_url'] = constants.DEFAULT_DB_DRYRUN_URL
+        else:
+            if not config.get('db_url', None):
+                config['db_url'] = constants.DEFAULT_DB_PROD_URL
+            logger.info('Dry run is disabled')
+
+        logger.info(f'Using DB: "{config["db_url"]}"')
+
+        if config.get('forcebuy_enable', False):
+            logger.warning('`forcebuy` RPC message enabled.')
+
+        # Setting max_open_trades to infinite if -1
+        if config.get('max_open_trades') == -1:
+            config['max_open_trades'] = float('inf')
+
+        # Support for sd_notify
+        if 'sd_notify' in self.args and self.args.sd_notify:
+            config['internals'].update({'sd_notify': True})
+
+        # Check if the exchange set by the user is supported
+        check_exchange(config)
+
+    def _process_datadir_options(self, config: Dict[str, Any]) -> None:
+        """
+        Extract information for sys.argv and load datadir configuration:
+        the --datadir option
+        """
+        if 'datadir' in self.args and self.args.datadir:
+            config.update({'datadir': create_datadir(config, self.args.datadir)})
+        else:
+            config.update({'datadir': create_datadir(config, None)})
+        logger.info('Using data directory: %s ...', config.get('datadir'))
+
+    def _process_optimize_options(self, config: Dict[str, Any]) -> None:
+
+        # This will override the strategy configuration
+        self._args_to_config(config, argname='ticker_interval',
+                             logstring='Parameter -i/--ticker-interval detected ... '
+                             'Using ticker_interval: {} ...')
+
+        self._args_to_config(config, argname='live',
+                             logstring='Parameter -l/--live detected ...',
+                             deprecated_msg='--live will be removed soon.')
+
+        self._args_to_config(config, argname='position_stacking',
+                             logstring='Parameter --enable-position-stacking detected ...')
+
+        if 'use_max_market_positions' in self.args and not self.args.use_max_market_positions:
+            config.update({'use_max_market_positions': False})
+            logger.info('Parameter --disable-max-market-positions detected ...')
+            logger.info('max_open_trades set to unlimited ...')
+        elif 'max_open_trades' in self.args and self.args.max_open_trades:
+            config.update({'max_open_trades': self.args.max_open_trades})
+            logger.info('Parameter --max_open_trades detected, '
+                        'overriding max_open_trades to: %s ...', config.get('max_open_trades'))
+        else:
+            logger.info('Using max_open_trades: %s ...', config.get('max_open_trades'))
+
+        self._args_to_config(config, argname='stake_amount',
+                             logstring='Parameter --stake_amount detected, '
+                             'overriding stake_amount to: {} ...')
+
+        self._args_to_config(config, argname='timerange',
+                             logstring='Parameter --timerange detected: {} ...')
+
+        self._process_datadir_options(config)
+
+        self._args_to_config(config, argname='refresh_pairs',
+                             logstring='Parameter -r/--refresh-pairs-cached detected ...')
+
+        self._args_to_config(config, argname='strategy_list',
+                             logstring='Using strategy list of {} Strategies', logfun=len)
+
+        self._args_to_config(config, argname='ticker_interval',
+                             logstring='Overriding ticker interval with Command line argument')
+
+        self._args_to_config(config, argname='export',
+                             logstring='Parameter --export detected: {} ...')
+
+        self._args_to_config(config, argname='exportfilename',
+                             logstring='Storing backtest results to {} ...')
+
+        # Edge section:
+        if 'stoploss_range' in self.args and self.args.stoploss_range:
+            txt_range = eval(self.args.stoploss_range)
+            config['edge'].update({'stoploss_range_min': txt_range[0]})
+            config['edge'].update({'stoploss_range_max': txt_range[1]})
+            config['edge'].update({'stoploss_range_step': txt_range[2]})
+            logger.info('Parameter --stoplosses detected: %s ...', self.args.stoploss_range)
+
+        # Hyperopt section
+        self._args_to_config(config, argname='hyperopt',
+                             logstring='Using Hyperopt file {}')
+
+        self._args_to_config(config, argname='hyperopt_path',
+                             logstring='Using additional Hyperopt lookup path: {}')
+
+        self._args_to_config(config, argname='epochs',
+                             logstring='Parameter --epochs detected ... '
+                             'Will run Hyperopt with for {} epochs ...'
+                             )
+
+        self._args_to_config(config, argname='spaces',
+                             logstring='Parameter -s/--spaces detected: {}')
+
+        self._args_to_config(config, argname='print_all',
+                             logstring='Parameter --print-all detected ...')
+
+        self._args_to_config(config, argname='hyperopt_jobs',
+                             logstring='Parameter -j/--job-workers detected: {}')
+
+        self._args_to_config(config, argname='hyperopt_random_state',
+                             logstring='Parameter --random-state detected: {}')
+
+        self._args_to_config(config, argname='hyperopt_min_trades',
+                             logstring='Parameter --min-trades detected: {}')
+
+        self._args_to_config(config, argname='hyperopt_continue',
+                             logstring='Hyperopt continue: {}')
+
+        self._args_to_config(config, argname='hyperopt_loss',
+                             logstring='Using loss function: {}')
+
+    def _process_plot_options(self, config: Dict[str, Any]) -> None:
+
+        self._args_to_config(config, argname='pairs',
+                             logstring='Using pairs {}')
+
+        self._args_to_config(config, argname='indicators1',
+                             logstring='Using indicators1: {}')
+
+        self._args_to_config(config, argname='indicators2',
+                             logstring='Using indicators2: {}')
+
+        self._args_to_config(config, argname='plot_limit',
+                             logstring='Limiting plot to: {}')
+        self._args_to_config(config, argname='trade_source',
+                             logstring='Using trades from: {}')
+
+    def _process_runmode(self, config: Dict[str, Any]) -> None:
+
+        if not self.runmode:
+            # Handle real mode, infer dry/live from config
+            self.runmode = RunMode.DRY_RUN if config.get('dry_run', True) else RunMode.LIVE
+            logger.info("Runmode set to {self.runmode}.")
+
+        config.update({'runmode': self.runmode})
+
+    def _validate_config_consistency(self, conf: Dict[str, Any]) -> None:
+        """
+        Validate the configuration consistency
+        :param conf: Config in JSON format
+        :return: Returns None if everything is ok, otherwise throw an OperationalException
+        """
+        # validating trailing stoploss
+        self._validate_trailing_stoploss(conf)
+
+    def _validate_trailing_stoploss(self, conf: Dict[str, Any]) -> None:
+
+        # Skip if trailing stoploss is not activated
+        if not conf.get('trailing_stop', False):
+            return
+
+        tsl_positive = float(conf.get('trailing_stop_positive', 0))
+        tsl_offset = float(conf.get('trailing_stop_positive_offset', 0))
+        tsl_only_offset = conf.get('trailing_only_offset_is_reached', False)
+
+        if tsl_only_offset:
+            if tsl_positive == 0.0:
+                raise OperationalException(
+                    f'The config trailing_only_offset_is_reached needs '
+                    'trailing_stop_positive_offset to be more than 0 in your config.')
+        if tsl_positive > 0 and 0 < tsl_offset <= tsl_positive:
+            raise OperationalException(
+                f'The config trailing_stop_positive_offset needs '
+                'to be greater than trailing_stop_positive_offset in your config.')
+
+    def _args_to_config(self, config: Dict[str, Any], argname: str,
+                        logstring: str, logfun: Optional[Callable] = None,
+                        deprecated_msg: Optional[str] = None) -> None:
+        """
+        :param config: Configuration dictionary
+        :param argname: Argumentname in self.args - will be copied to config dict.
+        :param logstring: Logging String
+        :param logfun: logfun is applied to the configuration entry before passing
+                        that entry to the log string using .format().
+                        sample: logfun=len (prints the length of the found
+                        configuration instead of the content)
+        """
+        if argname in self.args and getattr(self.args, argname):
+
+            config.update({argname: getattr(self.args, argname)})
+            if logfun:
+                logger.info(logstring.format(logfun(config[argname])))
+            else:
+                logger.info(logstring.format(config[argname]))
+            if deprecated_msg:
+                warnings.warn(f"DEPRECATED: {deprecated_msg}", DeprecationWarning)

freqtrade/configuration/create_datadir.py

@@ -0,0 +1,20 @@
+import logging
+from typing import Any, Dict, Optional
+from pathlib import Path
+
+
+logger = logging.getLogger(__name__)
+
+
+def create_datadir(config: Dict[str, Any], datadir: Optional[str] = None) -> str:
+
+    folder = Path(datadir) if datadir else Path('user_data/data')
+    if not datadir:
+        # set datadir
+        exchange_name = config.get('exchange', {}).get('name').lower()
+        folder = folder.joinpath(exchange_name)
+
+    if not folder.is_dir():
+        folder.mkdir(parents=True)
+        logger.info(f'Created data directory: {datadir}')
+    return str(folder)

freqtrade/configuration/json_schema.py

@@ -0,0 +1,53 @@
+import logging
+from typing import Any, Dict
+
+from jsonschema import Draft4Validator, validators
+from jsonschema.exceptions import ValidationError, best_match
+
+from freqtrade import constants
+
+
+logger = logging.getLogger(__name__)
+
+
+def _extend_validator(validator_class):
+    """
+    Extended validator for the Freqtrade configuration JSON Schema.
+    Currently it only handles defaults for subschemas.
+    """
+    validate_properties = validator_class.VALIDATORS['properties']
+
+    def set_defaults(validator, properties, instance, schema):
+        for prop, subschema in properties.items():
+            if 'default' in subschema:
+                instance.setdefault(prop, subschema['default'])
+
+        for error in validate_properties(
+            validator, properties, instance, schema,
+        ):
+            yield error
+
+    return validators.extend(
+        validator_class, {'properties': set_defaults}
+    )
+
+
+FreqtradeValidator = _extend_validator(Draft4Validator)
+
+
+def validate_config_schema(conf: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Validate the configuration follow the Config Schema
+    :param conf: Config in JSON format
+    :return: Returns the config if valid, otherwise throw an exception
+    """
+    try:
+        FreqtradeValidator(constants.CONF_SCHEMA).validate(conf)
+        return conf
+    except ValidationError as e:
+        logger.critical(
+            f"Invalid configuration. See config.json.example. Reason: {e}"
+        )
+        raise ValidationError(
+            best_match(Draft4Validator(constants.CONF_SCHEMA).iter_errors(conf)).message
+        )

freqtrade/constants.py

@@ -4,6 +4,7 @@
 bot constants
 """
 DEFAULT_CONFIG = 'config.json'
+DEFAULT_EXCHANGE = 'bittrex'
 DYNAMIC_WHITELIST = 20  # pairs
 PROCESS_THROTTLE_SECS = 5  # sec
 DEFAULT_TICKER_INTERVAL = 5  # min
@@ -11,6 +12,7 @@ HYPEROPT_EPOCH = 100  # epochs
 RETRY_TIMEOUT = 30  # sec
 DEFAULT_STRATEGY = 'DefaultStrategy'
 DEFAULT_HYPEROPT = 'DefaultHyperOpts'
+DEFAULT_HYPEROPT_LOSS = 'DefaultHyperOptLoss'
 DEFAULT_DB_PROD_URL = 'sqlite:///tradesv3.sqlite'
 DEFAULT_DB_DRYRUN_URL = 'sqlite://'
 UNLIMITED_STAKE_AMOUNT = 'unlimited'
@@ -21,6 +23,7 @@ ORDERTYPE_POSSIBILITIES = ['limit', 'market']
 ORDERTIF_POSSIBILITIES = ['gtc', 'fok', 'ioc']
 AVAILABLE_PAIRLISTS = ['StaticPairList', 'VolumePairList']
 DRY_RUN_WALLET = 999.9
+DEFAULT_DOWNLOAD_TICKER_INTERVALS = '1m 5m'
 
 TICKER_INTERVALS = [
     '1m', '3m', '5m', '15m', '30m',
@@ -156,6 +159,21 @@ CONF_SCHEMA = {
                 'webhookstatus': {'type': 'object'},
             },
         },
+        'api_server': {
+            'type': 'object',
+            'properties': {
+                'enabled': {'type': 'boolean'},
+                'listen_ip_address': {'format': 'ipv4'},
+                'listen_port': {
+                    'type': 'integer',
+                    "minimum": 1024,
+                    "maximum": 65535
+                },
+                'username': {'type': 'string'},
+                'password': {'type': 'string'},
+            },
+            'required': ['enabled', 'listen_ip_address', 'listen_port', 'username', 'password']
+        },
         'db_url': {'type': 'string'},
         'initial_state': {'type': 'string', 'enum': ['running', 'stopped']},
         'forcebuy_enable': {'type': 'boolean'},
@@ -173,10 +191,10 @@ CONF_SCHEMA = {
             'type': 'object',
             'properties': {
                 'name': {'type': 'string'},
-                'sandbox': {'type': 'boolean'},
-                'key': {'type': 'string'},
-                'secret': {'type': 'string'},
-                'password': {'type': 'string'},
+                'sandbox': {'type': 'boolean', 'default': False},
+                'key': {'type': 'string', 'default': ''},
+                'secret': {'type': 'string', 'default': ''},
+                'password': {'type': 'string', 'default': ''},
                 'uid': {'type': 'string'},
                 'pair_whitelist': {
                     'type': 'array',
@@ -199,7 +217,7 @@ CONF_SCHEMA = {
                 'ccxt_config': {'type': 'object'},
                 'ccxt_async_config': {'type': 'object'}
             },
-            'required': ['name', 'key', 'secret', 'pair_whitelist']
+            'required': ['name', 'pair_whitelist']
         },
         'edge': {
             'type': 'object',

freqtrade/data/btanalysis.py

@@ -1,12 +1,19 @@
 """
 Helpers when analyzing backtest data
 """
+import logging
 from pathlib import Path
+from typing import Dict
 
 import numpy as np
 import pandas as pd
+import pytz
 
+from freqtrade import persistence
 from freqtrade.misc import json_load
+from freqtrade.persistence import Trade
+
+logger = logging.getLogger(__name__)
 
 # must align with columns in backtest.py
 BT_DATA_COLUMNS = ["pair", "profitperc", "open_time", "close_time", "index", "duration",
@@ -17,7 +24,7 @@ def load_backtest_data(filename) -> pd.DataFrame:
     """
     Load backtest data file.
     :param filename: pathlib.Path object, or string pointing to the file.
-    :return a dataframe with the analysis results
+    :return: a dataframe with the analysis results
     """
     if isinstance(filename, str):
         filename = Path(filename)
@@ -60,8 +67,88 @@ def evaluate_result_multi(results: pd.DataFrame, freq: str, max_open_trades: int
     dates = pd.Series(pd.concat(dates).values, name='date')
     df2 = pd.DataFrame(np.repeat(results.values, deltas, axis=0), columns=results.columns)
 
-    df2 = df2.astype(dtype={"open_time": "datetime64", "close_time": "datetime64"})
     df2 = pd.concat([dates, df2], axis=1)
     df2 = df2.set_index('date')
     df_final = df2.resample(freq)[['pair']].count()
     return df_final[df_final['pair'] > max_open_trades]
+
+
+def load_trades_from_db(db_url: str) -> pd.DataFrame:
+    """
+    Load trades from a DB (using dburl)
+    :param db_url: Sqlite url (default format sqlite:///tradesv3.dry-run.sqlite)
+    :return: Dataframe containing Trades
+    """
+    trades: pd.DataFrame = pd.DataFrame([], columns=BT_DATA_COLUMNS)
+    persistence.init(db_url, clean_open_orders=False)
+    columns = ["pair", "profit", "open_time", "close_time",
+               "open_rate", "close_rate", "duration", "sell_reason",
+               "max_rate", "min_rate"]
+
+    trades = pd.DataFrame([(t.pair, t.calc_profit(),
+                            t.open_date.replace(tzinfo=pytz.UTC),
+                            t.close_date.replace(tzinfo=pytz.UTC) if t.close_date else None,
+                            t.open_rate, t.close_rate,
+                            t.close_date.timestamp() - t.open_date.timestamp()
+                            if t.close_date else None,
+                            t.sell_reason,
+                            t.max_rate,
+                            t.min_rate,
+                            )
+                           for t in Trade.query.all()],
+                          columns=columns)
+
+    return trades
+
+
+def load_trades(config) -> pd.DataFrame:
+    """
+    Based on configuration option "trade_source":
+    * loads data from DB (using `db_url`)
+    * loads data from backtestfile (using `exportfilename`)
+    """
+    if config["trade_source"] == "DB":
+        return load_trades_from_db(config["db_url"])
+    elif config["trade_source"] == "file":
+        return load_backtest_data(Path(config["exportfilename"]))
+
+
+def extract_trades_of_period(dataframe: pd.DataFrame, trades: pd.DataFrame) -> pd.DataFrame:
+    """
+    Compare trades and backtested pair DataFrames to get trades performed on backtested period
+    :return: the DataFrame of a trades of period
+    """
+    trades = trades.loc[(trades['open_time'] >= dataframe.iloc[0]['date']) &
+                        (trades['close_time'] <= dataframe.iloc[-1]['date'])]
+    return trades
+
+
+def combine_tickers_with_mean(tickers: Dict[str, pd.DataFrame], column: str = "close"):
+    """
+    Combine multiple dataframes "column"
+    :param tickers: Dict of Dataframes, dict key should be pair.
+    :param column: Column in the original dataframes to use
+    :return: DataFrame with the column renamed to the dict key, and a column
+        named mean, containing the mean of all pairs.
+    """
+    df_comb = pd.concat([tickers[pair].set_index('date').rename(
+        {column: pair}, axis=1)[pair] for pair in tickers], axis=1)
+
+    df_comb['mean'] = df_comb.mean(axis=1)
+
+    return df_comb
+
+
+def create_cum_profit(df: pd.DataFrame, trades: pd.DataFrame, col_name: str) -> pd.DataFrame:
+    """
+    Adds a column `col_name` with the cumulative profit for the given trades array.
+    :param df: DataFrame with date index
+    :param trades: DataFrame containing trades (requires columns close_time and profitperc)
+    :return: Returns df with one additional column, col_name, containing the cumulative profit.
+    """
+    df[col_name] = trades.set_index('close_time')['profitperc'].cumsum()
+    # Set first value to 0
+    df.loc[df.iloc[0].name, col_name] = 0
+    # FFill to get continuous
+    df[col_name] = df[col_name].ffill()
+    return df

freqtrade/data/converter.py

@@ -2,22 +2,25 @@
 Functions to convert data from one format to another
 """
 import logging
+
 import pandas as pd
 from pandas import DataFrame, to_datetime
-from freqtrade.misc import timeframe_to_minutes
 
 
 logger = logging.getLogger(__name__)
 
 
-def parse_ticker_dataframe(ticker: list, ticker_interval: str,
-                           fill_missing: bool = True) -> DataFrame:
+def parse_ticker_dataframe(ticker: list, ticker_interval: str, pair: str, *,
+                           fill_missing: bool = True,
+                           drop_incomplete: bool = True) -> DataFrame:
     """
     Converts a ticker-list (format ccxt.fetch_ohlcv) to a Dataframe
     :param ticker: ticker list, as returned by exchange.async_get_candle_history
     :param ticker_interval: ticker_interval (e.g. 5m). Used to fill up eventual missing data
+    :param pair: Pair this data is for (used to warn if fillup was necessary)
     :param fill_missing: fill up missing candles with 0 candles
                          (see ohlcv_fill_up_missing_data for details)
+    :param drop_incomplete: Drop the last candle of the dataframe, assuming it's incomplete
     :return: DataFrame
     """
     logger.debug("Parsing tickerlist to dataframe")
@@ -43,21 +46,25 @@ def parse_ticker_dataframe(ticker: list, ticker_interval: str,
         'close': 'last',
         'volume': 'max',
     })
-    frame.drop(frame.tail(1).index, inplace=True)     # eliminate partial candle
-    logger.debug('Dropping last candle')
+    # eliminate partial candle
+    if drop_incomplete:
+        frame.drop(frame.tail(1).index, inplace=True)
+        logger.debug('Dropping last candle')
 
     if fill_missing:
-        return ohlcv_fill_up_missing_data(frame, ticker_interval)
+        return ohlcv_fill_up_missing_data(frame, ticker_interval, pair)
     else:
         return frame
 
 
-def ohlcv_fill_up_missing_data(dataframe: DataFrame, ticker_interval: str) -> DataFrame:
+def ohlcv_fill_up_missing_data(dataframe: DataFrame, ticker_interval: str, pair: str) -> DataFrame:
     """
     Fills up missing data with 0 volume rows,
     using the previous close as price for "open", "high" "low" and "close", volume is set to 0
 
     """
+    from freqtrade.exchange import timeframe_to_minutes
+
     ohlc_dict = {
         'open': 'first',
         'high': 'max',
@@ -78,7 +85,10 @@ def ohlcv_fill_up_missing_data(dataframe: DataFrame, ticker_interval: str) -> Da
                'low': df['close'],
                })
     df.reset_index(inplace=True)
-    logger.debug(f"Missing data fillup: before: {len(dataframe)} - after: {len(df)}")
+    len_before = len(dataframe)
+    len_after = len(df)
+    if len_before != len_after:
+        logger.info(f"Missing data fillup for {pair}: before: {len_before} - after: {len_after}")
     return df
 
 

freqtrade/data/dataprovider.py

@@ -17,7 +17,7 @@ from freqtrade.state import RunMode
 logger = logging.getLogger(__name__)
 
 
-class DataProvider(object):
+class DataProvider():
 
     def __init__(self, config: dict, exchange: Exchange) -> None:
         self._config = config
@@ -81,12 +81,14 @@ class DataProvider(object):
         # TODO: Implement me
         pass
 
-    def orderbook(self, pair: str, max: int):
+    def orderbook(self, pair: str, maximum: int):
         """
         return latest orderbook data
+        :param pair: pair to get the data for
+        :param maximum: Maximum number of orderbook entries to query
+        :return: dict including bids/asks with a total of `maximum` entries.
         """
-        # TODO: Implement me
-        pass
+        return self._exchange.get_order_book(pair, maximum)
 
     @property
     def runmode(self) -> RunMode:

freqtrade/data/history.py

@@ -1,23 +1,24 @@
 """
 Handle historic data (ohlcv).
-includes:
+
+Includes:
 * load data for a pair (or a list of pairs) from disk
 * download data from exchange and store to disk
 """
 
 import logging
+import operator
+from datetime import datetime
 from pathlib import Path
-from typing import Optional, List, Dict, Tuple, Any
+from typing import Any, Dict, List, Optional, Tuple
 
 import arrow
 from pandas import DataFrame
 
-from freqtrade import misc, OperationalException
-from freqtrade.arguments import TimeRange
+from freqtrade import OperationalException, misc
+from freqtrade.configuration import TimeRange
 from freqtrade.data.converter import parse_ticker_dataframe
-from freqtrade.exchange import Exchange
-from freqtrade.misc import timeframe_to_minutes
-
+from freqtrade.exchange import Exchange, timeframe_to_minutes
 
 logger = logging.getLogger(__name__)
 
@@ -62,14 +63,10 @@ def load_tickerdata_file(
         timerange: Optional[TimeRange] = None) -> Optional[list]:
     """
     Load a pair from file, either .json.gz or .json
-    :return tickerlist or None if unsuccesful
+    :return: tickerlist or None if unsuccesful
     """
-    path = make_testdata_path(datadir)
-    pair_s = pair.replace('/', '_')
-    file = path.joinpath(f'{pair_s}-{ticker_interval}.json')
-
-    pairdata = misc.file_load_json(file)
-
+    filename = pair_data_filename(datadir, pair, ticker_interval)
+    pairdata = misc.file_load_json(filename)
     if not pairdata:
         return None
 
@@ -84,20 +81,25 @@ def load_pair_history(pair: str,
                       timerange: TimeRange = TimeRange(None, None, 0, 0),
                       refresh_pairs: bool = False,
                       exchange: Optional[Exchange] = None,
-                      fill_up_missing: bool = True
+                      fill_up_missing: bool = True,
+                      drop_incomplete: bool = True
                       ) -> DataFrame:
     """
     Loads cached ticker history for the given pair.
+    :param pair: Pair to load data for
+    :param ticker_interval: Ticker-interval (e.g. "5m")
+    :param datadir: Path to the data storage location.
+    :param timerange: Limit data to be loaded to this timerange
+    :param refresh_pairs: Refresh pairs from exchange.
+        (Note: Requires exchange to be passed as well.)
+    :param exchange: Exchange object (needed when using "refresh_pairs")
+    :param fill_up_missing: Fill missing values with "No action"-candles
+    :param drop_incomplete: Drop last candle assuming it may be incomplete.
     :return: DataFrame with ohlcv data
     """
 
-    # If the user force the refresh of pairs
+    # The user forced the refresh of pairs
     if refresh_pairs:
-        if not exchange:
-            raise OperationalException("Exchange needs to be initialized when "
-                                       "calling load_data with refresh_pairs=True")
-
-        logger.info('Download data for pair and store them in %s', datadir)
         download_pair_history(datadir=datadir,
                               exchange=exchange,
                               pair=pair,
@@ -114,11 +116,15 @@ def load_pair_history(pair: str,
             logger.warning('Missing data at end for pair %s, data ends at %s',
                            pair,
                            arrow.get(pairdata[-1][0] // 1000).strftime('%Y-%m-%d %H:%M:%S'))
-        return parse_ticker_dataframe(pairdata, ticker_interval, fill_up_missing)
+        return parse_ticker_dataframe(pairdata, ticker_interval, pair=pair,
+                                      fill_missing=fill_up_missing,
+                                      drop_incomplete=drop_incomplete)
     else:
-        logger.warning('No data for pair: "%s", Interval: %s. '
-                       'Use --refresh-pairs-cached to download the data',
-                       pair, ticker_interval)
+        logger.warning(
+            f'No history data for pair: "{pair}", interval: {ticker_interval}. '
+            'Use --refresh-pairs-cached option or download_backtest_data.py '
+            'script to download the data'
+        )
         return None
 
 
@@ -128,21 +134,34 @@ def load_data(datadir: Optional[Path],
               refresh_pairs: bool = False,
               exchange: Optional[Exchange] = None,
               timerange: TimeRange = TimeRange(None, None, 0, 0),
-              fill_up_missing: bool = True) -> Dict[str, DataFrame]:
+              fill_up_missing: bool = True,
+              live: bool = False
+              ) -> Dict[str, DataFrame]:
     """
     Loads ticker history data for a list of pairs the given parameters
     :return: dict(<pair>:<tickerlist>)
     """
-    result = {}
+    result: Dict[str, DataFrame] = {}
+    if live:
+        if exchange:
+            logger.info('Live: Downloading data for all defined pairs ...')
+            exchange.refresh_latest_ohlcv([(pair, ticker_interval) for pair in pairs])
+            result = {key[0]: value for key, value in exchange._klines.items() if value is not None}
+        else:
+            raise OperationalException(
+                "Exchange needs to be initialized when using live data."
+            )
+    else:
+        logger.info('Using local backtesting data ...')
 
-    for pair in pairs:
-        hist = load_pair_history(pair=pair, ticker_interval=ticker_interval,
-                                 datadir=datadir, timerange=timerange,
-                                 refresh_pairs=refresh_pairs,
-                                 exchange=exchange,
-                                 fill_up_missing=fill_up_missing)
-        if hist is not None:
-            result[pair] = hist
+        for pair in pairs:
+            hist = load_pair_history(pair=pair, ticker_interval=ticker_interval,
+                                     datadir=datadir, timerange=timerange,
+                                     refresh_pairs=refresh_pairs,
+                                     exchange=exchange,
+                                     fill_up_missing=fill_up_missing)
+            if hist is not None:
+                result[pair] = hist
     return result
 
 
@@ -151,6 +170,13 @@ def make_testdata_path(datadir: Optional[Path]) -> Path:
     return datadir or (Path(__file__).parent.parent / "tests" / "testdata").resolve()
 
 
+def pair_data_filename(datadir: Optional[Path], pair: str, ticker_interval: str) -> Path:
+    path = make_testdata_path(datadir)
+    pair_s = pair.replace("/", "_")
+    filename = path.joinpath(f'{pair_s}-{ticker_interval}.json')
+    return filename
+
+
 def load_cached_data_for_updating(filename: Path, ticker_interval: str,
                                   timerange: Optional[TimeRange]) -> Tuple[List[Any],
                                                                            Optional[int]]:
@@ -190,7 +216,7 @@ def load_cached_data_for_updating(filename: Path, ticker_interval: str,
 
 
 def download_pair_history(datadir: Optional[Path],
-                          exchange: Exchange,
+                          exchange: Optional[Exchange],
                           pair: str,
                           ticker_interval: str = '5m',
                           timerange: Optional[TimeRange] = None) -> bool:
@@ -201,18 +227,24 @@ def download_pair_history(datadir: Optional[Path],
     the full data will be redownloaded
 
     Based on @Rybolov work: https://github.com/rybolov/freqtrade-data
+
     :param pair: pair to download
     :param ticker_interval: ticker interval
     :param timerange: range of time to download
     :return: bool with success state
-
     """
-    try:
-        path = make_testdata_path(datadir)
-        filepair = pair.replace("/", "_")
-        filename = path.joinpath(f'{filepair}-{ticker_interval}.json')
+    if not exchange:
+        raise OperationalException(
+            "Exchange needs to be initialized when downloading pair history data"
+        )
 
-        logger.info('Download the pair: "%s", Interval: %s', pair, ticker_interval)
+    try:
+        filename = pair_data_filename(datadir, pair, ticker_interval)
+
+        logger.info(
+            f'Download history data for pair: "{pair}", interval: {ticker_interval} '
+            f'and store in {datadir}.'
+        )
 
         data, since_ms = load_cached_data_for_updating(filename, ticker_interval, timerange)
 
@@ -231,7 +263,46 @@ def download_pair_history(datadir: Optional[Path],
 
         misc.file_dump_json(filename, data)
         return True
-    except BaseException:
-        logger.info('Failed to download the pair: "%s", Interval: %s',
-                    pair, ticker_interval)
+
+    except Exception as e:
+        logger.error(
+            f'Failed to download history data for pair: "{pair}", interval: {ticker_interval}. '
+            f'Error: {e}'
+        )
         return False
+
+
+def get_timeframe(data: Dict[str, DataFrame]) -> Tuple[arrow.Arrow, arrow.Arrow]:
+    """
+    Get the maximum timeframe for the given backtest data
+    :param data: dictionary with preprocessed backtesting data
+    :return: tuple containing min_date, max_date
+    """
+    timeframe = [
+        (arrow.get(frame['date'].min()), arrow.get(frame['date'].max()))
+        for frame in data.values()
+    ]
+    return min(timeframe, key=operator.itemgetter(0))[0], \
+        max(timeframe, key=operator.itemgetter(1))[1]
+
+
+def validate_backtest_data(data: DataFrame, pair: str, min_date: datetime,
+                           max_date: datetime, ticker_interval_mins: int) -> bool:
+    """
+    Validates preprocessed backtesting data for missing values and shows warnings about it that.
+
+    :param data: preprocessed backtesting data (as DataFrame)
+    :param pair: pair used for log output.
+    :param min_date: start-date of the data
+    :param max_date: end-date of the data
+    :param ticker_interval_mins: ticker interval in minutes
+    """
+    # total difference in minutes / interval-minutes
+    expected_frames = int((max_date - min_date).total_seconds() // 60 // ticker_interval_mins)
+    found_missing = False
+    dflen = len(data)
+    if dflen < expected_frames:
+        found_missing = True
+        logger.warning("%s has missing frames: expected %s, got %s, that's %s missing values",
+                       pair, expected_frames, dflen, expected_frames - dflen)
+    return found_missing

freqtrade/edge/__init__.py

@@ -10,10 +10,8 @@ import utils_find_1st as utf1st
 from pandas import DataFrame
 
 from freqtrade import constants, OperationalException
-from freqtrade.arguments import Arguments
-from freqtrade.arguments import TimeRange
+from freqtrade.configuration import Arguments, TimeRange
 from freqtrade.data import history
-from freqtrade.optimize import get_timeframe
 from freqtrade.strategy.interface import SellType
 
 
@@ -47,11 +45,6 @@ class Edge():
         self.config = config
         self.exchange = exchange
         self.strategy = strategy
-        self.ticker_interval = self.strategy.ticker_interval
-        self.tickerdata_to_dataframe = self.strategy.tickerdata_to_dataframe
-        self.get_timeframe = get_timeframe
-        self.advise_sell = self.strategy.advise_sell
-        self.advise_buy = self.strategy.advise_buy
 
         self.edge_config = self.config.get('edge', {})
         self._cached_pairs: Dict[str, Any] = {}  # Keeps a list of pairs
@@ -102,7 +95,7 @@ class Edge():
         data = history.load_data(
             datadir=Path(self.config['datadir']) if self.config.get('datadir') else None,
             pairs=pairs,
-            ticker_interval=self.ticker_interval,
+            ticker_interval=self.strategy.ticker_interval,
             refresh_pairs=self._refresh_pairs,
             exchange=self.exchange,
             timerange=self._timerange
@@ -114,10 +107,10 @@ class Edge():
             logger.critical("No data found. Edge is stopped ...")
             return False
 
-        preprocessed = self.tickerdata_to_dataframe(data)
+        preprocessed = self.strategy.tickerdata_to_dataframe(data)
 
         # Print timeframe
-        min_date, max_date = self.get_timeframe(preprocessed)
+        min_date, max_date = history.get_timeframe(preprocessed)
         logger.info(
             'Measuring data from %s up to %s (%s days) ...',
             min_date.isoformat(),
@@ -132,13 +125,14 @@ class Edge():
             pair_data = pair_data.sort_values(by=['date'])
             pair_data = pair_data.reset_index(drop=True)
 
-            ticker_data = self.advise_sell(
-                self.advise_buy(pair_data, {'pair': pair}), {'pair': pair})[headers].copy()
+            ticker_data = self.strategy.advise_sell(
+                self.strategy.advise_buy(pair_data, {'pair': pair}), {'pair': pair})[headers].copy()
 
             trades += self._find_trades_for_stoploss_range(ticker_data, pair, self._stoploss_range)
 
         # If no trade found then exit
         if len(trades) == 0:
+            logger.info("No trades found.")
             return False
 
         # Fill missing, calculable columns, profit, duration , abs etc.

freqtrade/exchange/__init__.py

@@ -1,3 +1,10 @@
 from freqtrade.exchange.exchange import Exchange  # noqa: F401
+from freqtrade.exchange.exchange import (is_exchange_bad,  # noqa: F401
+                                         is_exchange_available,
+                                         is_exchange_officially_supported,
+                                         available_exchanges)
+from freqtrade.exchange.exchange import (timeframe_to_seconds,  # noqa: F401
+                                         timeframe_to_minutes,
+                                         timeframe_to_msecs)
 from freqtrade.exchange.kraken import Kraken  # noqa: F401
 from freqtrade.exchange.binance import Binance  # noqa: F401

freqtrade/exchange/exchange.py

@@ -1,23 +1,25 @@
 # pragma pylint: disable=W0603
-""" Cryptocurrency Exchanges support """
-import logging
+"""
+Cryptocurrency Exchanges support
+"""
+import asyncio
 import inspect
-from random import randint
-from typing import List, Dict, Tuple, Any, Optional
+import logging
+from copy import deepcopy
 from datetime import datetime
-from math import floor, ceil
+from math import ceil, floor
+from random import randint
+from typing import Any, Dict, List, Optional, Tuple
 
 import arrow
-import asyncio
 import ccxt
 import ccxt.async_support as ccxt_async
 from pandas import DataFrame
 
-from freqtrade import (constants, DependencyException, OperationalException,
-                       TemporaryError, InvalidOrderException)
+from freqtrade import (DependencyException, InvalidOrderException,
+                       OperationalException, TemporaryError, constants)
 from freqtrade.data.converter import parse_ticker_dataframe
-from freqtrade.misc import timeframe_to_seconds, timeframe_to_msecs
-
+from freqtrade.misc import deep_merge_dicts
 
 logger = logging.getLogger(__name__)
 
@@ -67,12 +69,15 @@ class Exchange(object):
     _params: Dict = {}
 
     # Dict to specify which options each exchange implements
-    # TODO: this should be merged with attributes from subclasses
-    # To avoid having to copy/paste this to all subclasses.
-    _ft_has: Dict = {
+    # This defines defaults, which can be selectively overridden by subclasses using _ft_has
+    # or by specifying them in the configuration.
+    _ft_has_default: Dict = {
         "stoploss_on_exchange": False,
         "order_time_in_force": ["gtc"],
+        "ohlcv_candle_limit": 500,
+        "ohlcv_partial_candle": True,
     }
+    _ft_has: Dict = {}
 
     def __init__(self, config: dict) -> None:
         """
@@ -80,6 +85,9 @@ class Exchange(object):
         it does basic validation whether the specified exchange and pairs are valid.
         :return: None
         """
+        self._api: ccxt.Exchange = None
+        self._api_async: ccxt_async.Exchange = None
+
         self._config.update(config)
 
         self._cached_ticker: Dict[str, Any] = {}
@@ -99,9 +107,22 @@ class Exchange(object):
             logger.info('Instance is running with dry_run enabled')
 
         exchange_config = config['exchange']
-        self._api: ccxt.Exchange = self._init_ccxt(
+
+        # Deep merge ft_has with default ft_has options
+        self._ft_has = deep_merge_dicts(self._ft_has, deepcopy(self._ft_has_default))
+        if exchange_config.get("_ft_has_params"):
+            self._ft_has = deep_merge_dicts(exchange_config.get("_ft_has_params"),
+                                            self._ft_has)
+            logger.info("Overriding exchange._ft_has with config params, result: %s", self._ft_has)
+
+        # Assign this directly for easy access
+        self._ohlcv_candle_limit = self._ft_has['ohlcv_candle_limit']
+        self._ohlcv_partial_candle = self._ft_has['ohlcv_partial_candle']
+
+        # Initialize ccxt objects
+        self._api = self._init_ccxt(
             exchange_config, ccxt_kwargs=exchange_config.get('ccxt_config'))
-        self._api_async: ccxt_async.Exchange = self._init_ccxt(
+        self._api_async = self._init_ccxt(
             exchange_config, ccxt_async, ccxt_kwargs=exchange_config.get('ccxt_async_config'))
 
         logger.info('Using Exchange "%s"', self.name)
@@ -138,8 +159,8 @@ class Exchange(object):
         # Find matching class for the given exchange name
         name = exchange_config['name']
 
-        if name not in ccxt_module.exchanges:
-            raise OperationalException(f'Exchange {name} is not supported')
+        if not is_exchange_available(name, ccxt_module):
+            raise OperationalException(f'Exchange {name} is not supported by ccxt')
 
         ex_config = {
             'apiKey': exchange_config.get('key'),
@@ -153,8 +174,10 @@ class Exchange(object):
         try:
 
             api = getattr(ccxt_module, name.lower())(ex_config)
-        except (KeyError, AttributeError):
-            raise OperationalException(f'Exchange {name} is not supported')
+        except (KeyError, AttributeError) as e:
+            raise OperationalException(f'Exchange {name} is not supported') from e
+        except ccxt.BaseError as e:
+            raise OperationalException(f"Initialization of ccxt failed. Reason: {e}") from e
 
         self.set_sandbox(api, exchange_config, name)
 
@@ -221,8 +244,11 @@ class Exchange(object):
                 > arrow.utcnow().timestamp):
             return None
         logger.debug("Performing scheduled market reload..")
-        self._api.load_markets(reload=True)
-        self._last_markets_refresh = arrow.utcnow().timestamp
+        try:
+            self._api.load_markets(reload=True)
+            self._last_markets_refresh = arrow.utcnow().timestamp
+        except ccxt.BaseError:
+            logger.exception("Could not reload markets.")
 
     def validate_pairs(self, pairs: List[str]) -> None:
         """
@@ -244,10 +270,28 @@ class Exchange(object):
                     f'Pair {pair} is not available on {self.name}. '
                     f'Please remove {pair} from your whitelist.')
 
+    def get_valid_pair_combination(self, curr_1, curr_2) -> str:
+        """
+        Get valid pair combination of curr_1 and curr_2 by trying both combinations.
+        """
+        for pair in [f"{curr_1}/{curr_2}", f"{curr_2}/{curr_1}"]:
+            if pair in self.markets and self.markets[pair].get('active'):
+                return pair
+        raise DependencyException(f"Could not combine {curr_1} and {curr_2} to get a valid pair.")
+
     def validate_timeframes(self, timeframe: List[str]) -> None:
         """
         Checks if ticker interval from config is a supported timeframe on the exchange
         """
+        if not hasattr(self._api, "timeframes") or self._api.timeframes is None:
+            # If timeframes attribute is missing (or is None), the exchange probably
+            # has no fetchOHLCV method.
+            # Therefore we also show that.
+            raise OperationalException(
+                f"The ccxt library does not provide the list of timeframes "
+                f"for the exchange \"{self.name}\" and this exchange "
+                f"is therefore not supported. ccxt fetchOHLCV: {self.exchange_has('fetchOHLCV')}")
+
         timeframes = self._api.timeframes
         if timeframe not in timeframes:
             raise OperationalException(
@@ -343,7 +387,9 @@ class Exchange(object):
         try:
             # Set the precision for amount and price(rate) as accepted by the exchange
             amount = self.symbol_amount_prec(pair, amount)
-            rate = self.symbol_price_prec(pair, rate) if ordertype != 'market' else None
+            needs_price = (ordertype != 'market'
+                           or self._api.options.get("createMarketBuyOrderRequiresPrice", False))
+            rate = self.symbol_price_prec(pair, rate) if needs_price else None
 
             return self._api.create_order(pair, ordertype, side,
                                           amount, rate, params)
@@ -351,18 +397,18 @@ class Exchange(object):
         except ccxt.InsufficientFunds as e:
             raise DependencyException(
                 f'Insufficient funds to create {ordertype} {side} order on market {pair}.'
-                f'Tried to {side} amount {amount} at rate {rate} (total {rate*amount}).'
-                f'Message: {e}')
+                f'Tried to {side} amount {amount} at rate {rate} (total {rate * amount}).'
+                f'Message: {e}') from e
         except ccxt.InvalidOrder as e:
             raise DependencyException(
                 f'Could not create {ordertype} {side} order on market {pair}.'
-                f'Tried to {side} amount {amount} at rate {rate} (total {rate*amount}).'
-                f'Message: {e}')
+                f'Tried to {side} amount {amount} at rate {rate} (total {rate * amount}).'
+                f'Message: {e}') from e
         except (ccxt.NetworkError, ccxt.ExchangeError) as e:
             raise TemporaryError(
-                f'Could not place {side} order due to {e.__class__.__name__}. Message: {e}')
+                f'Could not place {side} order due to {e.__class__.__name__}. Message: {e}') from e
         except ccxt.BaseError as e:
-            raise OperationalException(e)
+            raise OperationalException(e) from e
 
     def buy(self, pair: str, ordertype: str, amount: float,
             rate: float, time_in_force) -> Dict:
@@ -447,9 +493,9 @@ class Exchange(object):
             return balances
         except (ccxt.NetworkError, ccxt.ExchangeError) as e:
             raise TemporaryError(
-                f'Could not get balance due to {e.__class__.__name__}. Message: {e}')
+                f'Could not get balance due to {e.__class__.__name__}. Message: {e}') from e
         except ccxt.BaseError as e:
-            raise OperationalException(e)
+            raise OperationalException(e) from e
 
     @retrier
     def get_tickers(self) -> Dict:
@@ -458,18 +504,18 @@ class Exchange(object):
         except ccxt.NotSupported as e:
             raise OperationalException(
                 f'Exchange {self._api.name} does not support fetching tickers in batch.'
-                f'Message: {e}')
+                f'Message: {e}') from e
         except (ccxt.NetworkError, ccxt.ExchangeError) as e:
             raise TemporaryError(
-                f'Could not load tickers due to {e.__class__.__name__}. Message: {e}')
+                f'Could not load tickers due to {e.__class__.__name__}. Message: {e}') from e
         except ccxt.BaseError as e:
-            raise OperationalException(e)
+            raise OperationalException(e) from e
 
     @retrier
     def get_ticker(self, pair: str, refresh: Optional[bool] = True) -> dict:
         if refresh or pair not in self._cached_ticker.keys():
             try:
-                if pair not in self._api.markets:
+                if pair not in self._api.markets or not self._api.markets[pair].get('active'):
                     raise DependencyException(f"Pair {pair} not available")
                 data = self._api.fetch_ticker(pair)
                 try:
@@ -482,9 +528,9 @@ class Exchange(object):
                 return data
             except (ccxt.NetworkError, ccxt.ExchangeError) as e:
                 raise TemporaryError(
-                    f'Could not load ticker due to {e.__class__.__name__}. Message: {e}')
+                    f'Could not load ticker due to {e.__class__.__name__}. Message: {e}') from e
             except ccxt.BaseError as e:
-                raise OperationalException(e)
+                raise OperationalException(e) from e
         else:
             logger.info("returning cached ticker-data for %s", pair)
             return self._cached_ticker[pair]
@@ -502,11 +548,13 @@ class Exchange(object):
     async def _async_get_history(self, pair: str,
                                  ticker_interval: str,
                                  since_ms: int) -> List:
-        # Assume exchange returns 500 candles
-        _LIMIT = 500
 
-        one_call = timeframe_to_msecs(ticker_interval) * _LIMIT
-        logger.debug("one_call: %s msecs", one_call)
+        one_call = timeframe_to_msecs(ticker_interval) * self._ohlcv_candle_limit
+        logger.debug(
+            "one_call: %s msecs (%s)",
+            one_call,
+            arrow.utcnow().shift(seconds=one_call // 1000).humanize(only_distance=True)
+        )
         input_coroutines = [self._async_get_candle_history(
             pair, ticker_interval, since) for since in
             range(since_ms, arrow.utcnow().timestamp * 1000, one_call)]
@@ -537,7 +585,10 @@ class Exchange(object):
                     or self._now_is_time_to_refresh(pair, ticker_interval)):
                 input_coroutines.append(self._async_get_candle_history(pair, ticker_interval))
             else:
-                logger.debug("Using cached ohlcv data for %s, %s ...", pair, ticker_interval)
+                logger.debug(
+                    "Using cached ohlcv data for pair %s, interval %s ...",
+                    pair, ticker_interval
+                )
 
         tickers = asyncio.get_event_loop().run_until_complete(
             asyncio.gather(*input_coroutines, return_exceptions=True))
@@ -555,7 +606,8 @@ class Exchange(object):
                 self._pairs_last_refresh_time[(pair, ticker_interval)] = ticks[-1][0] // 1000
             # keeping parsed dataframe in cache
             self._klines[(pair, ticker_interval)] = parse_ticker_dataframe(
-                ticks, ticker_interval, fill_missing=True)
+                ticks, ticker_interval, pair=pair, fill_missing=True,
+                drop_incomplete=self._ohlcv_partial_candle)
         return tickers
 
     def _now_is_time_to_refresh(self, pair: str, ticker_interval: str) -> bool:
@@ -574,7 +626,11 @@ class Exchange(object):
         """
         try:
             # fetch ohlcv asynchronously
-            logger.debug("fetching %s, %s since %s ...", pair, ticker_interval, since_ms)
+            s = '(' + arrow.get(since_ms // 1000).isoformat() + ') ' if since_ms is not None else ''
+            logger.debug(
+                "Fetching pair %s, interval %s, since %s %s...",
+                pair, ticker_interval, since_ms, s
+            )
 
             data = await self._api_async.fetch_ohlcv(pair, timeframe=ticker_interval,
                                                      since=since_ms)
@@ -589,18 +645,18 @@ class Exchange(object):
             except IndexError:
                 logger.exception("Error loading %s. Result was %s.", pair, data)
                 return pair, ticker_interval, []
-            logger.debug("done fetching %s, %s ...", pair, ticker_interval)
+            logger.debug("Done fetching pair %s, interval %s ...", pair, ticker_interval)
             return pair, ticker_interval, data
 
         except ccxt.NotSupported as e:
             raise OperationalException(
                 f'Exchange {self._api.name} does not support fetching historical candlestick data.'
-                f'Message: {e}')
+                f'Message: {e}') from e
         except (ccxt.NetworkError, ccxt.ExchangeError) as e:
-            raise TemporaryError(
-                f'Could not load ticker history due to {e.__class__.__name__}. Message: {e}')
+            raise TemporaryError(f'Could not load ticker history due to {e.__class__.__name__}. '
+                                 f'Message: {e}') from e
         except ccxt.BaseError as e:
-            raise OperationalException(f'Could not fetch ticker data. Msg: {e}')
+            raise OperationalException(f'Could not fetch ticker data. Msg: {e}') from e
 
     @retrier
     def cancel_order(self, order_id: str, pair: str) -> None:
@@ -611,12 +667,12 @@ class Exchange(object):
             return self._api.cancel_order(order_id, pair)
         except ccxt.InvalidOrder as e:
             raise InvalidOrderException(
-                f'Could not cancel order. Message: {e}')
+                f'Could not cancel order. Message: {e}') from e
         except (ccxt.NetworkError, ccxt.ExchangeError) as e:
             raise TemporaryError(
-                f'Could not cancel order due to {e.__class__.__name__}. Message: {e}')
+                f'Could not cancel order due to {e.__class__.__name__}. Message: {e}') from e
         except ccxt.BaseError as e:
-            raise OperationalException(e)
+            raise OperationalException(e) from e
 
     @retrier
     def get_order(self, order_id: str, pair: str) -> Dict:
@@ -627,12 +683,12 @@ class Exchange(object):
             return self._api.fetch_order(order_id, pair)
         except ccxt.InvalidOrder as e:
             raise InvalidOrderException(
-                f'Tried to get an invalid order (id: {order_id}). Message: {e}')
+                f'Tried to get an invalid order (id: {order_id}). Message: {e}') from e
         except (ccxt.NetworkError, ccxt.ExchangeError) as e:
             raise TemporaryError(
-                f'Could not get order due to {e.__class__.__name__}. Message: {e}')
+                f'Could not get order due to {e.__class__.__name__}. Message: {e}') from e
         except ccxt.BaseError as e:
-            raise OperationalException(e)
+            raise OperationalException(e) from e
 
     @retrier
     def get_order_book(self, pair: str, limit: int = 100) -> dict:
@@ -648,12 +704,12 @@ class Exchange(object):
         except ccxt.NotSupported as e:
             raise OperationalException(
                 f'Exchange {self._api.name} does not support fetching order book.'
-                f'Message: {e}')
+                f'Message: {e}') from e
         except (ccxt.NetworkError, ccxt.ExchangeError) as e:
             raise TemporaryError(
-                f'Could not get order book due to {e.__class__.__name__}. Message: {e}')
+                f'Could not get order book due to {e.__class__.__name__}. Message: {e}') from e
         except ccxt.BaseError as e:
-            raise OperationalException(e)
+            raise OperationalException(e) from e
 
     @retrier
     def get_trades_for_order(self, order_id: str, pair: str, since: datetime) -> List:
@@ -670,9 +726,9 @@ class Exchange(object):
 
         except ccxt.NetworkError as e:
             raise TemporaryError(
-                f'Could not get trades due to networking error. Message: {e}')
+                f'Could not get trades due to networking error. Message: {e}') from e
         except ccxt.BaseError as e:
-            raise OperationalException(e)
+            raise OperationalException(e) from e
 
     @retrier
     def get_fee(self, symbol='ETH/BTC', type='', side='', amount=1,
@@ -686,6 +742,45 @@ class Exchange(object):
                                            price=price, takerOrMaker=taker_or_maker)['rate']
         except (ccxt.NetworkError, ccxt.ExchangeError) as e:
             raise TemporaryError(
-                f'Could not get fee info due to {e.__class__.__name__}. Message: {e}')
+                f'Could not get fee info due to {e.__class__.__name__}. Message: {e}') from e
         except ccxt.BaseError as e:
-            raise OperationalException(e)
+            raise OperationalException(e) from e
+
+
+def is_exchange_bad(exchange: str) -> bool:
+    return exchange in ['bitmex', 'bitstamp']
+
+
+def is_exchange_available(exchange: str, ccxt_module=None) -> bool:
+    return exchange in available_exchanges(ccxt_module)
+
+
+def is_exchange_officially_supported(exchange: str) -> bool:
+    return exchange in ['bittrex', 'binance']
+
+
+def available_exchanges(ccxt_module=None) -> List[str]:
+    return ccxt_module.exchanges if ccxt_module is not None else ccxt.exchanges
+
+
+def timeframe_to_seconds(ticker_interval: str) -> int:
+    """
+    Translates the timeframe interval value written in the human readable
+    form ('1m', '5m', '1h', '1d', '1w', etc.) to the number
+    of seconds for one timeframe interval.
+    """
+    return ccxt.Exchange.parse_timeframe(ticker_interval)
+
+
+def timeframe_to_minutes(ticker_interval: str) -> int:
+    """
+    Same as above, but returns minutes.
+    """
+    return ccxt.Exchange.parse_timeframe(ticker_interval) // 60
+
+
+def timeframe_to_msecs(ticker_interval: str) -> int:
+    """
+    Same as above, but returns milliseconds.
+    """
+    return ccxt.Exchange.parse_timeframe(ticker_interval) * 1000

freqtrade/freqtradebot.py

@@ -16,7 +16,7 @@ from freqtrade import (DependencyException, OperationalException, InvalidOrderEx
 from freqtrade.data.converter import order_book_to_dataframe
 from freqtrade.data.dataprovider import DataProvider
 from freqtrade.edge import Edge
-from freqtrade.misc import timeframe_to_minutes
+from freqtrade.exchange import timeframe_to_minutes
 from freqtrade.persistence import Trade
 from freqtrade.rpc import RPCManager, RPCMessageType
 from freqtrade.resolvers import ExchangeResolver, StrategyResolver, PairListResolver
@@ -53,8 +53,7 @@ class FreqtradeBot(object):
 
         self.rpc: RPCManager = RPCManager(self)
 
-        exchange_name = self.config.get('exchange', {}).get('name', 'bittrex').title()
-        self.exchange = ExchangeResolver(exchange_name, self.config).exchange
+        self.exchange = ExchangeResolver(self.config['exchange']['name'], self.config).exchange
 
         self.wallets = Wallets(self.config, self.exchange)
         self.dataprovider = DataProvider(self.config, self.exchange)
@@ -73,7 +72,8 @@ class FreqtradeBot(object):
 
         self.active_pair_whitelist: List[str] = self.config['exchange']['pair_whitelist']
 
-        persistence.init(self.config)
+        persistence.init(self.config.get('db_url', None),
+                         clean_open_orders=self.config.get('dry_run', False))
 
         # Set initial bot state from config
         initial_state = self.config.get('initial_state')
@@ -89,6 +89,16 @@ class FreqtradeBot(object):
         self.rpc.cleanup()
         persistence.cleanup()
 
+    def startup(self) -> None:
+        """
+        Called on startup and after reloading the bot - triggers notifications and
+        performs startup tasks
+        """
+        self.rpc.startup_messages(self.config, self.pairlists)
+        if not self.edge:
+            # Adjust stoploss if it was changed
+            Trade.stoploss_reinitialization(self.strategy.stoploss)
+
     def process(self) -> bool:
         """
         Queries the persistence layer for open trades and handles them,
@@ -194,19 +204,19 @@ class FreqtradeBot(object):
         else:
             stake_amount = self.config['stake_amount']
 
-        avaliable_amount = self.wallets.get_free(self.config['stake_currency'])
+        available_amount = self.wallets.get_free(self.config['stake_currency'])
 
         if stake_amount == constants.UNLIMITED_STAKE_AMOUNT:
             open_trades = len(Trade.get_open_trades())
             if open_trades >= self.config['max_open_trades']:
                 logger.warning('Can\'t open a new trade: max number of trades is reached')
                 return None
-            return avaliable_amount / (self.config['max_open_trades'] - open_trades)
+            return available_amount / (self.config['max_open_trades'] - open_trades)
 
         # Check if stake_amount is fulfilled
-        if avaliable_amount < stake_amount:
+        if available_amount < stake_amount:
             raise DependencyException(
-                f"Available balance({avaliable_amount} {self.config['stake_currency']}) is "
+                f"Available balance({available_amount} {self.config['stake_currency']}) is "
                 f"lower than stake amount({stake_amount} {self.config['stake_currency']})"
             )
 
@@ -334,8 +344,8 @@ class FreqtradeBot(object):
             return False
 
         amount = stake_amount / buy_limit_requested
-
-        order = self.exchange.buy(pair=pair, ordertype=self.strategy.order_types['buy'],
+        order_type = self.strategy.order_types['buy']
+        order = self.exchange.buy(pair=pair, ordertype=order_type,
                                   amount=amount, rate=buy_limit_requested,
                                   time_in_force=time_in_force)
         order_id = order['id']
@@ -345,7 +355,6 @@ class FreqtradeBot(object):
         buy_limit_filled_price = buy_limit_requested
 
         if order_status == 'expired' or order_status == 'rejected':
-            order_type = self.strategy.order_types['buy']
             order_tif = self.strategy.order_time_in_force['buy']
 
             # return false if the order is not filled
@@ -379,6 +388,7 @@ class FreqtradeBot(object):
             'exchange': self.exchange.name.capitalize(),
             'pair': pair_s,
             'limit': buy_limit_filled_price,
+            'order_type': order_type,
             'stake_amount': stake_amount,
             'stake_currency': stake_currency,
             'fiat_currency': fiat_currency
@@ -460,7 +470,7 @@ class FreqtradeBot(object):
     def get_real_amount(self, trade: Trade, order: Dict) -> float:
         """
         Get real amount for the trade
-        Necessary for self.exchanges which charge fees in base currency (e.g. binance)
+        Necessary for exchanges which charge fees in base currency (e.g. binance)
         """
         order_amount = order['amount']
         # Only run for closed orders
@@ -468,8 +478,11 @@ class FreqtradeBot(object):
             return order_amount
 
         # use fee from order-dict if possible
-        if 'fee' in order and order['fee'] and (order['fee'].keys() >= {'currency', 'cost'}):
-            if trade.pair.startswith(order['fee']['currency']):
+        if ('fee' in order and order['fee'] is not None and
+                (order['fee'].keys() >= {'currency', 'cost'})):
+            if (order['fee']['currency'] is not None and
+                    order['fee']['cost'] is not None and
+                    trade.pair.startswith(order['fee']['currency'])):
                 new_amount = order_amount - order['fee']['cost']
                 logger.info("Applying fee on amount for %s (from %s to %s) from Order",
                             trade, order['amount'], new_amount)
@@ -486,9 +499,12 @@ class FreqtradeBot(object):
         fee_abs = 0
         for exectrade in trades:
             amount += exectrade['amount']
-            if "fee" in exectrade and (exectrade['fee'].keys() >= {'currency', 'cost'}):
+            if ("fee" in exectrade and exectrade['fee'] is not None and
+                    (exectrade['fee'].keys() >= {'currency', 'cost'})):
                 # only applies if fee is in quote currency!
-                if trade.pair.startswith(exectrade['fee']['currency']):
+                if (exectrade['fee']['currency'] is not None and
+                        exectrade['fee']['cost'] is not None and
+                        trade.pair.startswith(exectrade['fee']['currency'])):
                     fee_abs += exectrade['fee']['cost']
 
         if amount != order_amount:
@@ -508,7 +524,11 @@ class FreqtradeBot(object):
         if trade.open_order_id:
             # Update trade with order values
             logger.info('Found open order for %s', trade)
-            order = action_order or self.exchange.get_order(trade.open_order_id, trade.pair)
+            try:
+                order = action_order or self.exchange.get_order(trade.open_order_id, trade.pair)
+            except InvalidOrderException as exception:
+                logger.warning('Unable to fetch order %s: %s', trade.open_order_id, exception)
+                return
             # Try update amount (binance-fix)
             try:
                 new_amount = self.get_real_amount(trade, order)
@@ -522,6 +542,10 @@ class FreqtradeBot(object):
 
             trade.update(order)
 
+            # Updating wallets when order is closed
+            if not trade.is_open:
+                self.wallets.update()
+
     def get_sell_rate(self, pair: str, refresh: bool) -> float:
         """
         Get sell rate - either using get-ticker bid or first bid based on orderbook
@@ -572,13 +596,13 @@ class FreqtradeBot(object):
                 logger.info('  order book asks top %s: %0.8f', i, order_book_rate)
                 sell_rate = order_book_rate
 
-                if self.check_sell(trade, sell_rate, buy, sell):
+                if self._check_and_execute_sell(trade, sell_rate, buy, sell):
                     return True
 
         else:
             logger.debug('checking sell')
             sell_rate = self.get_sell_rate(trade.pair, True)
-            if self.check_sell(trade, sell_rate, buy, sell):
+            if self._check_and_execute_sell(trade, sell_rate, buy, sell):
                 return True
 
         logger.debug('Found no sell signal for %s.', trade)
@@ -648,7 +672,7 @@ class FreqtradeBot(object):
         if stoploss_order and stoploss_order['status'] == 'closed':
             trade.sell_reason = SellType.STOPLOSS_ON_EXCHANGE.value
             trade.update(stoploss_order)
-            self.notify_sell(trade)
+            self._notify_sell(trade)
             return True
 
         # Finally we check if stoploss on exchange should be moved up because of trailing.
@@ -676,21 +700,32 @@ class FreqtradeBot(object):
                 # cancelling the current stoploss on exchange first
                 logger.info('Trailing stoploss: cancelling current stoploss on exchange (id:{%s})'
                             'in order to add another one ...', order['id'])
-                if self.exchange.cancel_order(order['id'], trade.pair):
+                try:
+                    self.exchange.cancel_order(order['id'], trade.pair)
+                except InvalidOrderException:
+                    logger.exception(f"Could not cancel stoploss order {order['id']} "
+                                     f"for pair {trade.pair}")
+
+                try:
                     # creating the new one
                     stoploss_order_id = self.exchange.stoploss_limit(
                         pair=trade.pair, amount=trade.amount,
                         stop_price=trade.stop_loss, rate=trade.stop_loss * 0.99
                     )['id']
                     trade.stoploss_order_id = str(stoploss_order_id)
+                except DependencyException:
+                    logger.exception(f"Could create trailing stoploss order "
+                                     f"for pair {trade.pair}.")
 
-    def check_sell(self, trade: Trade, sell_rate: float, buy: bool, sell: bool) -> bool:
-        if self.edge:
-            stoploss = self.edge.stoploss(trade.pair)
-            should_sell = self.strategy.should_sell(
-                trade, sell_rate, datetime.utcnow(), buy, sell, force_stoploss=stoploss)
-        else:
-            should_sell = self.strategy.should_sell(trade, sell_rate, datetime.utcnow(), buy, sell)
+    def _check_and_execute_sell(self, trade: Trade, sell_rate: float,
+                                buy: bool, sell: bool) -> bool:
+        """
+        Check and execute sell
+        """
+        should_sell = self.strategy.should_sell(
+                trade, sell_rate, datetime.utcnow(), buy, sell,
+                force_stoploss=self.edge.stoploss(trade.pair) if self.edge else 0
+        )
 
         if should_sell.sell_flag:
             self.execute_sell(trade, sell_rate, should_sell.sell_type)
@@ -718,7 +753,7 @@ class FreqtradeBot(object):
                 if not trade.open_order_id:
                     continue
                 order = self.exchange.get_order(trade.open_order_id, trade.pair)
-            except (RequestException, DependencyException):
+            except (RequestException, DependencyException, InvalidOrderException):
                 logger.info(
                     'Cannot query order for %s due to %s',
                     trade,
@@ -828,7 +863,10 @@ class FreqtradeBot(object):
 
         # First cancelling stoploss on exchange ...
         if self.strategy.order_types.get('stoploss_on_exchange') and trade.stoploss_order_id:
-            self.exchange.cancel_order(trade.stoploss_order_id, trade.pair)
+            try:
+                self.exchange.cancel_order(trade.stoploss_order_id, trade.pair)
+            except InvalidOrderException:
+                logger.exception(f"Could not cancel stoploss order {trade.stoploss_order_id}")
 
         # Execute sell and update trade record
         order_id = self.exchange.sell(pair=str(trade.pair),
@@ -841,9 +879,9 @@ class FreqtradeBot(object):
         trade.close_rate_requested = limit
         trade.sell_reason = sell_reason.value
         Trade.session.flush()
-        self.notify_sell(trade)
+        self._notify_sell(trade)
 
-    def notify_sell(self, trade: Trade):
+    def _notify_sell(self, trade: Trade):
         """
         Sends rpc notification when a sell occured.
         """
@@ -860,6 +898,7 @@ class FreqtradeBot(object):
             'pair': trade.pair,
             'gain': gain,
             'limit': trade.close_rate_requested,
+            'order_type': self.strategy.order_types['sell'],
             'amount': trade.amount,
             'open_rate': trade.open_rate,
             'current_rate': current_rate,

freqtrade/loggers.py

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

freqtrade/main.py

@@ -3,51 +3,60 @@
 Main Freqtrade bot script.
 Read the documentation to know what cli arguments you need.
 """
-import logging
+
 import sys
+# check min. python version
+if sys.version_info < (3, 6):
+    sys.exit("Freqtrade requires Python version >= 3.6")
+
+# flake8: noqa E402
+import logging
 from argparse import Namespace
-from typing import List
+from typing import Any, List
 
 from freqtrade import OperationalException
-from freqtrade.arguments import Arguments
-from freqtrade.configuration import set_loggers
+from freqtrade.configuration import Arguments
 from freqtrade.worker import Worker
 
 
 logger = logging.getLogger('freqtrade')
 
 
-def main(sysargv: List[str]) -> None:
+def main(sysargv: List[str] = None) -> None:
     """
     This function will initiate the bot and start the trading loop.
     :return: None
     """
-    arguments = Arguments(
-        sysargv,
-        'Free, open source crypto trading bot'
-    )
-    args: Namespace = arguments.get_parsed_arg()
-
-    # A subcommand has been issued.
-    # Means if Backtesting or Hyperopt have been called we exit the bot
-    if hasattr(args, 'func'):
-        args.func(args)
-        return
 
+    return_code: Any = 1
     worker = None
-    return_code = 1
     try:
-        # Load and run worker
-        worker = Worker(args)
-        worker.run()
+        arguments = Arguments(
+            sysargv,
+            'Free, open source crypto trading bot'
+        )
+        args: Namespace = arguments.get_parsed_arg()
 
+        # A subcommand has been issued.
+        # Means if Backtesting or Hyperopt have been called we exit the bot
+        if hasattr(args, 'func'):
+            args.func(args)
+            # TODO: fetch return_code as returned by the command function here
+            return_code = 0
+        else:
+            # Load and run worker
+            worker = Worker(args)
+            worker.run()
+
+    except SystemExit as e:
+        return_code = e
     except KeyboardInterrupt:
         logger.info('SIGINT received, aborting ...')
         return_code = 0
     except OperationalException as e:
         logger.error(str(e))
         return_code = 2
-    except BaseException:
+    except Exception:
         logger.exception('Fatal exception!')
     finally:
         if worker:
@@ -56,5 +65,4 @@ def main(sysargv: List[str]) -> None:
 
 
 if __name__ == '__main__':
-    set_loggers()
-    main(sys.argv[1:])
+    main()

freqtrade/misc.py

@@ -1,18 +1,15 @@
 """
 Various tool function for Freqtrade and scripts
 """
-
 import gzip
 import logging
 import re
 from datetime import datetime
-from typing import Dict
 
-from ccxt import Exchange
 import numpy as np
-from pandas import DataFrame
 import rapidjson
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -42,24 +39,6 @@ def datesarray_to_datetimearray(dates: np.ndarray) -> np.ndarray:
     return dates.dt.to_pydatetime()
 
 
-def common_datearray(dfs: Dict[str, DataFrame]) -> np.ndarray:
-    """
-    Return dates from Dataframe
-    :param dfs: Dict with format pair: pair_data
-    :return: List of dates
-    """
-    alldates = {}
-    for pair, pair_data in dfs.items():
-        dates = datesarray_to_datetimearray(pair_data['date'])
-        for date in dates:
-            alldates[date] = 1
-    lst = []
-    for date, _ in alldates.items():
-        lst.append(date)
-    arr = np.array(lst)
-    return np.sort(arr, axis=0)
-
-
 def file_dump_json(filename, data, is_zip=False) -> None:
     """
     Dump JSON data into a file
@@ -118,6 +97,8 @@ def format_ms_time(date: int) -> str:
 
 def deep_merge_dicts(source, destination):
     """
+    Values from Source override destination, destination is returned (and modified!!)
+    Sample:
     >>> a = { 'first' : { 'rows' : { 'pass' : 'dog', 'number' : '1' } } }
     >>> b = { 'first' : { 'rows' : { 'fail' : 'cat', 'number' : '5' } } }
     >>> merge(b, a) == { 'first' : { 'rows' : { 'pass' : 'dog', 'fail' : 'cat', 'number' : '5' } } }
@@ -132,26 +113,3 @@ def deep_merge_dicts(source, destination):
             destination[key] = value
 
     return destination
-
-
-def timeframe_to_seconds(ticker_interval: str) -> int:
-    """
-    Translates the timeframe interval value written in the human readable
-    form ('1m', '5m', '1h', '1d', '1w', etc.) to the number
-    of seconds for one timeframe interval.
-    """
-    return Exchange.parse_timeframe(ticker_interval)
-
-
-def timeframe_to_minutes(ticker_interval: str) -> int:
-    """
-    Same as above, but returns minutes.
-    """
-    return Exchange.parse_timeframe(ticker_interval) // 60
-
-
-def timeframe_to_msecs(ticker_interval: str) -> int:
-    """
-    Same as above, but returns milliseconds.
-    """
-    return Exchange.parse_timeframe(ticker_interval) * 1000

freqtrade/optimize/__init__.py

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

freqtrade/optimize/backtesting.py

@@ -4,7 +4,6 @@
 This module contains the backtesting logic
 """
 import logging
-from argparse import Namespace
 from copy import deepcopy
 from datetime import datetime, timedelta
 from pathlib import Path
@@ -13,17 +12,15 @@ from typing import Any, Dict, List, NamedTuple, Optional
 from pandas import DataFrame
 from tabulate import tabulate
 
-from freqtrade import optimize
-from freqtrade import DependencyException, constants
-from freqtrade.arguments import Arguments
-from freqtrade.configuration import Configuration
+from freqtrade.configuration import Arguments
 from freqtrade.data import history
 from freqtrade.data.dataprovider import DataProvider
-from freqtrade.misc import file_dump_json, timeframe_to_minutes
+from freqtrade.exchange import timeframe_to_minutes
+from freqtrade.misc import file_dump_json
 from freqtrade.persistence import Trade
 from freqtrade.resolvers import ExchangeResolver, StrategyResolver
 from freqtrade.state import RunMode
-from freqtrade.strategy.interface import SellType, IStrategy
+from freqtrade.strategy.interface import IStrategy, SellType
 
 logger = logging.getLogger(__name__)
 
@@ -66,8 +63,7 @@ class Backtesting(object):
         self.config['dry_run'] = True
         self.strategylist: List[IStrategy] = []
 
-        exchange_name = self.config.get('exchange', {}).get('name', 'bittrex').title()
-        self.exchange = ExchangeResolver(exchange_name, self.config).exchange
+        self.exchange = ExchangeResolver(self.config['exchange']['name'], self.config).exchange
         self.fee = self.exchange.get_fee()
 
         if self.config.get('runmode') != RunMode.HYPEROPT:
@@ -75,18 +71,16 @@ class Backtesting(object):
             IStrategy.dp = self.dataprovider
 
         if self.config.get('strategy_list', None):
-            # Force one interval
-            self.ticker_interval = str(self.config.get('ticker_interval'))
-            self.ticker_interval_mins = timeframe_to_minutes(self.ticker_interval)
             for strat in list(self.config['strategy_list']):
                 stratconf = deepcopy(self.config)
                 stratconf['strategy'] = strat
                 self.strategylist.append(StrategyResolver(stratconf).strategy)
 
         else:
-            # only one strategy
+            # No strategy list specified, only one strategy
             self.strategylist.append(StrategyResolver(self.config).strategy)
-        # Load one strategy
+
+        # Load one (first) strategy
         self._set_strategy(self.strategylist[0])
 
     def _set_strategy(self, strategy):
@@ -97,7 +91,6 @@ class Backtesting(object):
 
         self.ticker_interval = self.config.get('ticker_interval')
         self.ticker_interval_mins = timeframe_to_minutes(self.ticker_interval)
-        self.tickerdata_to_dataframe = strategy.tickerdata_to_dataframe
         self.advise_buy = strategy.advise_buy
         self.advise_sell = strategy.advise_sell
         # Set stoploss_on_exchange to false for backtesting,
@@ -238,10 +231,9 @@ class Backtesting(object):
 
     def _get_sell_trade_entry(
             self, pair: str, buy_row: DataFrame,
-            partial_ticker: List, trade_count_lock: Dict, args: Dict) -> Optional[BacktestResult]:
+            partial_ticker: List, trade_count_lock: Dict,
+            stake_amount: float, max_open_trades: int) -> Optional[BacktestResult]:
 
-        stake_amount = args['stake_amount']
-        max_open_trades = args.get('max_open_trades', 0)
         trade = Trade(
             open_rate=buy_row.open,
             open_date=buy_row.date,
@@ -257,26 +249,23 @@ class Backtesting(object):
                 # Increase trade_count_lock for every iteration
                 trade_count_lock[sell_row.date] = trade_count_lock.get(sell_row.date, 0) + 1
 
-            buy_signal = sell_row.buy
-            sell = self.strategy.should_sell(trade, sell_row.open, sell_row.date, buy_signal,
+            sell = self.strategy.should_sell(trade, sell_row.open, sell_row.date, sell_row.buy,
                                              sell_row.sell, low=sell_row.low, high=sell_row.high)
             if sell.sell_flag:
-
                 trade_dur = int((sell_row.date - buy_row.date).total_seconds() // 60)
                 # Special handling if high or low hit STOP_LOSS or ROI
                 if sell.sell_type in (SellType.STOP_LOSS, SellType.TRAILING_STOP_LOSS):
                     # Set close_rate to stoploss
                     closerate = trade.stop_loss
                 elif sell.sell_type == (SellType.ROI):
-                    # get next entry in min_roi > to trade duration
-                    # Interface.py skips on trade_duration <= duration
-                    roi_entry = max(list(filter(lambda x: trade_dur >= x,
-                                                self.strategy.minimal_roi.keys())))
-                    roi = self.strategy.minimal_roi[roi_entry]
-
-                    # - (Expected abs profit + open_rate + open_fee) / (fee_close -1)
-                    closerate = - (trade.open_rate * roi + trade.open_rate *
-                                   (1 + trade.fee_open)) / (trade.fee_close - 1)
+                    roi = self.strategy.min_roi_reached_entry(trade_dur)
+                    if roi is not None:
+                        # - (Expected abs profit + open_rate + open_fee) / (fee_close -1)
+                        closerate = - (trade.open_rate * roi + trade.open_rate *
+                                       (1 + trade.fee_open)) / (trade.fee_close - 1)
+                    else:
+                        # This should not be reached...
+                        closerate = sell_row.open
                 else:
                     closerate = sell_row.open
 
@@ -330,7 +319,11 @@ class Backtesting(object):
             position_stacking: do we allow position stacking? (default: False)
         :return: DataFrame
         """
+        # Arguments are long and noisy, so this is commented out.
+        # Uncomment if you need to debug the backtest() method.
+#        logger.debug(f"Start backtest, args: {args}")
         processed = args['processed']
+        stake_amount = args['stake_amount']
         max_open_trades = args.get('max_open_trades', 0)
         position_stacking = args.get('position_stacking', False)
         start_date = args['start_date']
@@ -357,7 +350,7 @@ class Backtesting(object):
                     row = ticker[pair][indexes[pair]]
                 except IndexError:
                     # missing Data for one pair at the end.
-                    # Warnings for this are shown by `validate_backtest_data`
+                    # Warnings for this are shown during data loading
                     continue
 
                 # Waits until the time-counter reaches the start of the data for this pair.
@@ -381,7 +374,8 @@ class Backtesting(object):
                     trade_count_lock[row.date] = trade_count_lock.get(row.date, 0) + 1
 
                 trade_entry = self._get_sell_trade_entry(pair, row, ticker[pair][indexes[pair]:],
-                                                         trade_count_lock, args)
+                                                         trade_count_lock, stake_amount,
+                                                         max_open_trades)
 
                 if trade_entry:
                     lock_pair_until[pair] = trade_entry.close_time
@@ -404,24 +398,17 @@ class Backtesting(object):
         logger.info('Using stake_currency: %s ...', self.config['stake_currency'])
         logger.info('Using stake_amount: %s ...', self.config['stake_amount'])
 
-        if self.config.get('live'):
-            logger.info('Downloading data for all pairs in whitelist ...')
-            self.exchange.refresh_latest_ohlcv([(pair, self.ticker_interval) for pair in pairs])
-            data = {key[0]: value for key, value in self.exchange._klines.items()}
-
-        else:
-            logger.info('Using local backtesting data (using whitelist in given config) ...')
-
-            timerange = Arguments.parse_timerange(None if self.config.get(
-                'timerange') is None else str(self.config.get('timerange')))
-            data = history.load_data(
-                datadir=Path(self.config['datadir']) if self.config.get('datadir') else None,
-                pairs=pairs,
-                ticker_interval=self.ticker_interval,
-                refresh_pairs=self.config.get('refresh_pairs', False),
-                exchange=self.exchange,
-                timerange=timerange
-            )
+        timerange = Arguments.parse_timerange(None if self.config.get(
+            'timerange') is None else str(self.config.get('timerange')))
+        data = history.load_data(
+            datadir=Path(self.config['datadir']) if self.config.get('datadir') else None,
+            pairs=pairs,
+            ticker_interval=self.ticker_interval,
+            refresh_pairs=self.config.get('refresh_pairs', False),
+            exchange=self.exchange,
+            timerange=timerange,
+            live=self.config.get('live', False)
+        )
 
         if not data:
             logger.critical("No data found. Terminating.")
@@ -434,20 +421,19 @@ class Backtesting(object):
             max_open_trades = 0
         all_results = {}
 
+        min_date, max_date = history.get_timeframe(data)
+
+        logger.info(
+            'Backtesting with data from %s up to %s (%s days)..',
+            min_date.isoformat(),
+            max_date.isoformat(),
+            (max_date - min_date).days
+        )
+
         for strat in self.strategylist:
             logger.info("Running backtesting for Strategy %s", strat.get_strategy_name())
             self._set_strategy(strat)
 
-            min_date, max_date = optimize.get_timeframe(data)
-            # Validate dataframe for missing values (mainly at start and end, as fillup is called)
-            optimize.validate_backtest_data(data, min_date, max_date,
-                                            timeframe_to_minutes(self.ticker_interval))
-            logger.info(
-                'Measuring data from %s up to %s (%s days)..',
-                min_date.isoformat(),
-                max_date.isoformat(),
-                (max_date - min_date).days
-            )
             # need to reprocess data every time to populate signals
             preprocessed = self.strategy.tickerdata_to_dataframe(data)
 
@@ -484,38 +470,3 @@ class Backtesting(object):
             print(' Strategy Summary '.center(133, '='))
             print(self._generate_text_table_strategy(all_results))
             print('\nFor more details, please look at the detail tables above')
-
-
-def setup_configuration(args: Namespace) -> Dict[str, Any]:
-    """
-    Prepare the configuration for the backtesting
-    :param args: Cli args from Arguments()
-    :return: Configuration
-    """
-    configuration = Configuration(args, RunMode.BACKTEST)
-    config = configuration.get_config()
-
-    # Ensure we do not use Exchange credentials
-    config['exchange']['key'] = ''
-    config['exchange']['secret'] = ''
-
-    if config['stake_amount'] == constants.UNLIMITED_STAKE_AMOUNT:
-        raise DependencyException('stake amount could not be "%s" for backtesting' %
-                                  constants.UNLIMITED_STAKE_AMOUNT)
-
-    return config
-
-
-def start(args: Namespace) -> None:
-    """
-    Start Backtesting script
-    :param args: Cli args from Arguments()
-    :return: None
-    """
-    # Initialize configuration
-    config = setup_configuration(args)
-    logger.info('Starting freqtrade in Backtesting mode')
-
-    # Initialize backtesting object
-    backtesting = Backtesting(config)
-    backtesting.start()

freqtrade/optimize/default_hyperopt.py

@@ -1,17 +1,15 @@
 # pragma pylint: disable=missing-docstring, invalid-name, pointless-string-statement
 
+from functools import reduce
+from typing import Any, Callable, Dict, List
+
 import talib.abstract as ta
 from pandas import DataFrame
-from typing import Dict, Any, Callable, List
-from functools import reduce
-
 from skopt.space import Categorical, Dimension, Integer, Real
 
 import freqtrade.vendor.qtpylib.indicators as qtpylib
 from freqtrade.optimize.hyperopt_interface import IHyperOpt
 
-class_name = 'DefaultHyperOpts'
-
 
 class DefaultHyperOpts(IHyperOpt):
     """
@@ -70,9 +68,10 @@ class DefaultHyperOpts(IHyperOpt):
                         dataframe['close'], dataframe['sar']
                     ))
 
-            dataframe.loc[
-                reduce(lambda x, y: x & y, conditions),
-                'buy'] = 1
+            if conditions:
+                dataframe.loc[
+                    reduce(lambda x, y: x & y, conditions),
+                    'buy'] = 1
 
             return dataframe
 
@@ -129,9 +128,10 @@ class DefaultHyperOpts(IHyperOpt):
                         dataframe['sar'], dataframe['close']
                     ))
 
-            dataframe.loc[
-                reduce(lambda x, y: x & y, conditions),
-                'sell'] = 1
+            if conditions:
+                dataframe.loc[
+                    reduce(lambda x, y: x & y, conditions),
+                    'sell'] = 1
 
             return dataframe
 

freqtrade/optimize/default_hyperopt_loss.py

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

freqtrade/optimize/edge_cli.py

@@ -4,16 +4,14 @@
 This module contains the edge backtesting interface
 """
 import logging
-from argparse import Namespace
 from typing import Dict, Any
 from tabulate import tabulate
+from freqtrade import constants
 from freqtrade.edge import Edge
 
-from freqtrade.arguments import Arguments
-from freqtrade.configuration import Configuration
+from freqtrade.configuration import Arguments
 from freqtrade.exchange import Exchange
 from freqtrade.resolvers import StrategyResolver
-from freqtrade.state import RunMode
 
 logger = logging.getLogger(__name__)
 
@@ -35,6 +33,7 @@ class EdgeCli(object):
         self.config['exchange']['secret'] = ''
         self.config['exchange']['password'] = ''
         self.config['exchange']['uid'] = ''
+        self.config['stake_amount'] = constants.UNLIMITED_STAKE_AMOUNT
         self.config['dry_run'] = True
         self.exchange = Exchange(self.config)
         self.strategy = StrategyResolver(self.config).strategy
@@ -73,37 +72,7 @@ class EdgeCli(object):
                         floatfmt=floatfmt, tablefmt="pipe")
 
     def start(self) -> None:
-        self.edge.calculate()
-        print('')  # blank like for readability
-        print(self._generate_edge_table(self.edge._cached_pairs))
-
-
-def setup_configuration(args: Namespace) -> Dict[str, Any]:
-    """
-    Prepare the configuration for edge backtesting
-    :param args: Cli args from Arguments()
-    :return: Configuration
-    """
-    configuration = Configuration(args, RunMode.EDGECLI)
-    config = configuration.get_config()
-
-    # Ensure we do not use Exchange credentials
-    config['exchange']['key'] = ''
-    config['exchange']['secret'] = ''
-
-    return config
-
-
-def start(args: Namespace) -> None:
-    """
-    Start Edge script
-    :param args: Cli args from Arguments()
-    :return: None
-    """
-    # Initialize configuration
-    config = setup_configuration(args)
-    logger.info('Starting freqtrade in Edge mode')
-
-    # Initialize Edge object
-    edge_cli = EdgeCli(config)
-    edge_cli.start()
+        result = self.edge.calculate()
+        if result:
+            print('')  # blank line for readability
+            print(self._generate_edge_table(self.edge._cached_pairs))

freqtrade/optimize/hyperopt.py

@@ -5,33 +5,35 @@ This module contains the hyperopt logic
 """
 
 import logging
-import multiprocessing
 import os
 import sys
-from argparse import Namespace
-from math import exp
+
 from operator import itemgetter
 from pathlib import Path
 from pprint import pprint
 from typing import Any, Dict, List
 
-from joblib import Parallel, delayed, dump, load, wrap_non_picklable_objects
+from joblib import Parallel, delayed, dump, load, wrap_non_picklable_objects, cpu_count
 from pandas import DataFrame
 from skopt import Optimizer
 from skopt.space import Dimension
 
-from freqtrade.arguments import Arguments
-from freqtrade.configuration import Configuration
-from freqtrade.data.history import load_data
-from freqtrade.optimize import get_timeframe
+from freqtrade.configuration import Arguments
+from freqtrade.data.history import load_data, get_timeframe
 from freqtrade.optimize.backtesting import Backtesting
-from freqtrade.state import RunMode
-from freqtrade.resolvers import HyperOptResolver
+# Import IHyperOptLoss to allow users import from this file
+from freqtrade.optimize.hyperopt_loss_interface import IHyperOptLoss  # noqa: F4
+from freqtrade.resolvers.hyperopt_resolver import HyperOptResolver, HyperOptLossResolver
+
 
 logger = logging.getLogger(__name__)
 
+
+INITIAL_POINTS = 30
 MAX_LOSS = 100000  # just a big enough number to be bad result in loss optimization
 TICKERDATA_PICKLE = os.path.join('user_data', 'hyperopt_tickerdata.pkl')
+TRIALSDATA_PICKLE = os.path.join('user_data', 'hyperopt_results.pickle')
+HYPEROPT_LOCKFILE = os.path.join('user_data', 'hyperopt.lock')
 
 
 class Hyperopt(Backtesting):
@@ -44,28 +46,48 @@ class Hyperopt(Backtesting):
     """
     def __init__(self, config: Dict[str, Any]) -> None:
         super().__init__(config)
-        self.config = config
         self.custom_hyperopt = HyperOptResolver(self.config).hyperopt
 
-        # set TARGET_TRADES to suit your number concurrent trades so its realistic
-        # to the number of days
-        self.target_trades = 600
+        self.custom_hyperoptloss = HyperOptLossResolver(self.config).hyperoptloss
+        self.calculate_loss = self.custom_hyperoptloss.hyperopt_loss_function
+
         self.total_tries = config.get('epochs', 0)
         self.current_best_loss = 100
 
-        # max average trade duration in minutes
-        # if eval ends with higher value, we consider it a failed eval
-        self.max_accepted_trade_duration = 300
-
-        # this is expexted avg profit * expected trade count
-        # for example 3.5%, 1100 trades, self.expected_max_profit = 3.85
-        # check that the reported Σ% values do not exceed this!
-        self.expected_max_profit = 3.0
+        if not self.config.get('hyperopt_continue'):
+            self.clean_hyperopt()
+        else:
+            logger.info("Continuing on previous hyperopt results.")
 
         # Previous evaluations
-        self.trials_file = os.path.join('user_data', 'hyperopt_results.pickle')
+        self.trials_file = TRIALSDATA_PICKLE
         self.trials: List = []
 
+        # Populate functions here (hasattr is slow so should not be run during "regular" operations)
+        if hasattr(self.custom_hyperopt, 'populate_buy_trend'):
+            self.advise_buy = self.custom_hyperopt.populate_buy_trend  # type: ignore
+
+        if hasattr(self.custom_hyperopt, 'populate_sell_trend'):
+            self.advise_sell = self.custom_hyperopt.populate_sell_trend  # type: ignore
+
+            # Use max_open_trades for hyperopt as well, except --disable-max-market-positions is set
+        if self.config.get('use_max_market_positions', True):
+            self.max_open_trades = self.config['max_open_trades']
+        else:
+            logger.debug('Ignoring max_open_trades (--disable-max-market-positions was used) ...')
+            self.max_open_trades = 0
+        self.position_stacking = self.config.get('position_stacking', False),
+
+    def clean_hyperopt(self):
+        """
+        Remove hyperopt pickle files to restart hyperopt.
+        """
+        for f in [TICKERDATA_PICKLE, TRIALSDATA_PICKLE]:
+            p = Path(f)
+            if p.is_file():
+                logger.info(f"Removing `{p}`.")
+                p.unlink()
+
     def get_args(self, params):
         dimensions = self.hyperopt_space()
         # Ensure the number of dimensions match
@@ -115,28 +137,24 @@ class Hyperopt(Backtesting):
         """
         Log results if it is better than any previous evaluation
         """
-        if results['loss'] < self.current_best_loss:
-            current = results['current_tries']
+        print_all = self.config.get('print_all', False)
+        if print_all or results['loss'] < self.current_best_loss:
+            # Output human-friendly index here (starting from 1)
+            current = results['current_tries'] + 1
             total = results['total_tries']
             res = results['result']
             loss = results['loss']
             self.current_best_loss = results['loss']
-            log_msg = f'\n{current:5d}/{total}: {res}. Loss {loss:.5f}'
-            print(log_msg)
+            log_msg = f'{current:5d}/{total}: {res} Objective: {loss:.5f}'
+            log_msg = f'*{log_msg}' if results['initial_point'] else f' {log_msg}'
+            if print_all:
+                print(log_msg)
+            else:
+                print('\n' + log_msg)
         else:
             print('.', end='')
             sys.stdout.flush()
 
-    def calculate_loss(self, total_profit: float, trade_count: int, trade_duration: float) -> float:
-        """
-        Objective function, returns smaller number for more optimal results
-        """
-        trade_loss = 1 - 0.25 * exp(-(trade_count - self.target_trades) ** 2 / 10 ** 5.8)
-        profit_loss = max(0, 1 - total_profit / self.expected_max_profit)
-        duration_loss = 0.4 * min(trade_duration / self.max_accepted_trade_duration, 1)
-        result = trade_loss + profit_loss + duration_loss
-        return result
-
     def has_space(self, space: str) -> bool:
         """
         Tell if a space value is contained in the configuration
@@ -165,48 +183,54 @@ class Hyperopt(Backtesting):
         return spaces
 
     def generate_optimizer(self, _params: Dict) -> Dict:
+        """
+        Used Optimize function. Called once per epoch to optimize whatever is configured.
+        Keep this function as optimized as possible!
+        """
         params = self.get_args(_params)
         if self.has_space('roi'):
             self.strategy.minimal_roi = self.custom_hyperopt.generate_roi_table(params)
 
         if self.has_space('buy'):
             self.advise_buy = self.custom_hyperopt.buy_strategy_generator(params)
-        elif hasattr(self.custom_hyperopt, 'populate_buy_trend'):
-            self.advise_buy = self.custom_hyperopt.populate_buy_trend  # type: ignore
 
         if self.has_space('sell'):
             self.advise_sell = self.custom_hyperopt.sell_strategy_generator(params)
-        elif hasattr(self.custom_hyperopt, 'populate_sell_trend'):
-            self.advise_sell = self.custom_hyperopt.populate_sell_trend  # type: ignore
 
         if self.has_space('stoploss'):
             self.strategy.stoploss = params['stoploss']
 
         processed = load(TICKERDATA_PICKLE)
+
         min_date, max_date = get_timeframe(processed)
+
         results = self.backtest(
             {
                 'stake_amount': self.config['stake_amount'],
                 'processed': processed,
-                'position_stacking': self.config.get('position_stacking', True),
+                'max_open_trades': self.max_open_trades,
+                'position_stacking': self.position_stacking,
                 'start_date': min_date,
                 'end_date': max_date,
             }
         )
         result_explanation = self.format_results(results)
 
-        total_profit = results.profit_percent.sum()
         trade_count = len(results.index)
-        trade_duration = results.trade_duration.mean()
 
-        if trade_count == 0:
+        # If this evaluation contains too short amount of trades to be
+        # interesting -- consider it as 'bad' (assigned max. loss value)
+        # in order to cast this hyperspace point away from optimization
+        # path. We do not want to optimize 'hodl' strategies.
+        if trade_count < self.config['hyperopt_min_trades']:
             return {
                 'loss': MAX_LOSS,
                 'params': params,
                 'result': result_explanation,
             }
 
-        loss = self.calculate_loss(total_profit, trade_count, trade_duration)
+        loss = self.calculate_loss(results=results, trade_count=trade_count,
+                                   min_date=min_date.datetime, max_date=max_date.datetime)
 
         return {
             'loss': loss,
@@ -222,20 +246,21 @@ class Hyperopt(Backtesting):
         avg_profit = results.profit_percent.mean() * 100.0
         total_profit = results.profit_abs.sum()
         stake_cur = self.config['stake_currency']
-        profit = results.profit_percent.sum()
+        profit = results.profit_percent.sum() * 100.0
         duration = results.trade_duration.mean()
 
         return (f'{trades:6d} trades. Avg profit {avg_profit: 5.2f}%. '
                 f'Total profit {total_profit: 11.8f} {stake_cur} '
-                f'({profit:.4f}Σ%). Avg duration {duration:5.1f} mins.')
+                f'({profit: 7.2f}Σ%). Avg duration {duration:5.1f} mins.')
 
     def get_optimizer(self, cpu_count) -> Optimizer:
         return Optimizer(
             self.hyperopt_space(),
             base_estimator="ET",
             acq_optimizer="auto",
-            n_initial_points=30,
-            acq_optimizer_kwargs={'n_jobs': cpu_count}
+            n_initial_points=INITIAL_POINTS,
+            acq_optimizer_kwargs={'n_jobs': cpu_count},
+            random_state=self.config.get('hyperopt_random_state', None)
         )
 
     def run_optimizer_parallel(self, parallel, asked) -> List:
@@ -258,69 +283,67 @@ class Hyperopt(Backtesting):
             datadir=Path(self.config['datadir']) if self.config.get('datadir') else None,
             pairs=self.config['exchange']['pair_whitelist'],
             ticker_interval=self.ticker_interval,
+            refresh_pairs=self.config.get('refresh_pairs', False),
+            exchange=self.exchange,
             timerange=timerange
         )
 
-        if self.has_space('buy') or self.has_space('sell'):
-            self.strategy.advise_indicators = \
-                self.custom_hyperopt.populate_indicators  # type: ignore
-        dump(self.strategy.tickerdata_to_dataframe(data), TICKERDATA_PICKLE)
+        if not data:
+            logger.critical("No data found. Terminating.")
+            return
+
+        min_date, max_date = get_timeframe(data)
+
+        logger.info(
+            'Hyperopting with data from %s up to %s (%s days)..',
+            min_date.isoformat(),
+            max_date.isoformat(),
+            (max_date - min_date).days
+        )
+
+        self.strategy.advise_indicators = \
+            self.custom_hyperopt.populate_indicators  # type: ignore
+
+        preprocessed = self.strategy.tickerdata_to_dataframe(data)
+
+        dump(preprocessed, TICKERDATA_PICKLE)
+
+        # We don't need exchange instance anymore while running hyperopt
         self.exchange = None  # type: ignore
+
         self.load_previous_results()
 
-        cpus = multiprocessing.cpu_count()
+        cpus = cpu_count()
         logger.info(f'Found {cpus} CPU cores. Let\'s make them scream!')
+        config_jobs = self.config.get('hyperopt_jobs', -1)
+        logger.info(f'Number of parallel jobs set as: {config_jobs}')
 
-        opt = self.get_optimizer(cpus)
-        EVALS = max(self.total_tries // cpus, 1)
+        opt = self.get_optimizer(config_jobs)
         try:
-            with Parallel(n_jobs=cpus) as parallel:
+            with Parallel(n_jobs=config_jobs) as parallel:
+                jobs = parallel._effective_n_jobs()
+                logger.info(f'Effective number of parallel workers used: {jobs}')
+                EVALS = max(self.total_tries // jobs, 1)
                 for i in range(EVALS):
-                    asked = opt.ask(n_points=cpus)
+                    asked = opt.ask(n_points=jobs)
                     f_val = self.run_optimizer_parallel(parallel, asked)
                     opt.tell(asked, [i['loss'] for i in f_val])
 
                     self.trials += f_val
-                    for j in range(cpus):
+                    for j in range(jobs):
+                        current = i * jobs + j
                         self.log_results({
                             'loss': f_val[j]['loss'],
-                            'current_tries': i * cpus + j,
+                            'current_tries': current,
+                            'initial_point': current < INITIAL_POINTS,
                             'total_tries': self.total_tries,
                             'result': f_val[j]['result'],
                         })
+                        logger.debug(f"Optimizer params: {f_val[j]['params']}")
+                    for j in range(jobs):
+                        logger.debug(f"Optimizer state: Xi: {opt.Xi[-j-1]}, yi: {opt.yi[-j-1]}")
         except KeyboardInterrupt:
             print('User interrupted..')
 
         self.save_trials()
         self.log_trials_result()
-
-
-def start(args: Namespace) -> None:
-    """
-    Start Backtesting script
-    :param args: Cli args from Arguments()
-    :return: None
-    """
-
-    # Remove noisy log messages
-    logging.getLogger('hyperopt.tpe').setLevel(logging.WARNING)
-
-    # Initialize configuration
-    # Monkey patch the configuration with hyperopt_conf.py
-    configuration = Configuration(args, RunMode.HYPEROPT)
-    logger.info('Starting freqtrade in Hyperopt mode')
-    config = configuration.load_config()
-
-    config['exchange']['key'] = ''
-    config['exchange']['secret'] = ''
-
-    if config.get('strategy') and config.get('strategy') != 'DefaultStrategy':
-        logger.error("Please don't use --strategy for hyperopt.")
-        logger.error(
-            "Read the documentation at "
-            "https://github.com/freqtrade/freqtrade/blob/develop/docs/hyperopt.md "
-            "to understand how to configure hyperopt.")
-        raise ValueError("--strategy configured but not supported for hyperopt")
-    # Initialize backtesting object
-    hyperopt = Hyperopt(config)
-    hyperopt.start()

freqtrade/optimize/hyperopt_interface.py

@@ -20,6 +20,7 @@ class IHyperOpt(ABC):
         stoploss -> float: optimal stoploss designed for the strategy
         ticker_interval -> int: value of the ticker interval to use for the strategy
     """
+    ticker_interval: str
 
     @staticmethod
     @abstractmethod

freqtrade/optimize/hyperopt_loss_interface.py

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

freqtrade/optimize/hyperopt_loss_onlyprofit.py

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

freqtrade/optimize/hyperopt_loss_sharpe.py

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

freqtrade/persistence.py

@@ -25,15 +25,16 @@ _DECL_BASE: Any = declarative_base()
 _SQL_DOCS_URL = 'http://docs.sqlalchemy.org/en/latest/core/engines.html#database-urls'
 
 
-def init(config: Dict) -> None:
+def init(db_url: str, clean_open_orders: bool = False) -> None:
     """
     Initializes this module with the given config,
     registers all known command handlers
     and starts polling for message updates
-    :param config: config to use
+    :param db_url: Database to use
+    :param clean_open_orders: Remove open orders from the database.
+        Useful for dry-run or if all orders have been reset on the exchange.
     :return: None
     """
-    db_url = config.get('db_url', None)
     kwargs = {}
 
     # Take care of thread ownership if in-memory db
@@ -57,7 +58,7 @@ def init(config: Dict) -> None:
     check_migrate(engine)
 
     # Clean dry_run DB if the db is not in-memory
-    if config.get('dry_run', False) and db_url != 'sqlite://':
+    if clean_open_orders and db_url != 'sqlite://':
         clean_dry_run_db()
 
 
@@ -213,11 +214,31 @@ class Trade(_DECL_BASE):
         return (f'Trade(id={self.id}, pair={self.pair}, amount={self.amount:.8f}, '
                 f'open_rate={self.open_rate:.8f}, open_since={open_since})')
 
+    def to_json(self) -> Dict[str, Any]:
+        return {
+            'trade_id': self.id,
+            'pair': self.pair,
+            'open_date_hum': arrow.get(self.open_date).humanize(),
+            'open_date': self.open_date.strftime("%Y-%m-%d %H:%M:%S"),
+            'close_date_hum': (arrow.get(self.close_date).humanize()
+                               if self.close_date else None),
+            'close_date': (self.close_date.strftime("%Y-%m-%d %H:%M:%S")
+                           if self.close_date else None),
+            'open_rate': self.open_rate,
+            'close_rate': self.close_rate,
+            'amount': round(self.amount, 8),
+            'stake_amount': round(self.stake_amount, 8),
+            'stop_loss': self.stop_loss,
+            'stop_loss_pct': (self.stop_loss_pct * 100) if self.stop_loss_pct else None,
+            'initial_stop_loss': self.initial_stop_loss,
+            'initial_stop_loss_pct': (self.initial_stop_loss_pct * 100
+                                      if self.initial_stop_loss_pct else None),
+        }
+
     def adjust_min_max_rates(self, current_price: float):
         """
         Adjust the max_rate and min_rate.
         """
-        logger.debug("Adjusting min/max rates")
         self.max_rate = max(current_price, self.max_rate or self.open_rate)
         self.min_rate = min(current_price, self.min_rate or self.open_rate)
 
@@ -401,3 +422,22 @@ class Trade(_DECL_BASE):
         Query trades from persistence layer
         """
         return Trade.query.filter(Trade.is_open.is_(True)).all()
+
+    @staticmethod
+    def stoploss_reinitialization(desired_stoploss):
+        """
+        Adjust initial Stoploss to desired stoploss for all open trades.
+        """
+        for trade in Trade.get_open_trades():
+            logger.info("Found open trade: %s", trade)
+
+            # skip case if trailing-stop changed the stoploss already.
+            if (trade.stop_loss == trade.initial_stop_loss
+               and trade.initial_stop_loss_pct != desired_stoploss):
+                # Stoploss value got changed
+
+                logger.info(f"Stoploss for {trade} needs adjustment.")
+                # Force reset of stoploss
+                trade.stop_loss = None
+                trade.adjust_stop_loss(trade.open_rate, desired_stoploss)
+                logger.info(f"new stoploss: {trade.stop_loss}, ")

freqtrade/plot/plotting.py

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

freqtrade/resolvers/__init__.py

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

freqtrade/resolvers/exchange_resolver.py

@@ -22,11 +22,13 @@ class ExchangeResolver(IResolver):
         Load the custom class from config parameter
         :param config: configuration dictionary
         """
+        exchange_name = exchange_name.title()
         try:
             self.exchange = self._load_exchange(exchange_name, kwargs={'config': config})
         except ImportError:
             logger.info(
                 f"No {exchange_name} specific subclass found. Using the generic class instead.")
+        if not hasattr(self, "exchange"):
             self.exchange = Exchange(config)
 
     def _load_exchange(
@@ -43,13 +45,13 @@ class ExchangeResolver(IResolver):
 
             exchange = ex_class(kwargs['config'])
             if exchange:
-                logger.info("Using resolved exchange %s", exchange_name)
+                logger.info(f"Using resolved exchange '{exchange_name}'...")
                 return exchange
         except AttributeError:
             # Pass and raise ImportError instead
             pass
 
         raise ImportError(
-            "Impossible to load Exchange '{}'. This class does not exist"
-            " or contains Python code errors".format(exchange_name)
+            f"Impossible to load Exchange '{exchange_name}'. This class does not exist "
+            "or contains Python code errors."
         )

freqtrade/resolvers/hyperopt_resolver.py

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

freqtrade/resolvers/iresolver.py

@@ -7,7 +7,7 @@ import importlib.util
 import inspect
 import logging
 from pathlib import Path
-from typing import Optional, Type, Any
+from typing import Any, List, Optional, Tuple, Type, Union
 
 logger = logging.getLogger(__name__)
 
@@ -45,7 +45,7 @@ class IResolver(object):
 
     @staticmethod
     def _search_object(directory: Path, object_type, object_name: str,
-                       kwargs: dict = {}) -> Optional[Any]:
+                       kwargs: dict = {}) -> Union[Tuple[Any, Path], Tuple[None, None]]:
         """
         Search for the objectname in the given directory
         :param directory: relative or absolute directory path
@@ -57,9 +57,33 @@ class IResolver(object):
             if not str(entry).endswith('.py'):
                 logger.debug('Ignoring %s', entry)
                 continue
+            module_path = Path.resolve(directory.joinpath(entry))
             obj = IResolver._get_valid_object(
-                object_type, Path.resolve(directory.joinpath(entry)), object_name
+                object_type, module_path, object_name
             )
             if obj:
-                return obj(**kwargs)
+                return (obj(**kwargs), module_path)
+        return (None, None)
+
+    @staticmethod
+    def _load_object(paths: List[Path], object_type, object_name: str,
+                     kwargs: dict = {}) -> Optional[Any]:
+        """
+        Try to load object from path list.
+        """
+
+        for _path in paths:
+            try:
+                (module, module_path) = IResolver._search_object(directory=_path,
+                                                                 object_type=object_type,
+                                                                 object_name=object_name,
+                                                                 kwargs=kwargs)
+                if module:
+                    logger.info(
+                        f"Using resolved {object_type.__name__.lower()[1:]} {object_name} "
+                        f"from '{module_path}'...")
+                    return module
+            except FileNotFoundError:
+                logger.warning('Path "%s" does not exist.', _path.resolve())
+
         return None

freqtrade/resolvers/pairlist_resolver.py

@@ -6,6 +6,7 @@ This module load custom hyperopts
 import logging
 from pathlib import Path
 
+from freqtrade import OperationalException
 from freqtrade.pairlist.IPairList import IPairList
 from freqtrade.resolvers import IResolver
 
@@ -38,22 +39,15 @@ class PairListResolver(IResolver):
         current_path = Path(__file__).parent.parent.joinpath('pairlist').resolve()
 
         abs_paths = [
-            current_path.parent.parent.joinpath('user_data/pairlist'),
+            Path.cwd().joinpath('user_data/pairlist'),
             current_path,
         ]
 
-        for _path in abs_paths:
-            try:
-                pairlist = self._search_object(directory=_path, object_type=IPairList,
-                                               object_name=pairlist_name,
-                                               kwargs=kwargs)
-                if pairlist:
-                    logger.info("Using resolved pairlist %s from '%s'", pairlist_name, _path)
-                    return pairlist
-            except FileNotFoundError:
-                logger.warning('Path "%s" does not exist', _path.relative_to(Path.cwd()))
-
-        raise ImportError(
-            "Impossible to load Pairlist '{}'. This class does not exist"
-            " or contains Python code errors".format(pairlist_name)
+        pairlist = self._load_object(paths=abs_paths, object_type=IPairList,
+                                     object_name=pairlist_name, kwargs=kwargs)
+        if pairlist:
+            return pairlist
+        raise OperationalException(
+            f"Impossible to load Pairlist '{pairlist_name}'. This class does not exist "
+            "or contains Python code errors."
         )

freqtrade/resolvers/strategy_resolver.py

@@ -11,7 +11,7 @@ from inspect import getfullargspec
 from pathlib import Path
 from typing import Dict, Optional
 
-from freqtrade import constants
+from freqtrade import constants, OperationalException
 from freqtrade.resolvers import IResolver
 from freqtrade.strategy import import_strategy
 from freqtrade.strategy.interface import IStrategy
@@ -132,7 +132,7 @@ class StrategyResolver(IResolver):
             abs_paths.insert(0, Path(extra_dir).resolve())
 
         if ":" in strategy_name:
-            logger.info("loading base64 endocded strategy")
+            logger.info("loading base64 encoded strategy")
             strat = strategy_name.split(":")
 
             if len(strat) == 2:
@@ -147,25 +147,21 @@ class StrategyResolver(IResolver):
                 # register temp path with the bot
                 abs_paths.insert(0, temp.resolve())
 
-        for _path in abs_paths:
-            try:
-                strategy = self._search_object(directory=_path, object_type=IStrategy,
-                                               object_name=strategy_name, kwargs={'config': config})
-                if strategy:
-                    logger.info("Using resolved strategy %s from '%s'", strategy_name, _path)
-                    strategy._populate_fun_len = len(
-                        getfullargspec(strategy.populate_indicators).args)
-                    strategy._buy_fun_len = len(getfullargspec(strategy.populate_buy_trend).args)
-                    strategy._sell_fun_len = len(getfullargspec(strategy.populate_sell_trend).args)
-                    try:
-                        return import_strategy(strategy, config=config)
-                    except TypeError as e:
-                        logger.warning(
-                            f"Impossible to load strategy '{strategy}' from {_path}. Error: {e}")
-            except FileNotFoundError:
-                logger.warning('Path "%s" does not exist', _path.relative_to(Path.cwd()))
+        strategy = self._load_object(paths=abs_paths, object_type=IStrategy,
+                                     object_name=strategy_name, kwargs={'config': config})
+        if strategy:
+            strategy._populate_fun_len = len(getfullargspec(strategy.populate_indicators).args)
+            strategy._buy_fun_len = len(getfullargspec(strategy.populate_buy_trend).args)
+            strategy._sell_fun_len = len(getfullargspec(strategy.populate_sell_trend).args)
 
-        raise ImportError(
-            f"Impossible to load Strategy '{strategy_name}'. This class does not exist"
-            " or contains Python code errors"
+            try:
+                return import_strategy(strategy, config=config)
+            except TypeError as e:
+                logger.warning(
+                    f"Impossible to load strategy '{strategy_name}'. "
+                    f"Error: {e}")
+
+        raise OperationalException(
+            f"Impossible to load Strategy '{strategy_name}'. This class does not exist "
+            "or contains Python code errors."
         )

freqtrade/rpc/api_server.py

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

freqtrade/rpc/rpc.py

@@ -48,6 +48,11 @@ class RPCException(Exception):
     def __str__(self):
         return self.message
 
+    def __json__(self):
+        return {
+            'msg': self.message
+        }
+
 
 class RPC(object):
     """
@@ -100,28 +105,17 @@ class RPC(object):
                 current_profit = trade.calc_profit_percent(current_rate)
                 fmt_close_profit = (f'{round(trade.close_profit * 100, 2):.2f}%'
                                     if trade.close_profit else None)
-                results.append(dict(
-                    trade_id=trade.id,
-                    pair=trade.pair,
+                trade_dict = trade.to_json()
+                trade_dict.update(dict(
                     base_currency=self._freqtrade.config['stake_currency'],
-                    date=arrow.get(trade.open_date),
-                    open_rate=trade.open_rate,
-                    close_rate=trade.close_rate,
-                    current_rate=current_rate,
-                    amount=round(trade.amount, 8),
-                    stake_amount=round(trade.stake_amount, 8),
                     close_profit=fmt_close_profit,
+                    current_rate=current_rate,
                     current_profit=round(current_profit * 100, 2),
-                    stop_loss=trade.stop_loss,
-                    stop_loss_pct=(trade.stop_loss_pct * 100)
-                    if trade.stop_loss_pct else None,
-                    initial_stop_loss=trade.initial_stop_loss,
-                    initial_stop_loss_pct=(trade.initial_stop_loss_pct * 100)
-                    if trade.initial_stop_loss_pct else None,
                     open_order='({} {} rem={:.8f})'.format(
                         order['type'], order['side'], order['remaining']
                     ) if order else None,
                 ))
+                results.append(trade_dict)
             return results
 
     def _rpc_status_table(self) -> DataFrame:
@@ -287,11 +281,13 @@ class RPC(object):
                 rate = 1.0
             else:
                 try:
-                    if coin == 'USDT':
-                        rate = 1.0 / self._freqtrade.get_sell_rate('BTC/USDT', False)
+                    pair = self._freqtrade.exchange.get_valid_pair_combination(coin, "BTC")
+                    if pair.startswith("BTC"):
+                        rate = 1.0 / self._freqtrade.get_sell_rate(pair, False)
                     else:
-                        rate = self._freqtrade.get_sell_rate(coin + '/BTC', False)
+                        rate = self._freqtrade.get_sell_rate(pair, False)
                 except (TemporaryError, DependencyException):
+                    logger.warning(f" Could not get rate for pair {coin}.")
                     continue
             est_btc: float = rate * balance['total']
             total = total + est_btc
@@ -303,7 +299,10 @@ class RPC(object):
                 'est_btc': est_btc,
             })
         if total == 0.0:
-            raise RPCException('all balances are zero')
+            if self._freqtrade.config.get('dry_run', False):
+                raise RPCException('Running in Dry Run, balances are not available.')
+            else:
+                raise RPCException('All balances are zero.')
 
         symbol = fiat_display_currency
         value = self._fiat_converter.convert_amount(total, 'BTC',
@@ -346,7 +345,7 @@ class RPC(object):
 
         return {'status': 'No more buy will occur from now. Run /reload_conf to reset.'}
 
-    def _rpc_forcesell(self, trade_id) -> None:
+    def _rpc_forcesell(self, trade_id) -> Dict[str, str]:
         """
         Handler for forcesell <id>.
         Sells the given trade at current price
@@ -386,7 +385,7 @@ class RPC(object):
             for trade in Trade.get_open_trades():
                 _exec_forcesell(trade)
             Trade.session.flush()
-            return
+            return {'result': 'Created sell orders for all open trades.'}
 
         # Query for trade
         trade = Trade.query.filter(
@@ -401,6 +400,7 @@ class RPC(object):
 
         _exec_forcesell(trade)
         Trade.session.flush()
+        return {'result': f'Created sell order for trade {trade_id}.'}
 
     def _rpc_forcebuy(self, pair: str, price: Optional[float]) -> Optional[Trade]:
         """
@@ -474,7 +474,7 @@ class RPC(object):
                }
         return res
 
-    def _rpc_blacklist(self, add: List[str]) -> Dict:
+    def _rpc_blacklist(self, add: List[str] = None) -> Dict:
         """ Returns the currently active blacklist"""
         if add:
             stake_currency = self._freqtrade.config.get('stake_currency')

freqtrade/rpc/rpc_manager.py

@@ -29,6 +29,12 @@ class RPCManager(object):
             from freqtrade.rpc.webhook import Webhook
             self.registered_modules.append(Webhook(freqtrade))
 
+        # Enable local rest api server for cmd line control
+        if freqtrade.config.get('api_server', {}).get('enabled', False):
+            logger.info('Enabling rpc.api_server')
+            from freqtrade.rpc.api_server import ApiServer
+            self.registered_modules.append(ApiServer(freqtrade))
+
     def cleanup(self) -> None:
         """ Stops all enabled rpc modules """
         logger.info('Cleaning up rpc modules ...')

freqtrade/rpc/telegram.py

@@ -132,7 +132,7 @@ class Telegram(RPC):
                 msg['stake_amount_fiat'] = 0
 
             message = ("*{exchange}:* Buying {pair}\n"
-                       "with limit `{limit:.8f}\n"
+                       "at rate `{limit:.8f}\n"
                        "({stake_amount:.6f} {stake_currency}").format(**msg)
 
             if msg.get('fiat_currency', None):
@@ -144,7 +144,7 @@ class Telegram(RPC):
             msg['profit_percent'] = round(msg['profit_percent'] * 100, 2)
 
             message = ("*{exchange}:* Selling {pair}\n"
-                       "*Limit:* `{limit:.8f}`\n"
+                       "*Rate:* `{limit:.8f}`\n"
                        "*Amount:* `{amount:.8f}`\n"
                        "*Open Rate:* `{open_rate:.8f}`\n"
                        "*Current Rate:* `{current_rate:.8f}`\n"
@@ -193,14 +193,11 @@ class Telegram(RPC):
 
         try:
             results = self._rpc_trade_status()
-            # pre format data
-            for result in results:
-                result['date'] = result['date'].humanize()
 
             messages = []
             for r in results:
                 lines = [
-                    "*Trade ID:* `{trade_id}` `(since {date})`",
+                    "*Trade ID:* `{trade_id}` `(since {open_date_hum})`",
                     "*Current Pair:* {pair}",
                     "*Amount:* `{amount} ({stake_amount} {base_currency})`",
                     "*Open Rate:* `{open_rate:.8f}`",
@@ -220,7 +217,8 @@ class Telegram(RPC):
 
                     "*Open Order:* `{open_order}`" if r['open_order'] else ""
                 ]
-                messages.append("\n".join(filter(None, lines)).format(**r))
+                # Filter empty lines using list-comprehension
+                messages.append("\n".join([l for l in lines if l]).format(**r))
 
             for msg in messages:
                 self._send_msg(msg, bot=bot)
@@ -413,7 +411,9 @@ class Telegram(RPC):
 
         trade_id = update.message.text.replace('/forcesell', '').strip()
         try:
-            self._rpc_forcesell(trade_id)
+            msg = self._rpc_forcesell(trade_id)
+            self._send_msg('Forcesell Result: `{result}`'.format(**msg), bot=bot)
+
         except RPCException as e:
             self._send_msg(str(e), bot=bot)
 

freqtrade/state.py

@@ -18,11 +18,11 @@ class State(Enum):
 class RunMode(Enum):
     """
     Bot running mode (backtest, hyperopt, ...)
-    can be "live", "dry-run", "backtest", "edgecli", "hyperopt".
+    can be "live", "dry-run", "backtest", "edge", "hyperopt".
     """
     LIVE = "live"
     DRY_RUN = "dry_run"
     BACKTEST = "backtest"
-    EDGECLI = "edgecli"
+    EDGE = "edge"
     HYPEROPT = "hyperopt"
     OTHER = "other"  # Used for plotting scripts and test

freqtrade/strategy/__init__.py

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

freqtrade/strategy/interface.py

@@ -6,17 +6,18 @@ import logging
 from abc import ABC, abstractmethod
 from datetime import datetime
 from enum import Enum
-from typing import Dict, List, NamedTuple, Tuple
+from typing import Dict, List, NamedTuple, Optional, Tuple
 import warnings
 
 import arrow
 from pandas import DataFrame
 
 from freqtrade.data.dataprovider import DataProvider
-from freqtrade.misc import timeframe_to_minutes
+from freqtrade.exchange import timeframe_to_minutes
 from freqtrade.persistence import Trade
 from freqtrade.wallets import Wallets
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -157,7 +158,7 @@ class IStrategy(ABC):
         """
         Parses the given ticker history and returns a populated DataFrame
         add several TA indicators and buy signal to it
-        :return DataFrame with ticker data and indicator data
+        :return: DataFrame with ticker data and indicator data
         """
 
         pair = str(metadata.get('pair'))
@@ -307,14 +308,16 @@ class IStrategy(ABC):
 
         if trailing_stop:
             # trailing stoploss handling
-
             sl_offset = self.config.get('trailing_stop_positive_offset') or 0.0
             tsl_only_offset = self.config.get('trailing_only_offset_is_reached', False)
 
+            # Make sure current_profit is calculated using high for backtesting.
+            high_profit = current_profit if not high else trade.calc_profit_percent(high)
+
             # Don't update stoploss if trailing_only_offset_is_reached is true.
-            if not (tsl_only_offset and current_profit < sl_offset):
+            if not (tsl_only_offset and high_profit < sl_offset):
                 # Specific handling for trailing_stop_positive
-                if 'trailing_stop_positive' in self.config and current_profit > sl_offset:
+                if 'trailing_stop_positive' in self.config and high_profit > sl_offset:
                     # Ignore mypy error check in configuration that this is a float
                     stop_loss_value = self.config.get('trailing_stop_positive')  # type: ignore
                     logger.debug(f"using positive stop loss: {stop_loss_value} "
@@ -328,8 +331,9 @@ class IStrategy(ABC):
                 (not self.order_types.get('stoploss_on_exchange'))):
 
             selltype = SellType.STOP_LOSS
-            # If Trailing stop (and max-rate did move above open rate)
-            if trailing_stop and trade.open_rate != trade.max_rate:
+
+            # If initial stoploss is not the same as current one then it is trailing.
+            if trade.initial_stop_loss != trade.stop_loss:
                 selltype = SellType.TRAILING_STOP_LOSS
                 logger.debug(
                     f"HIT STOP: current price at {current_rate:.6f}, "
@@ -343,23 +347,32 @@ class IStrategy(ABC):
 
         return SellCheckTuple(sell_flag=False, sell_type=SellType.NONE)
 
+    def min_roi_reached_entry(self, trade_dur: int) -> Optional[float]:
+        """
+        Based on trade duration defines the ROI entry that may have been reached.
+        :param trade_dur: trade duration in minutes
+        :return: minimal ROI entry value or None if none proper ROI entry was found.
+        """
+        # Get highest entry in ROI dict where key <= trade-duration
+        roi_list = list(filter(lambda x: x <= trade_dur, self.minimal_roi.keys()))
+        if not roi_list:
+            return None
+        roi_entry = max(roi_list)
+        return self.minimal_roi[roi_entry]
+
     def min_roi_reached(self, trade: Trade, current_profit: float, current_time: datetime) -> bool:
         """
-        Based an earlier trade and current price and ROI configuration, decides whether bot should
+        Based on trade duration, current price and ROI configuration, decides whether bot should
         sell. Requires current_profit to be in percent!!
-        :return True if bot should sell at current rate
+        :return: True if bot should sell at current rate
         """
-
         # Check if time matches and current rate is above threshold
-        trade_dur = (current_time.timestamp() - trade.open_date.timestamp()) / 60
-
-        # Get highest entry in ROI dict where key >= trade-duration
-        roi_entry = max(list(filter(lambda x: trade_dur >= x, self.minimal_roi.keys())))
-        threshold = self.minimal_roi[roi_entry]
-        if current_profit > threshold:
-            return True
-
-        return False
+        trade_dur = int((current_time.timestamp() - trade.open_date.timestamp()) // 60)
+        roi = self.min_roi_reached_entry(trade_dur)
+        if roi is None:
+            return False
+        else:
+            return current_profit > roi
 
     def tickerdata_to_dataframe(self, tickerdata: Dict[str, List]) -> Dict[str, DataFrame]:
         """
@@ -376,6 +389,7 @@ class IStrategy(ABC):
         :param metadata: Additional information, like the currently traded pair
         :return: a Dataframe with all mandatory indicators for the strategies
         """
+        logger.debug(f"Populating indicators for pair {metadata.get('pair')}.")
         if self._populate_fun_len == 2:
             warnings.warn("deprecated - check out the Sample strategy to see "
                           "the current function headers!", DeprecationWarning)
@@ -391,6 +405,7 @@ class IStrategy(ABC):
         :param pair: Additional information, like the currently traded pair
         :return: DataFrame with buy column
         """
+        logger.debug(f"Populating buy signals for pair {metadata.get('pair')}.")
         if self._buy_fun_len == 2:
             warnings.warn("deprecated - check out the Sample strategy to see "
                           "the current function headers!", DeprecationWarning)
@@ -406,6 +421,7 @@ class IStrategy(ABC):
         :param pair: Additional information, like the currently traded pair
         :return: DataFrame with sell column
         """
+        logger.debug(f"Populating sell signals for pair {metadata.get('pair')}.")
         if self._sell_fun_len == 2:
             warnings.warn("deprecated - check out the Sample strategy to see "
                           "the current function headers!", DeprecationWarning)

freqtrade/tests/conftest.py

@@ -2,15 +2,18 @@
 import json
 import logging
 import re
+from copy import deepcopy
 from datetime import datetime
 from functools import reduce
+from pathlib import Path
 from unittest.mock import MagicMock, PropertyMock
 
 import arrow
 import pytest
 from telegram import Chat, Message, Update
 
-from freqtrade import constants
+from freqtrade import constants, persistence
+from freqtrade.configuration import Arguments
 from freqtrade.data.converter import parse_ticker_dataframe
 from freqtrade.edge import Edge, PairInfo
 from freqtrade.exchange import Exchange
@@ -18,6 +21,7 @@ from freqtrade.freqtradebot import FreqtradeBot
 from freqtrade.resolvers import ExchangeResolver
 from freqtrade.worker import Worker
 
+
 logging.getLogger('').setLevel(logging.INFO)
 
 
@@ -35,6 +39,17 @@ def log_has_re(line, logs):
                   False)
 
 
+def get_args(args):
+    return Arguments(args, '').get_parsed_arg()
+
+
+def patched_configuration_load_config_file(mocker, config) -> None:
+    mocker.patch(
+        'freqtrade.configuration.configuration.Configuration._load_config_file',
+        lambda *args, **kwargs: config
+    )
+
+
 def patch_exchange(mocker, api_mock=None, id='bittrex') -> None:
     mocker.patch('freqtrade.exchange.Exchange._load_markets', MagicMock(return_value={}))
     mocker.patch('freqtrade.exchange.Exchange.validate_pairs', MagicMock())
@@ -53,7 +68,7 @@ def get_patched_exchange(mocker, config, api_mock=None, id='bittrex') -> Exchang
     patch_exchange(mocker, api_mock, id)
     config["exchange"]["name"] = id
     try:
-        exchange = ExchangeResolver(id.title(), config).exchange
+        exchange = ExchangeResolver(id, config).exchange
     except ImportError:
         exchange = Exchange(config)
     return exchange
@@ -96,22 +111,44 @@ def patch_freqtradebot(mocker, config) -> None:
     :return: None
     """
     mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
-    mocker.patch('freqtrade.freqtradebot.persistence.init', MagicMock())
+    persistence.init(config['db_url'])
     patch_exchange(mocker, None)
     mocker.patch('freqtrade.freqtradebot.RPCManager._init', MagicMock())
     mocker.patch('freqtrade.freqtradebot.RPCManager.send_msg', MagicMock())
 
 
 def get_patched_freqtradebot(mocker, config) -> FreqtradeBot:
+    """
+    This function patches _init_modules() to not call dependencies
+    :param mocker: a Mocker object to apply patches
+    :param config: Config to pass to the bot
+    :return: FreqtradeBot
+    """
     patch_freqtradebot(mocker, config)
     return FreqtradeBot(config)
 
 
 def get_patched_worker(mocker, config) -> Worker:
+    """
+    This function patches _init_modules() to not call dependencies
+    :param mocker: a Mocker object to apply patches
+    :param config: Config to pass to the bot
+    :return: Worker
+    """
     patch_freqtradebot(mocker, config)
     return Worker(args=None, config=config)
 
 
+def patch_get_signal(freqtrade: FreqtradeBot, value=(True, False)) -> None:
+    """
+    :param mocker: mocker to patch IStrategy class
+    :param value: which value IStrategy.get_signal() must return
+    :return: None
+    """
+    freqtrade.strategy.get_signal = lambda e, s, t: value
+    freqtrade.exchange.refresh_latest_ohlcv = lambda p: None
+
+
 @pytest.fixture(autouse=True)
 def patch_coinmarketcap(mocker) -> None:
     """
@@ -134,6 +171,11 @@ def patch_coinmarketcap(mocker) -> None:
     )
 
 
+@pytest.fixture(scope='function')
+def init_persistence(default_conf):
+    persistence.init(default_conf['db_url'], default_conf['dry_run'])
+
+
 @pytest.fixture(scope="function")
 def default_conf():
     """ Returns validated configuration suitable for most tests """
@@ -192,7 +234,7 @@ def default_conf():
         },
         "initial_state": "running",
         "db_url": "sqlite://",
-        "loglevel": logging.DEBUG,
+        "verbosity": 3,
     }
     return configuration
 
@@ -639,7 +681,7 @@ def ticker_history_list():
 
 @pytest.fixture
 def ticker_history(ticker_history_list):
-    return parse_ticker_dataframe(ticker_history_list, "5m", True)
+    return parse_ticker_dataframe(ticker_history_list, "5m", pair="UNITTEST/BTC", fill_missing=True)
 
 
 @pytest.fixture
@@ -843,8 +885,9 @@ def tickers():
 
 @pytest.fixture
 def result():
-    with open('freqtrade/tests/testdata/UNITTEST_BTC-1m.json') as data_file:
-        return parse_ticker_dataframe(json.load(data_file), '1m', True)
+    with Path('freqtrade/tests/testdata/UNITTEST_BTC-1m.json').open('r') as data_file:
+        return parse_ticker_dataframe(json.load(data_file), '1m', pair="UNITTEST/BTC",
+                                      fill_missing=True)
 
 # FIX:
 # Create an fixture/function
@@ -942,9 +985,10 @@ def buy_order_fee():
 
 @pytest.fixture(scope="function")
 def edge_conf(default_conf):
-    default_conf['max_open_trades'] = -1
-    default_conf['stake_amount'] = constants.UNLIMITED_STAKE_AMOUNT
-    default_conf['edge'] = {
+    conf = deepcopy(default_conf)
+    conf['max_open_trades'] = -1
+    conf['stake_amount'] = constants.UNLIMITED_STAKE_AMOUNT
+    conf['edge'] = {
         "enabled": True,
         "process_throttle_secs": 1800,
         "calculate_since_number_of_days": 14,
@@ -960,4 +1004,40 @@ def edge_conf(default_conf):
         "remove_pumps": False
     }
 
-    return default_conf
+    return conf
+
+
+@pytest.fixture
+def rpc_balance():
+    return {
+        'BTC': {
+            'total': 12.0,
+            'free': 12.0,
+            'used': 0.0
+        },
+        'ETH': {
+            'total': 0.0,
+            'free': 0.0,
+            'used': 0.0
+        },
+        'USDT': {
+            'total': 10000.0,
+            'free': 10000.0,
+            'used': 0.0
+        },
+        'LTC': {
+            'total': 10.0,
+            'free': 10.0,
+            'used': 0.0
+        },
+        'XRP': {
+            'total': 1.0,
+            'free': 1.0,
+            'used': 0.0
+            },
+        'EUR': {
+            'total': 10.0,
+            'free': 10.0,
+            'used': 0.0
+        },
+    }

freqtrade/tests/data/test_btanalysis.py

@@ -1,8 +1,19 @@
-import pytest
-from pandas import DataFrame
+from unittest.mock import MagicMock
 
-from freqtrade.data.btanalysis import BT_DATA_COLUMNS, load_backtest_data
-from freqtrade.data.history import make_testdata_path
+import pytest
+from arrow import Arrow
+from pandas import DataFrame, to_datetime
+
+from freqtrade.configuration import Arguments, TimeRange
+from freqtrade.data.btanalysis import (BT_DATA_COLUMNS,
+                                       combine_tickers_with_mean,
+                                       create_cum_profit,
+                                       extract_trades_of_period,
+                                       load_backtest_data, load_trades,
+                                       load_trades_from_db)
+from freqtrade.data.history import (load_data, load_pair_history,
+                                    make_testdata_path)
+from freqtrade.tests.test_persistence import create_mock_trades
 
 
 def test_load_backtest_data():
@@ -19,3 +30,100 @@ def test_load_backtest_data():
 
     with pytest.raises(ValueError, match=r"File .* does not exist\."):
         load_backtest_data(str("filename") + "nofile")
+
+
+@pytest.mark.usefixtures("init_persistence")
+def test_load_trades_db(default_conf, fee, mocker):
+
+    create_mock_trades(fee)
+    # remove init so it does not init again
+    init_mock = mocker.patch('freqtrade.persistence.init', MagicMock())
+
+    trades = load_trades_from_db(db_url=default_conf['db_url'])
+    assert init_mock.call_count == 1
+    assert len(trades) == 3
+    assert isinstance(trades, DataFrame)
+    assert "pair" in trades.columns
+    assert "open_time" in trades.columns
+
+
+def test_extract_trades_of_period():
+    pair = "UNITTEST/BTC"
+    timerange = TimeRange(None, 'line', 0, -1000)
+
+    data = load_pair_history(pair=pair, ticker_interval='1m',
+                             datadir=None, timerange=timerange)
+
+    # timerange = 2017-11-14 06:07 - 2017-11-14 22:58:00
+    trades = DataFrame(
+        {'pair': [pair, pair, pair, pair],
+         'profit_percent': [0.0, 0.1, -0.2, -0.5],
+         'profit_abs': [0.0, 1, -2, -5],
+         'open_time': to_datetime([Arrow(2017, 11, 13, 15, 40, 0).datetime,
+                                   Arrow(2017, 11, 14, 9, 41, 0).datetime,
+                                   Arrow(2017, 11, 14, 14, 20, 0).datetime,
+                                   Arrow(2017, 11, 15, 3, 40, 0).datetime,
+                                   ], utc=True
+                                  ),
+         'close_time': to_datetime([Arrow(2017, 11, 13, 16, 40, 0).datetime,
+                                    Arrow(2017, 11, 14, 10, 41, 0).datetime,
+                                    Arrow(2017, 11, 14, 15, 25, 0).datetime,
+                                    Arrow(2017, 11, 15, 3, 55, 0).datetime,
+                                    ], utc=True)
+         })
+    trades1 = extract_trades_of_period(data, trades)
+    # First and last trade are dropped as they are out of range
+    assert len(trades1) == 2
+    assert trades1.iloc[0].open_time == Arrow(2017, 11, 14, 9, 41, 0).datetime
+    assert trades1.iloc[0].close_time == Arrow(2017, 11, 14, 10, 41, 0).datetime
+    assert trades1.iloc[-1].open_time == Arrow(2017, 11, 14, 14, 20, 0).datetime
+    assert trades1.iloc[-1].close_time == Arrow(2017, 11, 14, 15, 25, 0).datetime
+
+
+def test_load_trades(default_conf, mocker):
+    db_mock = mocker.patch("freqtrade.data.btanalysis.load_trades_from_db", MagicMock())
+    bt_mock = mocker.patch("freqtrade.data.btanalysis.load_backtest_data", MagicMock())
+
+    default_conf['trade_source'] = "DB"
+    load_trades(default_conf)
+
+    assert db_mock.call_count == 1
+    assert bt_mock.call_count == 0
+
+    db_mock.reset_mock()
+    bt_mock.reset_mock()
+    default_conf['trade_source'] = "file"
+    default_conf['exportfilename'] = "testfile.json"
+    load_trades(default_conf)
+
+    assert db_mock.call_count == 0
+    assert bt_mock.call_count == 1
+
+
+def test_combine_tickers_with_mean():
+    pairs = ["ETH/BTC", "XLM/BTC"]
+    tickers = load_data(datadir=None,
+                        pairs=pairs,
+                        ticker_interval='5m'
+                        )
+    df = combine_tickers_with_mean(tickers)
+    assert isinstance(df, DataFrame)
+    assert "ETH/BTC" in df.columns
+    assert "XLM/BTC" in df.columns
+    assert "mean" in df.columns
+
+
+def test_create_cum_profit():
+    filename = make_testdata_path(None) / "backtest-result_test.json"
+    bt_data = load_backtest_data(filename)
+    timerange = Arguments.parse_timerange("20180110-20180112")
+
+    df = load_pair_history(pair="POWR/BTC", ticker_interval='5m',
+                           datadir=None, timerange=timerange)
+
+    cum_profits = create_cum_profit(df.set_index('date'),
+                                    bt_data[bt_data["pair"] == 'POWR/BTC'],
+                                    "cum_profits")
+    assert "cum_profits" in cum_profits.columns
+    assert cum_profits.iloc[0]['cum_profits'] == 0
+    assert cum_profits.iloc[-1]['cum_profits'] == 0.0798005

freqtrade/tests/data/test_converter.py

@@ -2,8 +2,7 @@
 import logging
 
 from freqtrade.data.converter import parse_ticker_dataframe, ohlcv_fill_up_missing_data
-from freqtrade.data.history import load_pair_history
-from freqtrade.optimize import validate_backtest_data, get_timeframe
+from freqtrade.data.history import load_pair_history, validate_backtest_data, get_timeframe
 from freqtrade.tests.conftest import log_has
 
 
@@ -16,7 +15,8 @@ def test_parse_ticker_dataframe(ticker_history_list, caplog):
 
     caplog.set_level(logging.DEBUG)
     # Test file with BV data
-    dataframe = parse_ticker_dataframe(ticker_history_list, '5m', fill_missing=True)
+    dataframe = parse_ticker_dataframe(ticker_history_list, '5m',
+                                       pair="UNITTEST/BTC", fill_missing=True)
     assert dataframe.columns.tolist() == columns
     assert log_has('Parsing tickerlist to dataframe', caplog.record_tuples)
 
@@ -28,18 +28,19 @@ def test_ohlcv_fill_up_missing_data(caplog):
                              pair='UNITTEST/BTC',
                              fill_up_missing=False)
     caplog.set_level(logging.DEBUG)
-    data2 = ohlcv_fill_up_missing_data(data, '1m')
+    data2 = ohlcv_fill_up_missing_data(data, '1m', 'UNITTEST/BTC')
     assert len(data2) > len(data)
     # Column names should not change
     assert (data.columns == data2.columns).all()
 
-    assert log_has(f"Missing data fillup: before: {len(data)} - after: {len(data2)}",
+    assert log_has(f"Missing data fillup for UNITTEST/BTC: before: "
+                   f"{len(data)} - after: {len(data2)}",
                    caplog.record_tuples)
 
     # Test fillup actually fixes invalid backtest data
     min_date, max_date = get_timeframe({'UNITTEST/BTC': data})
-    assert validate_backtest_data({'UNITTEST/BTC': data}, min_date, max_date, 1)
-    assert not validate_backtest_data({'UNITTEST/BTC': data2}, min_date, max_date, 1)
+    assert validate_backtest_data(data, 'UNITTEST/BTC', min_date, max_date, 1)
+    assert not validate_backtest_data(data2, 'UNITTEST/BTC', min_date, max_date, 1)
 
 
 def test_ohlcv_fill_up_missing_data2(caplog):
@@ -79,10 +80,10 @@ def test_ohlcv_fill_up_missing_data2(caplog):
     ]
 
     # Generate test-data without filling missing
-    data = parse_ticker_dataframe(ticks, ticker_interval, fill_missing=False)
+    data = parse_ticker_dataframe(ticks, ticker_interval, pair="UNITTEST/BTC", fill_missing=False)
     assert len(data) == 3
     caplog.set_level(logging.DEBUG)
-    data2 = ohlcv_fill_up_missing_data(data, ticker_interval)
+    data2 = ohlcv_fill_up_missing_data(data, ticker_interval, "UNITTEST/BTC")
     assert len(data2) == 4
     # 3rd candle has been filled
     row = data2.loc[2, :]
@@ -95,5 +96,55 @@ def test_ohlcv_fill_up_missing_data2(caplog):
     # Column names should not change
     assert (data.columns == data2.columns).all()
 
-    assert log_has(f"Missing data fillup: before: {len(data)} - after: {len(data2)}",
+    assert log_has(f"Missing data fillup for UNITTEST/BTC: before: "
+                   f"{len(data)} - after: {len(data2)}",
                    caplog.record_tuples)
+
+
+def test_ohlcv_drop_incomplete(caplog):
+    ticker_interval = '1d'
+    ticks = [[
+            1559750400000,  # 2019-06-04
+            8.794e-05,  # open
+            8.948e-05,  # high
+            8.794e-05,  # low
+            8.88e-05,  # close
+            2255,  # volume (in quote currency)
+        ],
+        [
+            1559836800000,  # 2019-06-05
+            8.88e-05,
+            8.942e-05,
+            8.88e-05,
+            8.893e-05,
+            9911,
+        ],
+        [
+            1559923200000,  # 2019-06-06
+            8.891e-05,
+            8.893e-05,
+            8.875e-05,
+            8.877e-05,
+            2251
+        ],
+        [
+            1560009600000,  # 2019-06-07
+            8.877e-05,
+            8.883e-05,
+            8.895e-05,
+            8.817e-05,
+            123551
+     ]
+    ]
+    caplog.set_level(logging.DEBUG)
+    data = parse_ticker_dataframe(ticks, ticker_interval, pair="UNITTEST/BTC",
+                                  fill_missing=False, drop_incomplete=False)
+    assert len(data) == 4
+    assert not log_has("Dropping last candle", caplog.record_tuples)
+
+    # Drop last candle
+    data = parse_ticker_dataframe(ticks, ticker_interval, pair="UNITTEST/BTC",
+                                  fill_missing=False, drop_incomplete=True)
+    assert len(data) == 3
+
+    assert log_has("Dropping last candle", caplog.record_tuples)

freqtrade/tests/data/test_history.py

@@ -2,24 +2,27 @@
 
 import json
 import os
-from pathlib import Path
 import uuid
+from pathlib import Path
 from shutil import copyfile
+from unittest.mock import MagicMock
 
 import arrow
-from pandas import DataFrame
 import pytest
+from pandas import DataFrame
 
 from freqtrade import OperationalException
-from freqtrade.arguments import TimeRange
+from freqtrade.configuration import TimeRange
 from freqtrade.data import history
 from freqtrade.data.history import (download_pair_history,
                                     load_cached_data_for_updating,
-                                    load_tickerdata_file,
-                                    make_testdata_path,
+                                    load_tickerdata_file, make_testdata_path,
                                     trim_tickerlist)
+from freqtrade.exchange import timeframe_to_minutes
 from freqtrade.misc import file_dump_json
-from freqtrade.tests.conftest import get_patched_exchange, log_has
+from freqtrade.strategy.default_strategy import DefaultStrategy
+from freqtrade.tests.conftest import (get_patched_exchange, log_has,
+                                      patch_exchange)
 
 # Change this if modifying UNITTEST/BTC testdatafile
 _BTC_UNITTEST_LENGTH = 13681
@@ -59,7 +62,11 @@ def _clean_test_file(file: str) -> None:
 def test_load_data_30min_ticker(mocker, caplog, default_conf) -> None:
     ld = history.load_pair_history(pair='UNITTEST/BTC', ticker_interval='30m', datadir=None)
     assert isinstance(ld, DataFrame)
-    assert not log_has('Download the pair: "UNITTEST/BTC", Interval: 30m', caplog.record_tuples)
+    assert not log_has(
+        'Download history data for pair: "UNITTEST/BTC", interval: 30m '
+        'and store in None.',
+        caplog.record_tuples
+    )
 
 
 def test_load_data_7min_ticker(mocker, caplog, default_conf) -> None:
@@ -67,8 +74,11 @@ def test_load_data_7min_ticker(mocker, caplog, default_conf) -> None:
     assert not isinstance(ld, DataFrame)
     assert ld is None
     assert log_has(
-        'No data for pair: "UNITTEST/BTC", Interval: 7m. '
-        'Use --refresh-pairs-cached to download the data', caplog.record_tuples)
+        'No history data for pair: "UNITTEST/BTC", interval: 7m. '
+        'Use --refresh-pairs-cached option or download_backtest_data.py '
+        'script to download the data',
+        caplog.record_tuples
+    )
 
 
 def test_load_data_1min_ticker(ticker_history, mocker, caplog) -> None:
@@ -77,7 +87,11 @@ def test_load_data_1min_ticker(ticker_history, mocker, caplog) -> None:
     _backup_file(file, copy_file=True)
     history.load_data(datadir=None, ticker_interval='1m', pairs=['UNITTEST/BTC'])
     assert os.path.isfile(file) is True
-    assert not log_has('Download the pair: "UNITTEST/BTC", Interval: 1m', caplog.record_tuples)
+    assert not log_has(
+        'Download history data for pair: "UNITTEST/BTC", interval: 1m '
+        'and store in None.',
+        caplog.record_tuples
+    )
     _clean_test_file(file)
 
 
@@ -96,9 +110,12 @@ def test_load_data_with_new_pair_1min(ticker_history_list, mocker, caplog, defau
                               refresh_pairs=False,
                               pair='MEME/BTC')
     assert os.path.isfile(file) is False
-    assert log_has('No data for pair: "MEME/BTC", Interval: 1m. '
-                   'Use --refresh-pairs-cached to download the data',
-                   caplog.record_tuples)
+    assert log_has(
+        'No history data for pair: "MEME/BTC", interval: 1m. '
+        'Use --refresh-pairs-cached option or download_backtest_data.py '
+        'script to download the data',
+        caplog.record_tuples
+    )
 
     # download a new pair if refresh_pairs is set
     history.load_pair_history(datadir=None,
@@ -107,7 +124,11 @@ def test_load_data_with_new_pair_1min(ticker_history_list, mocker, caplog, defau
                               exchange=exchange,
                               pair='MEME/BTC')
     assert os.path.isfile(file) is True
-    assert log_has('Download the pair: "MEME/BTC", Interval: 1m', caplog.record_tuples)
+    assert log_has(
+        'Download history data for pair: "MEME/BTC", interval: 1m '
+        'and store in None.',
+        caplog.record_tuples
+    )
     with pytest.raises(OperationalException, match=r'Exchange needs to be initialized when.*'):
         history.load_pair_history(datadir=None,
                                   ticker_interval='1m',
@@ -117,6 +138,31 @@ def test_load_data_with_new_pair_1min(ticker_history_list, mocker, caplog, defau
     _clean_test_file(file)
 
 
+def test_load_data_live(default_conf, mocker, caplog) -> None:
+    refresh_mock = MagicMock()
+    mocker.patch("freqtrade.exchange.Exchange.refresh_latest_ohlcv", refresh_mock)
+    exchange = get_patched_exchange(mocker, default_conf)
+
+    history.load_data(datadir=None, ticker_interval='5m',
+                      pairs=['UNITTEST/BTC', 'UNITTEST2/BTC'],
+                      live=True,
+                      exchange=exchange)
+    assert refresh_mock.call_count == 1
+    assert len(refresh_mock.call_args_list[0][0][0]) == 2
+    assert log_has('Live: Downloading data for all defined pairs ...', caplog.record_tuples)
+
+
+def test_load_data_live_noexchange(default_conf, mocker, caplog) -> None:
+
+    with pytest.raises(OperationalException,
+                       match=r'Exchange needs to be initialized when using live data.'):
+        history.load_data(datadir=None, ticker_interval='5m',
+                          pairs=['UNITTEST/BTC', 'UNITTEST2/BTC'],
+                          exchange=None,
+                          live=True,
+                          )
+
+
 def test_testdata_path() -> None:
     assert str(Path('freqtrade') / 'tests' / 'testdata') in str(make_testdata_path(None))
 
@@ -287,7 +333,7 @@ def test_download_pair_history2(mocker, default_conf) -> None:
 
 def test_download_backtesting_data_exception(ticker_history, mocker, caplog, default_conf) -> None:
     mocker.patch('freqtrade.exchange.Exchange.get_history',
-                 side_effect=BaseException('File Error'))
+                 side_effect=Exception('File Error'))
 
     exchange = get_patched_exchange(mocker, default_conf)
 
@@ -302,7 +348,11 @@ def test_download_backtesting_data_exception(ticker_history, mocker, caplog, def
     # clean files freshly downloaded
     _clean_test_file(file1_1)
     _clean_test_file(file1_5)
-    assert log_has('Failed to download the pair: "MEME/BTC", Interval: 1m', caplog.record_tuples)
+    assert log_has(
+        'Failed to download history data for pair: "MEME/BTC", interval: 1m. '
+        'Error: File Error',
+        caplog.record_tuples
+    )
 
 
 def test_load_tickerdata_file() -> None:
@@ -473,3 +523,62 @@ def test_file_dump_json_tofile() -> None:
 
     # Remove the file
     _clean_test_file(file)
+
+
+def test_get_timeframe(default_conf, mocker) -> None:
+    patch_exchange(mocker)
+    strategy = DefaultStrategy(default_conf)
+
+    data = strategy.tickerdata_to_dataframe(
+        history.load_data(
+            datadir=None,
+            ticker_interval='1m',
+            pairs=['UNITTEST/BTC']
+        )
+    )
+    min_date, max_date = history.get_timeframe(data)
+    assert min_date.isoformat() == '2017-11-04T23:02:00+00:00'
+    assert max_date.isoformat() == '2017-11-14T22:58:00+00:00'
+
+
+def test_validate_backtest_data_warn(default_conf, mocker, caplog) -> None:
+    patch_exchange(mocker)
+    strategy = DefaultStrategy(default_conf)
+
+    data = strategy.tickerdata_to_dataframe(
+        history.load_data(
+            datadir=None,
+            ticker_interval='1m',
+            pairs=['UNITTEST/BTC'],
+            fill_up_missing=False
+        )
+    )
+    min_date, max_date = history.get_timeframe(data)
+    caplog.clear()
+    assert history.validate_backtest_data(data['UNITTEST/BTC'], 'UNITTEST/BTC',
+                                          min_date, max_date, timeframe_to_minutes('1m'))
+    assert len(caplog.record_tuples) == 1
+    assert log_has(
+        "UNITTEST/BTC has missing frames: expected 14396, got 13680, that's 716 missing values",
+        caplog.record_tuples)
+
+
+def test_validate_backtest_data(default_conf, mocker, caplog) -> None:
+    patch_exchange(mocker)
+    strategy = DefaultStrategy(default_conf)
+
+    timerange = TimeRange('index', 'index', 200, 250)
+    data = strategy.tickerdata_to_dataframe(
+        history.load_data(
+            datadir=None,
+            ticker_interval='5m',
+            pairs=['UNITTEST/BTC'],
+            timerange=timerange
+        )
+    )
+
+    min_date, max_date = history.get_timeframe(data)
+    caplog.clear()
+    assert not history.validate_backtest_data(data['UNITTEST/BTC'], 'UNITTEST/BTC',
+                                              min_date, max_date, timeframe_to_minutes('5m'))
+    assert len(caplog.record_tuples) == 0

freqtrade/tests/edge/test_edge.py

@@ -10,10 +10,11 @@ import numpy as np
 import pytest
 from pandas import DataFrame, to_datetime
 
+from freqtrade import OperationalException
 from freqtrade.data.converter import parse_ticker_dataframe
 from freqtrade.edge import Edge, PairInfo
 from freqtrade.strategy.interface import SellType
-from freqtrade.tests.conftest import get_patched_freqtradebot
+from freqtrade.tests.conftest import get_patched_freqtradebot, log_has
 from freqtrade.tests.optimize import (BTContainer, BTrade,
                                       _build_backtest_dataframe,
                                       _get_frame_time_from_offset)
@@ -30,7 +31,50 @@ ticker_start_time = arrow.get(2018, 10, 3)
 ticker_interval_in_minute = 60
 _ohlc = {'date': 0, 'buy': 1, 'open': 2, 'high': 3, 'low': 4, 'close': 5, 'sell': 6, 'volume': 7}
 
+# Helpers for this test file
 
+
+def _validate_ohlc(buy_ohlc_sell_matrice):
+    for index, ohlc in enumerate(buy_ohlc_sell_matrice):
+        # if not high < open < low or not high < close < low
+        if not ohlc[3] >= ohlc[2] >= ohlc[4] or not ohlc[3] >= ohlc[5] >= ohlc[4]:
+            raise Exception('Line ' + str(index + 1) + ' of ohlc has invalid values!')
+    return True
+
+
+def _build_dataframe(buy_ohlc_sell_matrice):
+    _validate_ohlc(buy_ohlc_sell_matrice)
+    tickers = []
+    for ohlc in buy_ohlc_sell_matrice:
+        ticker = {
+            'date': ticker_start_time.shift(
+                minutes=(
+                    ohlc[0] *
+                    ticker_interval_in_minute)).timestamp *
+            1000,
+            'buy': ohlc[1],
+            'open': ohlc[2],
+            'high': ohlc[3],
+            'low': ohlc[4],
+            'close': ohlc[5],
+            'sell': ohlc[6]}
+        tickers.append(ticker)
+
+    frame = DataFrame(tickers)
+    frame['date'] = to_datetime(frame['date'],
+                                unit='ms',
+                                utc=True,
+                                infer_datetime_format=True)
+
+    return frame
+
+
+def _time_on_candle(number):
+    return np.datetime64(ticker_start_time.shift(
+        minutes=(number * ticker_interval_in_minute)).timestamp * 1000, 'ms')
+
+
+# End helper functions
 # Open trade should be removed from the end
 tc0 = BTContainer(data=[
     # D  O     H     L     C     V    B  S
@@ -203,46 +247,6 @@ def test_nonexisting_stake_amount(mocker, edge_conf):
     assert edge.stake_amount('N/O', 1, 2, 1) == 0.15
 
 
-def _validate_ohlc(buy_ohlc_sell_matrice):
-    for index, ohlc in enumerate(buy_ohlc_sell_matrice):
-        # if not high < open < low or not high < close < low
-        if not ohlc[3] >= ohlc[2] >= ohlc[4] or not ohlc[3] >= ohlc[5] >= ohlc[4]:
-            raise Exception('Line ' + str(index + 1) + ' of ohlc has invalid values!')
-    return True
-
-
-def _build_dataframe(buy_ohlc_sell_matrice):
-    _validate_ohlc(buy_ohlc_sell_matrice)
-    tickers = []
-    for ohlc in buy_ohlc_sell_matrice:
-        ticker = {
-            'date': ticker_start_time.shift(
-                minutes=(
-                    ohlc[0] *
-                    ticker_interval_in_minute)).timestamp *
-            1000,
-            'buy': ohlc[1],
-            'open': ohlc[2],
-            'high': ohlc[3],
-            'low': ohlc[4],
-            'close': ohlc[5],
-            'sell': ohlc[6]}
-        tickers.append(ticker)
-
-    frame = DataFrame(tickers)
-    frame['date'] = to_datetime(frame['date'],
-                                unit='ms',
-                                utc=True,
-                                infer_datetime_format=True)
-
-    return frame
-
-
-def _time_on_candle(number):
-    return np.datetime64(ticker_start_time.shift(
-        minutes=(number * ticker_interval_in_minute)).timestamp * 1000, 'ms')
-
-
 def test_edge_heartbeat_calculate(mocker, edge_conf):
     freqtrade = get_patched_freqtradebot(mocker, edge_conf)
     edge = Edge(edge_conf, freqtrade.exchange, freqtrade.strategy)
@@ -259,7 +263,7 @@ def mocked_load_data(datadir, pairs=[], ticker_interval='0m', refresh_pairs=Fals
     hz = 0.1
     base = 0.001
 
-    ETHBTC = [
+    NEOBTC = [
         [
             ticker_start_time.shift(minutes=(x * ticker_interval_in_minute)).timestamp * 1000,
             math.sin(x * hz) / 1000 + base,
@@ -281,8 +285,8 @@ def mocked_load_data(datadir, pairs=[], ticker_interval='0m', refresh_pairs=Fals
             123.45
         ] for x in range(0, 500)]
 
-    pairdata = {'NEO/BTC': parse_ticker_dataframe(ETHBTC, '1h', fill_missing=True),
-                'LTC/BTC': parse_ticker_dataframe(LTCBTC, '1h', fill_missing=True)}
+    pairdata = {'NEO/BTC': parse_ticker_dataframe(NEOBTC, '1h', pair="NEO/BTC", fill_missing=True),
+                'LTC/BTC': parse_ticker_dataframe(LTCBTC, '1h', pair="LTC/BTC", fill_missing=True)}
     return pairdata
 
 
@@ -298,6 +302,40 @@ def test_edge_process_downloaded_data(mocker, edge_conf):
     assert edge._last_updated <= arrow.utcnow().timestamp + 2
 
 
+def test_edge_process_no_data(mocker, edge_conf, caplog):
+    edge_conf['datadir'] = None
+    freqtrade = get_patched_freqtradebot(mocker, edge_conf)
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', MagicMock(return_value=0.001))
+    mocker.patch('freqtrade.data.history.load_data', MagicMock(return_value={}))
+    edge = Edge(edge_conf, freqtrade.exchange, freqtrade.strategy)
+
+    assert not edge.calculate()
+    assert len(edge._cached_pairs) == 0
+    assert log_has("No data found. Edge is stopped ...", caplog.record_tuples)
+    assert edge._last_updated == 0
+
+
+def test_edge_process_no_trades(mocker, edge_conf, caplog):
+    edge_conf['datadir'] = None
+    freqtrade = get_patched_freqtradebot(mocker, edge_conf)
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', MagicMock(return_value=0.001))
+    mocker.patch('freqtrade.data.history.load_data', mocked_load_data)
+    # Return empty
+    mocker.patch('freqtrade.edge.Edge._find_trades_for_stoploss_range', MagicMock(return_value=[]))
+    edge = Edge(edge_conf, freqtrade.exchange, freqtrade.strategy)
+
+    assert not edge.calculate()
+    assert len(edge._cached_pairs) == 0
+    assert log_has("No trades found.", caplog.record_tuples)
+
+
+def test_edge_init_error(mocker, edge_conf,):
+    edge_conf['stake_amount'] = 0.5
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', MagicMock(return_value=0.001))
+    with pytest.raises(OperationalException,  match='Edge works only with unlimited stake amount'):
+        get_patched_freqtradebot(mocker, edge_conf)
+
+
 def test_process_expectancy(mocker, edge_conf):
     edge_conf['edge']['min_trade_number'] = 2
     freqtrade = get_patched_freqtradebot(mocker, edge_conf)
@@ -360,3 +398,11 @@ def test_process_expectancy(mocker, edge_conf):
     assert round(final['TEST/BTC'].risk_reward_ratio, 10) == 306.5384615384
     assert round(final['TEST/BTC'].required_risk_reward, 10) == 2.0
     assert round(final['TEST/BTC'].expectancy, 10) == 101.5128205128
+
+    # Pop last item so no trade is profitable
+    trades.pop()
+    trades_df = DataFrame(trades)
+    trades_df = edge._fill_calculable_fields(trades_df)
+    final = edge._process_expectancy(trades_df)
+    assert len(final) == 0
+    assert isinstance(final, dict)

freqtrade/tests/exchange/test_exchange.py

@@ -33,13 +33,13 @@ def get_mock_coro(return_value):
 def ccxt_exceptionhandlers(mocker, default_conf, api_mock, exchange_name,
                            fun, mock_ccxt_fun, **kwargs):
     with pytest.raises(TemporaryError):
-        api_mock.__dict__[mock_ccxt_fun] = MagicMock(side_effect=ccxt.NetworkError)
+        api_mock.__dict__[mock_ccxt_fun] = MagicMock(side_effect=ccxt.NetworkError("DeaDBeef"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
         getattr(exchange, fun)(**kwargs)
     assert api_mock.__dict__[mock_ccxt_fun].call_count == API_RETRY_COUNT + 1
 
     with pytest.raises(OperationalException):
-        api_mock.__dict__[mock_ccxt_fun] = MagicMock(side_effect=ccxt.BaseError)
+        api_mock.__dict__[mock_ccxt_fun] = MagicMock(side_effect=ccxt.BaseError("DeadBeef"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
         getattr(exchange, fun)(**kwargs)
     assert api_mock.__dict__[mock_ccxt_fun].call_count == 1
@@ -47,13 +47,13 @@ def ccxt_exceptionhandlers(mocker, default_conf, api_mock, exchange_name,
 
 async def async_ccxt_exception(mocker, default_conf, api_mock, fun, mock_ccxt_fun, **kwargs):
     with pytest.raises(TemporaryError):
-        api_mock.__dict__[mock_ccxt_fun] = MagicMock(side_effect=ccxt.NetworkError)
+        api_mock.__dict__[mock_ccxt_fun] = MagicMock(side_effect=ccxt.NetworkError("DeadBeef"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock)
         await getattr(exchange, fun)(**kwargs)
     assert api_mock.__dict__[mock_ccxt_fun].call_count == API_RETRY_COUNT + 1
 
     with pytest.raises(OperationalException):
-        api_mock.__dict__[mock_ccxt_fun] = MagicMock(side_effect=ccxt.BaseError)
+        api_mock.__dict__[mock_ccxt_fun] = MagicMock(side_effect=ccxt.BaseError("DeadBeef"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock)
         await getattr(exchange, fun)(**kwargs)
     assert api_mock.__dict__[mock_ccxt_fun].call_count == 1
@@ -124,14 +124,14 @@ def test_exchange_resolver(default_conf, mocker, caplog):
                       caplog.record_tuples)
     caplog.clear()
 
-    exchange = ExchangeResolver('Kraken', default_conf).exchange
+    exchange = ExchangeResolver('kraken', default_conf).exchange
     assert isinstance(exchange, Exchange)
     assert isinstance(exchange, Kraken)
     assert not isinstance(exchange, Binance)
     assert not log_has_re(r"No .* specific subclass found. Using the generic class instead.",
                           caplog.record_tuples)
 
-    exchange = ExchangeResolver('Binance', default_conf).exchange
+    exchange = ExchangeResolver('binance', default_conf).exchange
     assert isinstance(exchange, Exchange)
     assert isinstance(exchange, Binance)
     assert not isinstance(exchange, Kraken)
@@ -256,13 +256,13 @@ def test__load_async_markets(default_conf, mocker, caplog):
 def test__load_markets(default_conf, mocker, caplog):
     caplog.set_level(logging.INFO)
     api_mock = MagicMock()
-    api_mock.load_markets = MagicMock(side_effect=ccxt.BaseError())
+    api_mock.load_markets = MagicMock(side_effect=ccxt.BaseError("SomeError"))
     mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
     mocker.patch('freqtrade.exchange.Exchange.validate_pairs', MagicMock())
     mocker.patch('freqtrade.exchange.Exchange.validate_timeframes', MagicMock())
     mocker.patch('freqtrade.exchange.Exchange._load_async_markets', MagicMock())
     Exchange(default_conf)
-    assert log_has('Unable to initialize markets. Reason: ', caplog.record_tuples)
+    assert log_has('Unable to initialize markets. Reason: SomeError', caplog.record_tuples)
 
     expected_return = {'ETH/BTC': 'available'}
     api_mock = MagicMock()
@@ -301,6 +301,20 @@ def test__reload_markets(default_conf, mocker, caplog):
     assert log_has('Performing scheduled market reload..', caplog.record_tuples)
 
 
+def test__reload_markets_exception(default_conf, mocker, caplog):
+    caplog.set_level(logging.DEBUG)
+
+    api_mock = MagicMock()
+    api_mock.load_markets = MagicMock(side_effect=ccxt.NetworkError("LoadError"))
+    default_conf['exchange']['markets_refresh_interval'] = 10
+    exchange = get_patched_exchange(mocker, default_conf, api_mock, id="binance")
+
+    # less than 10 minutes have passed, no reload
+    exchange._reload_markets()
+    assert exchange._last_markets_refresh == 0
+    assert log_has_re(r"Could not reload markets.*", caplog.record_tuples)
+
+
 def test_validate_pairs(default_conf, mocker):  # test exchange.validate_pairs directly
     api_mock = MagicMock()
     type(api_mock).markets = PropertyMock(return_value={
@@ -382,6 +396,45 @@ def test_validate_timeframes_failed(default_conf, mocker):
         Exchange(default_conf)
 
 
+def test_validate_timeframes_emulated_ohlcv_1(default_conf, mocker):
+    default_conf["ticker_interval"] = "3m"
+    api_mock = MagicMock()
+    id_mock = PropertyMock(return_value='test_exchange')
+    type(api_mock).id = id_mock
+
+    # delete timeframes so magicmock does not autocreate it
+    del api_mock.timeframes
+
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
+    mocker.patch('freqtrade.exchange.Exchange._load_markets', MagicMock(return_value={}))
+    mocker.patch('freqtrade.exchange.Exchange.validate_pairs', MagicMock())
+    with pytest.raises(OperationalException,
+                       match=r'The ccxt library does not provide the list of timeframes '
+                             r'for the exchange ".*" and this exchange '
+                             r'is therefore not supported. *'):
+        Exchange(default_conf)
+
+
+def test_validate_timeframes_emulated_ohlcvi_2(default_conf, mocker):
+    default_conf["ticker_interval"] = "3m"
+    api_mock = MagicMock()
+    id_mock = PropertyMock(return_value='test_exchange')
+    type(api_mock).id = id_mock
+
+    # delete timeframes so magicmock does not autocreate it
+    del api_mock.timeframes
+
+    mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
+    mocker.patch('freqtrade.exchange.Exchange._load_markets',
+                 MagicMock(return_value={'timeframes': None}))
+    mocker.patch('freqtrade.exchange.Exchange.validate_pairs', MagicMock())
+    with pytest.raises(OperationalException,
+                       match=r'The ccxt library does not provide the list of timeframes '
+                             r'for the exchange ".*" and this exchange '
+                             r'is therefore not supported. *'):
+        Exchange(default_conf)
+
+
 def test_validate_timeframes_not_in_config(default_conf, mocker):
     del default_conf["ticker_interval"]
     api_mock = MagicMock()
@@ -490,15 +543,17 @@ def test_dry_run_order(default_conf, mocker, side, exchange_name):
     ("buy"),
     ("sell")
 ])
-@pytest.mark.parametrize("ordertype,rate", [
-    ("market", None),
-    ("limit", 200),
-    ("stop_loss_limit", 200)
+@pytest.mark.parametrize("ordertype,rate,marketprice", [
+    ("market", None, None),
+    ("market", 200, True),
+    ("limit", 200, None),
+    ("stop_loss_limit", 200, None)
 ])
 @pytest.mark.parametrize("exchange_name", EXCHANGES)
-def test_create_order(default_conf, mocker, side, ordertype, rate, exchange_name):
+def test_create_order(default_conf, mocker, side, ordertype, rate, marketprice, exchange_name):
     api_mock = MagicMock()
     order_id = 'test_prod_{}_{}'.format(side, randint(0, 10 ** 6))
+    api_mock.options = {} if not marketprice else {"createMarketBuyOrderRequiresPrice": True}
     api_mock.create_order = MagicMock(return_value={
         'id': order_id,
         'info': {
@@ -539,6 +594,7 @@ def test_buy_prod(default_conf, mocker, exchange_name):
     order_id = 'test_prod_buy_{}'.format(randint(0, 10 ** 6))
     order_type = 'market'
     time_in_force = 'gtc'
+    api_mock.options = {}
     api_mock.create_order = MagicMock(return_value={
         'id': order_id,
         'info': {
@@ -578,25 +634,25 @@ def test_buy_prod(default_conf, mocker, exchange_name):
 
     # test exception handling
     with pytest.raises(DependencyException):
-        api_mock.create_order = MagicMock(side_effect=ccxt.InsufficientFunds)
+        api_mock.create_order = MagicMock(side_effect=ccxt.InsufficientFunds("Not enough funds"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
         exchange.buy(pair='ETH/BTC', ordertype=order_type,
                      amount=1, rate=200, time_in_force=time_in_force)
 
     with pytest.raises(DependencyException):
-        api_mock.create_order = MagicMock(side_effect=ccxt.InvalidOrder)
+        api_mock.create_order = MagicMock(side_effect=ccxt.InvalidOrder("Order not found"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
         exchange.buy(pair='ETH/BTC', ordertype=order_type,
                      amount=1, rate=200, time_in_force=time_in_force)
 
     with pytest.raises(TemporaryError):
-        api_mock.create_order = MagicMock(side_effect=ccxt.NetworkError)
+        api_mock.create_order = MagicMock(side_effect=ccxt.NetworkError("Network disconnect"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
         exchange.buy(pair='ETH/BTC', ordertype=order_type,
                      amount=1, rate=200, time_in_force=time_in_force)
 
     with pytest.raises(OperationalException):
-        api_mock.create_order = MagicMock(side_effect=ccxt.BaseError)
+        api_mock.create_order = MagicMock(side_effect=ccxt.BaseError("Unknown error"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
         exchange.buy(pair='ETH/BTC', ordertype=order_type,
                      amount=1, rate=200, time_in_force=time_in_force)
@@ -606,6 +662,7 @@ def test_buy_prod(default_conf, mocker, exchange_name):
 def test_buy_considers_time_in_force(default_conf, mocker, exchange_name):
     api_mock = MagicMock()
     order_id = 'test_prod_buy_{}'.format(randint(0, 10 ** 6))
+    api_mock.options = {}
     api_mock.create_order = MagicMock(return_value={
         'id': order_id,
         'info': {
@@ -666,6 +723,7 @@ def test_sell_prod(default_conf, mocker, exchange_name):
     api_mock = MagicMock()
     order_id = 'test_prod_sell_{}'.format(randint(0, 10 ** 6))
     order_type = 'market'
+    api_mock.options = {}
     api_mock.create_order = MagicMock(return_value={
         'id': order_id,
         'info': {
@@ -700,22 +758,22 @@ def test_sell_prod(default_conf, mocker, exchange_name):
 
     # test exception handling
     with pytest.raises(DependencyException):
-        api_mock.create_order = MagicMock(side_effect=ccxt.InsufficientFunds)
+        api_mock.create_order = MagicMock(side_effect=ccxt.InsufficientFunds("0 balance"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
         exchange.sell(pair='ETH/BTC', ordertype=order_type, amount=1, rate=200)
 
     with pytest.raises(DependencyException):
-        api_mock.create_order = MagicMock(side_effect=ccxt.InvalidOrder)
+        api_mock.create_order = MagicMock(side_effect=ccxt.InvalidOrder("Order not found"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
         exchange.sell(pair='ETH/BTC', ordertype=order_type, amount=1, rate=200)
 
     with pytest.raises(TemporaryError):
-        api_mock.create_order = MagicMock(side_effect=ccxt.NetworkError)
+        api_mock.create_order = MagicMock(side_effect=ccxt.NetworkError("No Connection"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
         exchange.sell(pair='ETH/BTC', ordertype=order_type, amount=1, rate=200)
 
     with pytest.raises(OperationalException):
-        api_mock.create_order = MagicMock(side_effect=ccxt.BaseError)
+        api_mock.create_order = MagicMock(side_effect=ccxt.BaseError("DeadBeef"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
         exchange.sell(pair='ETH/BTC', ordertype=order_type, amount=1, rate=200)
 
@@ -730,6 +788,7 @@ def test_sell_considers_time_in_force(default_conf, mocker, exchange_name):
             'foo': 'bar'
         }
     })
+    api_mock.options = {}
     default_conf['dry_run'] = False
     mocker.patch('freqtrade.exchange.Exchange.symbol_amount_prec', lambda s, x, y: y)
     mocker.patch('freqtrade.exchange.Exchange.symbol_price_prec', lambda s, x, y: y)
@@ -787,7 +846,7 @@ def test_get_balance_prod(default_conf, mocker, exchange_name):
     assert exchange.get_balance(currency='BTC') == 123.4
 
     with pytest.raises(OperationalException):
-        api_mock.fetch_balance = MagicMock(side_effect=ccxt.BaseError)
+        api_mock.fetch_balance = MagicMock(side_effect=ccxt.BaseError("Unknown error"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
 
         exchange.get_balance(currency='BTC')
@@ -860,7 +919,7 @@ def test_get_tickers(default_conf, mocker, exchange_name):
                            "get_tickers", "fetch_tickers")
 
     with pytest.raises(OperationalException):
-        api_mock.fetch_tickers = MagicMock(side_effect=ccxt.NotSupported)
+        api_mock.fetch_tickers = MagicMock(side_effect=ccxt.NotSupported("DeadBeef"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
         exchange.get_tickers()
 
@@ -879,7 +938,7 @@ def test_get_ticker(default_conf, mocker, exchange_name):
         'last': 0.0001,
     }
     api_mock.fetch_ticker = MagicMock(return_value=tick)
-    api_mock.markets = {'ETH/BTC': {}}
+    api_mock.markets = {'ETH/BTC': {'active': True}}
     exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
     # retrieve original ticker
     ticker = exchange.get_ticker(pair='ETH/BTC')
@@ -1002,7 +1061,7 @@ def test_refresh_latest_ohlcv(mocker, default_conf, caplog) -> None:
     exchange.refresh_latest_ohlcv([('IOTA/ETH', '5m'), ('XRP/ETH', '5m')])
 
     assert exchange._api_async.fetch_ohlcv.call_count == 2
-    assert log_has(f"Using cached ohlcv data for {pairs[0][0]}, {pairs[0][1]} ...",
+    assert log_has(f"Using cached ohlcv data for pair {pairs[0][0]}, interval {pairs[0][1]} ...",
                    caplog.record_tuples)
 
 
@@ -1042,7 +1101,7 @@ async def test__async_get_candle_history(default_conf, mocker, caplog, exchange_
 
     api_mock = MagicMock()
     with pytest.raises(OperationalException, match=r'Could not fetch ticker data*'):
-        api_mock.fetch_ohlcv = MagicMock(side_effect=ccxt.BaseError)
+        api_mock.fetch_ohlcv = MagicMock(side_effect=ccxt.BaseError("Unknown error"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
         await exchange._async_get_candle_history(pair, "5m",
                                                  (arrow.utcnow().timestamp - 2000) * 1000)
@@ -1114,15 +1173,15 @@ def test_get_order_book(default_conf, mocker, order_book_l2, exchange_name):
 def test_get_order_book_exception(default_conf, mocker, exchange_name):
     api_mock = MagicMock()
     with pytest.raises(OperationalException):
-        api_mock.fetch_l2_order_book = MagicMock(side_effect=ccxt.NotSupported)
+        api_mock.fetch_l2_order_book = MagicMock(side_effect=ccxt.NotSupported("Not supported"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
         exchange.get_order_book(pair='ETH/BTC', limit=50)
     with pytest.raises(TemporaryError):
-        api_mock.fetch_l2_order_book = MagicMock(side_effect=ccxt.NetworkError)
+        api_mock.fetch_l2_order_book = MagicMock(side_effect=ccxt.NetworkError("DeadBeef"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
         exchange.get_order_book(pair='ETH/BTC', limit=50)
     with pytest.raises(OperationalException):
-        api_mock.fetch_l2_order_book = MagicMock(side_effect=ccxt.BaseError)
+        api_mock.fetch_l2_order_book = MagicMock(side_effect=ccxt.BaseError("DeadBeef"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
         exchange.get_order_book(pair='ETH/BTC', limit=50)
 
@@ -1235,7 +1294,7 @@ def test_cancel_order(default_conf, mocker, exchange_name):
     assert exchange.cancel_order(order_id='_', pair='TKN/BTC') == 123
 
     with pytest.raises(InvalidOrderException):
-        api_mock.cancel_order = MagicMock(side_effect=ccxt.InvalidOrder)
+        api_mock.cancel_order = MagicMock(side_effect=ccxt.InvalidOrder("Did not find order"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
         exchange.cancel_order(order_id='_', pair='TKN/BTC')
     assert api_mock.cancel_order.call_count == 1
@@ -1262,7 +1321,7 @@ def test_get_order(default_conf, mocker, exchange_name):
     assert exchange.get_order('X', 'TKN/BTC') == 456
 
     with pytest.raises(InvalidOrderException):
-        api_mock.fetch_order = MagicMock(side_effect=ccxt.InvalidOrder)
+        api_mock.fetch_order = MagicMock(side_effect=ccxt.InvalidOrder("Order not found"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
         exchange.get_order(order_id='_', pair='TKN/BTC')
     assert api_mock.fetch_order.call_count == 1
@@ -1378,22 +1437,22 @@ def test_stoploss_limit_order(default_conf, mocker):
 
     # test exception handling
     with pytest.raises(DependencyException):
-        api_mock.create_order = MagicMock(side_effect=ccxt.InsufficientFunds)
+        api_mock.create_order = MagicMock(side_effect=ccxt.InsufficientFunds("0 balance"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock)
         exchange.stoploss_limit(pair='ETH/BTC', amount=1, stop_price=220, rate=200)
 
     with pytest.raises(DependencyException):
-        api_mock.create_order = MagicMock(side_effect=ccxt.InvalidOrder)
+        api_mock.create_order = MagicMock(side_effect=ccxt.InvalidOrder("Order not found"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock)
         exchange.stoploss_limit(pair='ETH/BTC', amount=1, stop_price=220, rate=200)
 
     with pytest.raises(TemporaryError):
-        api_mock.create_order = MagicMock(side_effect=ccxt.NetworkError)
+        api_mock.create_order = MagicMock(side_effect=ccxt.NetworkError("No connection"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock)
         exchange.stoploss_limit(pair='ETH/BTC', amount=1, stop_price=220, rate=200)
 
     with pytest.raises(OperationalException):
-        api_mock.create_order = MagicMock(side_effect=ccxt.BaseError)
+        api_mock.create_order = MagicMock(side_effect=ccxt.BaseError("DeadBeef"))
         exchange = get_patched_exchange(mocker, default_conf, api_mock)
         exchange.stoploss_limit(pair='ETH/BTC', amount=1, stop_price=220, rate=200)
 
@@ -1421,3 +1480,46 @@ def test_stoploss_limit_order_dry_run(default_conf, mocker):
     assert order['type'] == order_type
     assert order['price'] == 220
     assert order['amount'] == 1
+
+
+def test_merge_ft_has_dict(default_conf, mocker):
+    mocker.patch.multiple('freqtrade.exchange.Exchange',
+                          _init_ccxt=MagicMock(return_value=MagicMock()),
+                          _load_async_markets=MagicMock(),
+                          validate_pairs=MagicMock(),
+                          validate_timeframes=MagicMock())
+    ex = Exchange(default_conf)
+    assert ex._ft_has == Exchange._ft_has_default
+
+    ex = Kraken(default_conf)
+    assert ex._ft_has == Exchange._ft_has_default
+
+    # Binance defines different values
+    ex = Binance(default_conf)
+    assert ex._ft_has != Exchange._ft_has_default
+    assert ex._ft_has['stoploss_on_exchange']
+    assert ex._ft_has['order_time_in_force'] == ['gtc', 'fok', 'ioc']
+
+    conf = copy.deepcopy(default_conf)
+    conf['exchange']['_ft_has_params'] = {"DeadBeef": 20,
+                                          "stoploss_on_exchange": False}
+    # Use settings from configuration (overriding stoploss_on_exchange)
+    ex = Binance(conf)
+    assert ex._ft_has != Exchange._ft_has_default
+    assert not ex._ft_has['stoploss_on_exchange']
+    assert ex._ft_has['DeadBeef'] == 20
+
+
+def test_get_valid_pair_combination(default_conf, mocker, markets):
+    mocker.patch.multiple('freqtrade.exchange.Exchange',
+                          _init_ccxt=MagicMock(return_value=MagicMock()),
+                          _load_async_markets=MagicMock(),
+                          validate_pairs=MagicMock(),
+                          validate_timeframes=MagicMock(),
+                          markets=PropertyMock(return_value=markets))
+    ex = Exchange(default_conf)
+
+    assert ex.get_valid_pair_combination("ETH", "BTC") == "ETH/BTC"
+    assert ex.get_valid_pair_combination("BTC", "ETH") == "ETH/BTC"
+    with pytest.raises(DependencyException, match=r"Could not combine.* to get a valid pair."):
+        ex.get_valid_pair_combination("NOPAIR", "ETH")

freqtrade/tests/exchange/test_kraken.py

@@ -11,6 +11,7 @@ def test_buy_kraken_trading_agreement(default_conf, mocker):
     order_id = 'test_prod_buy_{}'.format(randint(0, 10 ** 6))
     order_type = 'limit'
     time_in_force = 'ioc'
+    api_mock.options = {}
     api_mock.create_order = MagicMock(return_value={
         'id': order_id,
         'info': {
@@ -42,6 +43,7 @@ def test_sell_kraken_trading_agreement(default_conf, mocker):
     api_mock = MagicMock()
     order_id = 'test_prod_sell_{}'.format(randint(0, 10 ** 6))
     order_type = 'market'
+    api_mock.options = {}
     api_mock.create_order = MagicMock(return_value={
         'id': order_id,
         'info': {

freqtrade/tests/optimize/__init__.py

@@ -3,7 +3,7 @@ from typing import NamedTuple, List
 import arrow
 from pandas import DataFrame
 
-from freqtrade.misc import timeframe_to_minutes
+from freqtrade.exchange import timeframe_to_minutes
 from freqtrade.strategy.interface import SellType
 
 ticker_start_time = arrow.get(2018, 10, 3)
@@ -29,6 +29,10 @@ class BTContainer(NamedTuple):
     trades: List[BTrade]
     profit_perc: float
     trailing_stop: bool = False
+    trailing_only_offset_is_reached: bool = False
+    trailing_stop_positive: float = None
+    trailing_stop_positive_offset: float = 0.0
+    use_sell_signal: bool = False
 
 
 def _get_frame_time_from_offset(offset):

freqtrade/tests/optimize/test_backtest_detail.py

@@ -2,17 +2,32 @@
 import logging
 from unittest.mock import MagicMock
 
-from pandas import DataFrame
 import pytest
+from pandas import DataFrame
 
-
-from freqtrade.optimize import get_timeframe
+from freqtrade.data.history import get_timeframe
 from freqtrade.optimize.backtesting import Backtesting
 from freqtrade.strategy.interface import SellType
-from freqtrade.tests.optimize import (BTrade, BTContainer, _build_backtest_dataframe,
-                                      _get_frame_time_from_offset, tests_ticker_interval)
 from freqtrade.tests.conftest import patch_exchange
+from freqtrade.tests.optimize import (BTContainer, BTrade,
+                                      _build_backtest_dataframe,
+                                      _get_frame_time_from_offset,
+                                      tests_ticker_interval)
 
+# Test 0 Sell signal sell
+# Test with Stop-loss at 1%
+# TC0: Sell signal in candle 3
+tc0 = BTContainer(data=[
+    # D  O     H     L     C     V    B  S
+    [0, 5000, 5025, 4975, 4987, 6172, 1, 0],
+    [1, 5000, 5025, 4975, 4987, 6172, 0, 0],  # enter trade (signal on last candle)
+    [2, 4987, 5012, 4986, 4600, 6172, 0, 0],  # exit with stoploss hit
+    [3, 5010, 5000, 4980, 5010, 6172, 0, 1],
+    [4, 5010, 4987, 4977, 4995, 6172, 0, 0],
+    [5, 4995, 4995, 4995, 4950, 6172, 0, 0]],
+    stop_loss=-0.01, roi=1, profit_perc=0.002, use_sell_signal=True,
+    trades=[BTrade(sell_reason=SellType.SELL_SIGNAL, open_tick=1, close_tick=4)]
+)
 
 # Test 1 Minus 8% Close
 # Test with Stop-loss at 1%
@@ -146,7 +161,7 @@ tc8 = BTContainer(data=[
 # Test 9 - trailing_stop should raise - high and low in same candle.
 # Candle Data for test 9
 # Set stop-loss at 10%, ROI at 10% (should not apply)
-# TC9: Trailing stoploss - stoploss should be adjusted candle 2
+# TC9: Trailing stoploss - stoploss should be adjusted candle 3
 tc9 = BTContainer(data=[
     # D   O     H     L     C    V    B  S
     [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
@@ -158,7 +173,59 @@ tc9 = BTContainer(data=[
     trades=[BTrade(sell_reason=SellType.TRAILING_STOP_LOSS, open_tick=1, close_tick=3)]
 )
 
+# Test 10 - trailing_stop should raise so candle 3 causes a stoploss
+# without applying trailing_stop_positive since stoploss_offset is at 10%.
+# Set stop-loss at 10%, ROI at 10% (should not apply)
+# TC10: Trailing stoploss - stoploss should be adjusted candle 2
+tc10 = BTContainer(data=[
+    # D   O     H     L     C    V    B  S
+    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
+    [1, 5000, 5050, 4950, 5100, 6172, 0, 0],
+    [2, 5100, 5251, 5100, 5100, 6172, 0, 0],
+    [3, 4850, 5050, 4650, 4750, 6172, 0, 0],
+    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
+    stop_loss=-0.10, roi=0.10, profit_perc=-0.1, trailing_stop=True,
+    trailing_only_offset_is_reached=True, trailing_stop_positive_offset=0.10,
+    trailing_stop_positive=0.03,
+    trades=[BTrade(sell_reason=SellType.STOP_LOSS, open_tick=1, close_tick=4)]
+)
+
+# Test 11 - trailing_stop should raise so candle 3 causes a stoploss
+# applying a positive trailing stop of 3% since stop_positive_offset is reached.
+# Set stop-loss at 10%, ROI at 10% (should not apply)
+# TC11: Trailing stoploss - stoploss should be adjusted candle 2,
+tc11 = BTContainer(data=[
+    # D   O     H     L     C    V    B  S
+    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
+    [1, 5000, 5050, 4950, 5100, 6172, 0, 0],
+    [2, 5100, 5251, 5100, 5100, 6172, 0, 0],
+    [3, 4850, 5050, 4650, 4750, 6172, 0, 0],
+    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
+    stop_loss=-0.10, roi=0.10, profit_perc=0.019, trailing_stop=True,
+    trailing_only_offset_is_reached=True, trailing_stop_positive_offset=0.05,
+    trailing_stop_positive=0.03,
+    trades=[BTrade(sell_reason=SellType.TRAILING_STOP_LOSS, open_tick=1, close_tick=3)]
+)
+
+# Test 12 - trailing_stop should raise in candle 2 and cause a stoploss in the same candle
+# applying a positive trailing stop of 3% since stop_positive_offset is reached.
+# Set stop-loss at 10%, ROI at 10% (should not apply)
+# TC12: Trailing stoploss - stoploss should be adjusted candle 2,
+tc12 = BTContainer(data=[
+    # D   O     H     L     C    V    B  S
+    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
+    [1, 5000, 5050, 4950, 5100, 6172, 0, 0],
+    [2, 5100, 5251, 4650, 5100, 6172, 0, 0],
+    [3, 4850, 5050, 4650, 4750, 6172, 0, 0],
+    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
+    stop_loss=-0.10, roi=0.10, profit_perc=0.019, trailing_stop=True,
+    trailing_only_offset_is_reached=True, trailing_stop_positive_offset=0.05,
+    trailing_stop_positive=0.03,
+    trades=[BTrade(sell_reason=SellType.TRAILING_STOP_LOSS, open_tick=1, close_tick=2)]
+)
+
 TESTS = [
+    tc0,
     tc1,
     tc2,
     tc3,
@@ -168,6 +235,9 @@ TESTS = [
     tc7,
     tc8,
     tc9,
+    tc10,
+    tc11,
+    tc12,
 ]
 
 
@@ -180,6 +250,13 @@ def test_backtest_results(default_conf, fee, mocker, caplog, data) -> None:
     default_conf["minimal_roi"] = {"0": data.roi}
     default_conf["ticker_interval"] = tests_ticker_interval
     default_conf["trailing_stop"] = data.trailing_stop
+    default_conf["trailing_only_offset_is_reached"] = data.trailing_only_offset_is_reached
+    # Only add this to configuration If it's necessary
+    if data.trailing_stop_positive:
+        default_conf["trailing_stop_positive"] = data.trailing_stop_positive
+    default_conf["trailing_stop_positive_offset"] = data.trailing_stop_positive_offset
+    default_conf["experimental"] = {"use_sell_signal": data.use_sell_signal}
+
     mocker.patch("freqtrade.exchange.Exchange.get_fee", MagicMock(return_value=0.0))
     patch_exchange(mocker)
     frame = _build_backtest_dataframe(data.data)

freqtrade/tests/optimize/test_backtesting.py

@@ -1,9 +1,7 @@
 # pragma pylint: disable=missing-docstring, W0212, line-too-long, C0103, unused-argument
 
-import json
 import math
 import random
-from typing import List
 from unittest.mock import MagicMock
 
 import numpy as np
@@ -12,28 +10,25 @@ import pytest
 from arrow import Arrow
 
 from freqtrade import DependencyException, constants
-from freqtrade.arguments import Arguments, TimeRange
+from freqtrade.configuration import TimeRange
 from freqtrade.data import history
 from freqtrade.data.btanalysis import evaluate_result_multi
 from freqtrade.data.converter import parse_ticker_dataframe
 from freqtrade.data.dataprovider import DataProvider
-from freqtrade.optimize import get_timeframe
-from freqtrade.optimize.backtesting import (Backtesting, setup_configuration,
-                                            start)
+from freqtrade.data.history import get_timeframe
+from freqtrade.optimize import setup_configuration, start_backtesting
+from freqtrade.optimize.backtesting import Backtesting
 from freqtrade.state import RunMode
 from freqtrade.strategy.default_strategy import DefaultStrategy
 from freqtrade.strategy.interface import SellType
-from freqtrade.tests.conftest import log_has, patch_exchange
-
-
-def get_args(args) -> List[str]:
-    return Arguments(args, '').get_parsed_arg()
+from freqtrade.tests.conftest import (get_args, log_has, log_has_re, patch_exchange,
+                                      patched_configuration_load_config_file)
 
 
 def trim_dictlist(dict_list, num):
     new = {}
     for pair, pair_data in dict_list.items():
-        new[pair] = pair_data[num:]
+        new[pair] = pair_data[num:].reset_index()
     return new
 
 
@@ -78,7 +73,8 @@ def load_data_test(what):
                 pair[x][5]  # Keep old volume
             ] for x in range(0, datalen)
         ]
-    return {'UNITTEST/BTC': parse_ticker_dataframe(data, '1m', fill_missing=True)}
+    return {'UNITTEST/BTC': parse_ticker_dataframe(data, '1m', pair="UNITTEST/BTC",
+                                                   fill_missing=True)}
 
 
 def simple_backtest(config, contour, num_results, mocker) -> None:
@@ -105,9 +101,10 @@ def simple_backtest(config, contour, num_results, mocker) -> None:
 
 
 def mocked_load_data(datadir, pairs=[], ticker_interval='0m', refresh_pairs=False,
-                     timerange=None, exchange=None):
+                     timerange=None, exchange=None, live=False):
     tickerdata = history.load_tickerdata_file(datadir, 'UNITTEST/BTC', '1m', timerange=timerange)
-    pairdata = {'UNITTEST/BTC': parse_ticker_dataframe(tickerdata, '1m', fill_missing=True)}
+    pairdata = {'UNITTEST/BTC': parse_ticker_dataframe(tickerdata, '1m', pair="UNITTEST/BTC",
+                                                       fill_missing=True)}
     return pairdata
 
 
@@ -168,9 +165,7 @@ def _trend_alternate(dataframe=None, metadata=None):
 
 # Unit tests
 def test_setup_configuration_without_arguments(mocker, default_conf, caplog) -> None:
-    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
-        read_data=json.dumps(default_conf)
-    ))
+    patched_configuration_load_config_file(mocker, default_conf)
 
     args = [
         '--config', 'config.json',
@@ -178,7 +173,7 @@ def test_setup_configuration_without_arguments(mocker, default_conf, caplog) ->
         'backtesting'
     ]
 
-    config = setup_configuration(get_args(args))
+    config = setup_configuration(get_args(args), RunMode.BACKTEST)
     assert 'max_open_trades' in config
     assert 'stake_currency' in config
     assert 'stake_amount' in config
@@ -186,11 +181,11 @@ def test_setup_configuration_without_arguments(mocker, default_conf, caplog) ->
     assert 'pair_whitelist' in config['exchange']
     assert 'datadir' in config
     assert log_has(
-        'Using data folder: {} ...'.format(config['datadir']),
+        'Using data directory: {} ...'.format(config['datadir']),
         caplog.record_tuples
     )
     assert 'ticker_interval' in config
-    assert not log_has('Parameter -i/--ticker-interval detected ...', caplog.record_tuples)
+    assert not log_has_re('Parameter -i/--ticker-interval detected .*', caplog.record_tuples)
 
     assert 'live' not in config
     assert not log_has('Parameter -l/--live detected ...', caplog.record_tuples)
@@ -208,10 +203,11 @@ def test_setup_configuration_without_arguments(mocker, default_conf, caplog) ->
 
 
 def test_setup_bt_configuration_with_arguments(mocker, default_conf, caplog) -> None:
-    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
-        read_data=json.dumps(default_conf)
-    ))
-    mocker.patch('freqtrade.configuration.Configuration._create_datadir', lambda s, c, x: x)
+    patched_configuration_load_config_file(mocker, default_conf)
+    mocker.patch(
+        'freqtrade.configuration.configuration.create_datadir',
+        lambda c, x: x
+    )
 
     args = [
         '--config', 'config.json',
@@ -228,7 +224,7 @@ def test_setup_bt_configuration_with_arguments(mocker, default_conf, caplog) ->
         '--export-filename', 'foo_bar.json'
     ]
 
-    config = setup_configuration(get_args(args))
+    config = setup_configuration(get_args(args), RunMode.BACKTEST)
     assert 'max_open_trades' in config
     assert 'stake_currency' in config
     assert 'stake_amount' in config
@@ -238,15 +234,12 @@ def test_setup_bt_configuration_with_arguments(mocker, default_conf, caplog) ->
     assert config['runmode'] == RunMode.BACKTEST
 
     assert log_has(
-        'Using data folder: {} ...'.format(config['datadir']),
+        'Using data directory: {} ...'.format(config['datadir']),
         caplog.record_tuples
     )
     assert 'ticker_interval' in config
-    assert log_has('Parameter -i/--ticker-interval detected ...', caplog.record_tuples)
-    assert log_has(
-        'Using ticker_interval: 1m ...',
-        caplog.record_tuples
-    )
+    assert log_has('Parameter -i/--ticker-interval detected ... Using ticker_interval: 1m ...',
+                   caplog.record_tuples)
 
     assert 'live' in config
     assert log_has('Parameter -l/--live detected ...', caplog.record_tuples)
@@ -260,6 +253,7 @@ def test_setup_bt_configuration_with_arguments(mocker, default_conf, caplog) ->
 
     assert 'refresh_pairs' in config
     assert log_has('Parameter -r/--refresh-pairs-cached detected ...', caplog.record_tuples)
+
     assert 'timerange' in config
     assert log_has(
         'Parameter --timerange detected: {} ...'.format(config['timerange']),
@@ -281,9 +275,7 @@ def test_setup_bt_configuration_with_arguments(mocker, default_conf, caplog) ->
 def test_setup_configuration_unlimited_stake_amount(mocker, default_conf, caplog) -> None:
     default_conf['stake_amount'] = constants.UNLIMITED_STAKE_AMOUNT
 
-    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
-        read_data=json.dumps(default_conf)
-    ))
+    patched_configuration_load_config_file(mocker, default_conf)
 
     args = [
         '--config', 'config.json',
@@ -292,7 +284,7 @@ def test_setup_configuration_unlimited_stake_amount(mocker, default_conf, caplog
     ]
 
     with pytest.raises(DependencyException, match=r'.*stake amount.*'):
-        setup_configuration(get_args(args))
+        setup_configuration(get_args(args), RunMode.BACKTEST)
 
 
 def test_start(mocker, fee, default_conf, caplog) -> None:
@@ -300,16 +292,15 @@ def test_start(mocker, fee, default_conf, caplog) -> None:
     mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
     patch_exchange(mocker)
     mocker.patch('freqtrade.optimize.backtesting.Backtesting.start', start_mock)
-    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
-        read_data=json.dumps(default_conf)
-    ))
+    patched_configuration_load_config_file(mocker, default_conf)
+
     args = [
         '--config', 'config.json',
         '--strategy', 'DefaultStrategy',
         'backtesting'
     ]
     args = get_args(args)
-    start(args)
+    start_backtesting(args)
     assert log_has(
         'Starting freqtrade in Backtesting mode',
         caplog.record_tuples
@@ -357,7 +348,8 @@ def test_tickerdata_to_dataframe_bt(default_conf, mocker) -> None:
     patch_exchange(mocker)
     timerange = TimeRange(None, 'line', 0, -100)
     tick = history.load_tickerdata_file(None, 'UNITTEST/BTC', '1m', timerange=timerange)
-    tickerlist = {'UNITTEST/BTC': parse_ticker_dataframe(tick, '1m', fill_missing=True)}
+    tickerlist = {'UNITTEST/BTC': parse_ticker_dataframe(tick, '1m', pair="UNITTEST/BTC",
+                                                         fill_missing=True)}
 
     backtesting = Backtesting(default_conf)
     data = backtesting.strategy.tickerdata_to_dataframe(tickerlist)
@@ -474,7 +466,7 @@ def test_backtesting_start(default_conf, mocker, caplog) -> None:
         return Arrow(2017, 11, 14, 21, 17), Arrow(2017, 11, 14, 22, 59)
 
     mocker.patch('freqtrade.data.history.load_data', mocked_load_data)
-    mocker.patch('freqtrade.optimize.get_timeframe', get_timeframe)
+    mocker.patch('freqtrade.data.history.get_timeframe', get_timeframe)
     mocker.patch('freqtrade.exchange.Exchange.refresh_latest_ohlcv', MagicMock())
     patch_exchange(mocker)
     mocker.patch.multiple(
@@ -494,10 +486,9 @@ def test_backtesting_start(default_conf, mocker, caplog) -> None:
     backtesting.start()
     # check the logs, that will contain the backtest result
     exists = [
-        'Using local backtesting data (using whitelist in given config) ...',
         'Using stake_currency: BTC ...',
         'Using stake_amount: 0.001 ...',
-        'Measuring data from 2017-11-14T21:17:00+00:00 '
+        'Backtesting with data from 2017-11-14T21:17:00+00:00 '
         'up to 2017-11-14T22:59:00+00:00 (0 days)..'
     ]
     for line in exists:
@@ -509,7 +500,7 @@ def test_backtesting_start_no_data(default_conf, mocker, caplog) -> None:
         return Arrow(2017, 11, 14, 21, 17), Arrow(2017, 11, 14, 22, 59)
 
     mocker.patch('freqtrade.data.history.load_data', MagicMock(return_value={}))
-    mocker.patch('freqtrade.optimize.get_timeframe', get_timeframe)
+    mocker.patch('freqtrade.data.history.get_timeframe', get_timeframe)
     mocker.patch('freqtrade.exchange.Exchange.refresh_latest_ohlcv', MagicMock())
     patch_exchange(mocker)
     mocker.patch.multiple(
@@ -710,7 +701,7 @@ def test_backtest_multi_pair(default_conf, fee, mocker, tres, pair):
     data = trim_dictlist(data, -500)
 
     # Remove data for one pair from the beginning of the data
-    data[pair] = data[pair][tres:]
+    data[pair] = data[pair][tres:].reset_index()
     # We need to enable sell-signal - otherwise it sells on ROI!!
     default_conf['experimental'] = {"use_sell_signal": True}
     default_conf['ticker_interval'] = '5m'
@@ -833,9 +824,7 @@ def test_backtest_start_live(default_conf, mocker, caplog):
     patch_exchange(mocker, api_mock)
     mocker.patch('freqtrade.optimize.backtesting.Backtesting.backtest', MagicMock())
     mocker.patch('freqtrade.optimize.backtesting.Backtesting._generate_text_table', MagicMock())
-    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
-        read_data=json.dumps(default_conf)
-    ))
+    patched_configuration_load_config_file(mocker, default_conf)
 
     args = [
         '--config', 'config.json',
@@ -849,19 +838,19 @@ def test_backtest_start_live(default_conf, mocker, caplog):
         '--disable-max-market-positions'
     ]
     args = get_args(args)
-    start(args)
+    start_backtesting(args)
     # check the logs, that will contain the backtest result
     exists = [
-        'Parameter -i/--ticker-interval detected ...',
-        'Using ticker_interval: 1m ...',
+        'Parameter -i/--ticker-interval detected ... Using ticker_interval: 1m ...',
         'Parameter -l/--live detected ...',
         'Ignoring max_open_trades (--disable-max-market-positions was used) ...',
         'Parameter --timerange detected: -100 ...',
-        'Using data folder: freqtrade/tests/testdata ...',
+        'Using data directory: freqtrade/tests/testdata ...',
         'Using stake_currency: BTC ...',
         'Using stake_amount: 0.001 ...',
-        'Downloading data for all pairs in whitelist ...',
-        'Measuring data from 2017-11-14T19:31:00+00:00 up to 2017-11-14T22:58:00+00:00 (0 days)..',
+        'Live: Downloading data for all defined pairs ...',
+        'Backtesting with data from 2017-11-14T19:31:00+00:00 '
+        'up to 2017-11-14T22:58:00+00:00 (0 days)..',
         'Parameter --enable-position-stacking detected ...'
     ]
 
@@ -885,9 +874,7 @@ def test_backtest_start_multi_strat(default_conf, mocker, caplog):
     gen_strattable_mock = MagicMock()
     mocker.patch('freqtrade.optimize.backtesting.Backtesting._generate_text_table_strategy',
                  gen_strattable_mock)
-    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
-        read_data=json.dumps(default_conf)
-    ))
+    patched_configuration_load_config_file(mocker, default_conf)
 
     args = [
         '--config', 'config.json',
@@ -903,7 +890,7 @@ def test_backtest_start_multi_strat(default_conf, mocker, caplog):
         'TestStrategy',
     ]
     args = get_args(args)
-    start(args)
+    start_backtesting(args)
     # 2 backtests, 4 tables
     assert backtestmock.call_count == 2
     assert gen_table_mock.call_count == 4
@@ -911,16 +898,16 @@ def test_backtest_start_multi_strat(default_conf, mocker, caplog):
 
     # check the logs, that will contain the backtest result
     exists = [
-        'Parameter -i/--ticker-interval detected ...',
-        'Using ticker_interval: 1m ...',
+        'Parameter -i/--ticker-interval detected ... Using ticker_interval: 1m ...',
         'Parameter -l/--live detected ...',
         'Ignoring max_open_trades (--disable-max-market-positions was used) ...',
         'Parameter --timerange detected: -100 ...',
-        'Using data folder: freqtrade/tests/testdata ...',
+        'Using data directory: freqtrade/tests/testdata ...',
         'Using stake_currency: BTC ...',
         'Using stake_amount: 0.001 ...',
-        'Downloading data for all pairs in whitelist ...',
-        'Measuring data from 2017-11-14T19:31:00+00:00 up to 2017-11-14T22:58:00+00:00 (0 days)..',
+        'Live: Downloading data for all defined pairs ...',
+        'Backtesting with data from 2017-11-14T19:31:00+00:00 '
+        'up to 2017-11-14T22:58:00+00:00 (0 days)..',
         'Parameter --enable-position-stacking detected ...',
         'Running backtesting for Strategy DefaultStrategy',
         'Running backtesting for Strategy TestStrategy',

freqtrade/tests/optimize/test_edge_cli.py

@@ -2,23 +2,17 @@
 # pragma pylint: disable=protected-access, too-many-lines, invalid-name, too-many-arguments
 
 from unittest.mock import MagicMock
-import json
-from typing import List
+
 from freqtrade.edge import PairInfo
-from freqtrade.arguments import Arguments
-from freqtrade.optimize.edge_cli import (EdgeCli, setup_configuration, start)
+from freqtrade.optimize import setup_configuration, start_edge
+from freqtrade.optimize.edge_cli import EdgeCli
 from freqtrade.state import RunMode
-from freqtrade.tests.conftest import log_has, patch_exchange
-
-
-def get_args(args) -> List[str]:
-    return Arguments(args, '').get_parsed_arg()
+from freqtrade.tests.conftest import (get_args, log_has, log_has_re, patch_exchange,
+                                      patched_configuration_load_config_file)
 
 
 def test_setup_configuration_without_arguments(mocker, default_conf, caplog) -> None:
-    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
-        read_data=json.dumps(default_conf)
-    ))
+    patched_configuration_load_config_file(mocker, default_conf)
 
     args = [
         '--config', 'config.json',
@@ -26,8 +20,8 @@ def test_setup_configuration_without_arguments(mocker, default_conf, caplog) ->
         'edge'
     ]
 
-    config = setup_configuration(get_args(args))
-    assert config['runmode'] == RunMode.EDGECLI
+    config = setup_configuration(get_args(args), RunMode.EDGE)
+    assert config['runmode'] == RunMode.EDGE
 
     assert 'max_open_trades' in config
     assert 'stake_currency' in config
@@ -36,11 +30,11 @@ def test_setup_configuration_without_arguments(mocker, default_conf, caplog) ->
     assert 'pair_whitelist' in config['exchange']
     assert 'datadir' in config
     assert log_has(
-        'Using data folder: {} ...'.format(config['datadir']),
+        'Using data directory: {} ...'.format(config['datadir']),
         caplog.record_tuples
     )
     assert 'ticker_interval' in config
-    assert not log_has('Parameter -i/--ticker-interval detected ...', caplog.record_tuples)
+    assert not log_has_re('Parameter -i/--ticker-interval detected .*', caplog.record_tuples)
 
     assert 'refresh_pairs' not in config
     assert not log_has('Parameter -r/--refresh-pairs-cached detected ...', caplog.record_tuples)
@@ -50,10 +44,11 @@ def test_setup_configuration_without_arguments(mocker, default_conf, caplog) ->
 
 
 def test_setup_edge_configuration_with_arguments(mocker, edge_conf, caplog) -> None:
-    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
-        read_data=json.dumps(edge_conf)
-    ))
-    mocker.patch('freqtrade.configuration.Configuration._create_datadir', lambda s, c, x: x)
+    patched_configuration_load_config_file(mocker, edge_conf)
+    mocker.patch(
+        'freqtrade.configuration.configuration.create_datadir',
+        lambda c, x: x
+    )
 
     args = [
         '--config', 'config.json',
@@ -66,24 +61,21 @@ def test_setup_edge_configuration_with_arguments(mocker, edge_conf, caplog) -> N
         '--stoplosses=-0.01,-0.10,-0.001'
     ]
 
-    config = setup_configuration(get_args(args))
+    config = setup_configuration(get_args(args), RunMode.EDGE)
     assert 'max_open_trades' in config
     assert 'stake_currency' in config
     assert 'stake_amount' in config
     assert 'exchange' in config
     assert 'pair_whitelist' in config['exchange']
     assert 'datadir' in config
-    assert config['runmode'] == RunMode.EDGECLI
+    assert config['runmode'] == RunMode.EDGE
     assert log_has(
-        'Using data folder: {} ...'.format(config['datadir']),
+        'Using data directory: {} ...'.format(config['datadir']),
         caplog.record_tuples
     )
     assert 'ticker_interval' in config
-    assert log_has('Parameter -i/--ticker-interval detected ...', caplog.record_tuples)
-    assert log_has(
-        'Using ticker_interval: 1m ...',
-        caplog.record_tuples
-    )
+    assert log_has('Parameter -i/--ticker-interval detected ... Using ticker_interval: 1m ...',
+                   caplog.record_tuples)
 
     assert 'refresh_pairs' in config
     assert log_has('Parameter -r/--refresh-pairs-cached detected ...', caplog.record_tuples)
@@ -99,16 +91,15 @@ def test_start(mocker, fee, edge_conf, caplog) -> None:
     mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
     patch_exchange(mocker)
     mocker.patch('freqtrade.optimize.edge_cli.EdgeCli.start', start_mock)
-    mocker.patch('freqtrade.configuration.open', mocker.mock_open(
-        read_data=json.dumps(edge_conf)
-    ))
+    patched_configuration_load_config_file(mocker, edge_conf)
+
     args = [
         '--config', 'config.json',
         '--strategy', 'DefaultStrategy',
         'edge'
     ]
     args = get_args(args)
-    start(args)
+    start_edge(args)
     assert log_has(
         'Starting freqtrade in Edge mode',
         caplog.record_tuples
@@ -118,8 +109,10 @@ def test_start(mocker, fee, edge_conf, caplog) -> None:
 
 def test_edge_init(mocker, edge_conf) -> None:
     patch_exchange(mocker)
+    edge_conf['stake_amount'] = 20
     edge_cli = EdgeCli(edge_conf)
     assert edge_cli.config == edge_conf
+    assert edge_cli.config['stake_amount'] == 'unlimited'
     assert callable(edge_cli.edge.calculate)
 
 

freqtrade/tests/optimize/test_hyperopt.py

@@ -1,18 +1,27 @@
 # pragma pylint: disable=missing-docstring,W0212,C0103
-from datetime import datetime
 import os
+from datetime import datetime
 from unittest.mock import MagicMock
 
 import pandas as pd
 import pytest
+from arrow import Arrow
+from filelock import Timeout
 
+from freqtrade import DependencyException, OperationalException
 from freqtrade.data.converter import parse_ticker_dataframe
 from freqtrade.data.history import load_tickerdata_file
-from freqtrade.optimize.hyperopt import Hyperopt, start
+from freqtrade.optimize import setup_configuration, start_hyperopt
 from freqtrade.optimize.default_hyperopt import DefaultHyperOpts
-from freqtrade.resolvers import StrategyResolver, HyperOptResolver
-from freqtrade.tests.conftest import log_has, patch_exchange
-from freqtrade.tests.optimize.test_backtesting import get_args
+from freqtrade.optimize.default_hyperopt_loss import DefaultHyperOptLoss
+from freqtrade.optimize.hyperopt import (HYPEROPT_LOCKFILE, TICKERDATA_PICKLE,
+                                         Hyperopt)
+from freqtrade.resolvers.hyperopt_resolver import HyperOptResolver, HyperOptLossResolver
+from freqtrade.state import RunMode
+from freqtrade.strategy.interface import SellType
+from freqtrade.tests.conftest import (get_args, log_has, log_has_re,
+                                      patch_exchange,
+                                      patched_configuration_load_config_file)
 
 
 @pytest.fixture(scope='function')
@@ -21,6 +30,21 @@ def hyperopt(default_conf, mocker):
     return Hyperopt(default_conf)
 
 
+@pytest.fixture(scope='function')
+def hyperopt_results():
+    return pd.DataFrame(
+        {
+            'pair': ['ETH/BTC', 'ETH/BTC', 'ETH/BTC'],
+            'profit_percent': [0.1, 0.2, 0.3],
+            'profit_abs': [0.2, 0.4, 0.5],
+            'trade_duration': [10, 30, 10],
+            'profit': [2, 0, 0],
+            'loss': [0, 0, 1],
+            'sell_reason': [SellType.ROI, SellType.ROI, SellType.STOP_LOSS]
+        }
+    )
+
+
 # Functions for recurrent object patching
 def create_trials(mocker, hyperopt) -> None:
     """
@@ -39,12 +63,112 @@ def create_trials(mocker, hyperopt) -> None:
     return [{'loss': 1, 'result': 'foo', 'params': {}}]
 
 
-def test_hyperoptresolver(mocker, default_conf, caplog) -> None:
+def test_setup_hyperopt_configuration_without_arguments(mocker, default_conf, caplog) -> None:
+    patched_configuration_load_config_file(mocker, default_conf)
 
-    mocker.patch(
-        'freqtrade.configuration.Configuration._load_config_file',
-        lambda *args, **kwargs: default_conf
+    args = [
+        '--config', 'config.json',
+        'hyperopt'
+    ]
+
+    config = setup_configuration(get_args(args), RunMode.HYPEROPT)
+    assert 'max_open_trades' in config
+    assert 'stake_currency' in config
+    assert 'stake_amount' in config
+    assert 'exchange' in config
+    assert 'pair_whitelist' in config['exchange']
+    assert 'datadir' in config
+    assert log_has(
+        'Using data directory: {} ...'.format(config['datadir']),
+        caplog.record_tuples
     )
+    assert 'ticker_interval' in config
+    assert not log_has_re('Parameter -i/--ticker-interval detected .*', caplog.record_tuples)
+
+    assert 'live' not in config
+    assert not log_has('Parameter -l/--live detected ...', caplog.record_tuples)
+
+    assert 'position_stacking' not in config
+    assert not log_has('Parameter --enable-position-stacking detected ...', caplog.record_tuples)
+
+    assert 'refresh_pairs' not in config
+    assert not log_has('Parameter -r/--refresh-pairs-cached detected ...', caplog.record_tuples)
+
+    assert 'timerange' not in config
+    assert 'runmode' in config
+    assert config['runmode'] == RunMode.HYPEROPT
+
+
+def test_setup_hyperopt_configuration_with_arguments(mocker, default_conf, caplog) -> None:
+    patched_configuration_load_config_file(mocker, default_conf)
+    mocker.patch(
+        'freqtrade.configuration.configuration.create_datadir',
+        lambda c, x: x
+    )
+
+    args = [
+        '--config', 'config.json',
+        '--datadir', '/foo/bar',
+        'hyperopt',
+        '--ticker-interval', '1m',
+        '--timerange', ':100',
+        '--refresh-pairs-cached',
+        '--enable-position-stacking',
+        '--disable-max-market-positions',
+        '--epochs', '1000',
+        '--spaces', 'all',
+        '--print-all'
+    ]
+
+    config = setup_configuration(get_args(args), RunMode.HYPEROPT)
+    assert 'max_open_trades' in config
+    assert 'stake_currency' in config
+    assert 'stake_amount' in config
+    assert 'exchange' in config
+    assert 'pair_whitelist' in config['exchange']
+    assert 'datadir' in config
+    assert config['runmode'] == RunMode.HYPEROPT
+
+    assert log_has(
+        'Using data directory: {} ...'.format(config['datadir']),
+        caplog.record_tuples
+    )
+    assert 'ticker_interval' in config
+    assert log_has('Parameter -i/--ticker-interval detected ... Using ticker_interval: 1m ...',
+                   caplog.record_tuples)
+
+    assert 'position_stacking' in config
+    assert log_has('Parameter --enable-position-stacking detected ...', caplog.record_tuples)
+
+    assert 'use_max_market_positions' in config
+    assert log_has('Parameter --disable-max-market-positions detected ...', caplog.record_tuples)
+    assert log_has('max_open_trades set to unlimited ...', caplog.record_tuples)
+
+    assert 'refresh_pairs' in config
+    assert log_has('Parameter -r/--refresh-pairs-cached detected ...', caplog.record_tuples)
+
+    assert 'timerange' in config
+    assert log_has(
+        'Parameter --timerange detected: {} ...'.format(config['timerange']),
+        caplog.record_tuples
+    )
+
+    assert 'epochs' in config
+    assert log_has('Parameter --epochs detected ... Will run Hyperopt with for 1000 epochs ...',
+                   caplog.record_tuples)
+
+    assert 'spaces' in config
+    assert log_has(
+        'Parameter -s/--spaces detected: {}'.format(config['spaces']),
+        caplog.record_tuples
+    )
+    assert 'print_all' in config
+    assert log_has('Parameter --print-all detected ...', caplog.record_tuples)
+
+
+def test_hyperoptresolver(mocker, default_conf, caplog) -> None:
+    patched_configuration_load_config_file(mocker, default_conf)
+
     hyperopts = DefaultHyperOpts
     delattr(hyperopts, 'populate_buy_trend')
     delattr(hyperopts, 'populate_sell_trend')
@@ -59,26 +183,47 @@ def test_hyperoptresolver(mocker, default_conf, caplog) -> None:
                    "Using populate_sell_trend from DefaultStrategy.", caplog.record_tuples)
     assert log_has("Custom Hyperopt does not provide populate_buy_trend. "
                    "Using populate_buy_trend from DefaultStrategy.", caplog.record_tuples)
+    assert hasattr(x, "ticker_interval")
+
+
+def test_hyperoptresolver_wrongname(mocker, default_conf, caplog) -> None:
+    default_conf.update({'hyperopt': "NonExistingHyperoptClass"})
+
+    with pytest.raises(OperationalException, match=r'Impossible to load Hyperopt.*'):
+        HyperOptResolver(default_conf, ).hyperopt
+
+
+def test_hyperoptlossresolver(mocker, default_conf, caplog) -> None:
+
+    hl = DefaultHyperOptLoss
+    mocker.patch(
+        'freqtrade.resolvers.hyperopt_resolver.HyperOptLossResolver._load_hyperoptloss',
+        MagicMock(return_value=hl)
+    )
+    x = HyperOptLossResolver(default_conf, ).hyperoptloss
+    assert hasattr(x, "hyperopt_loss_function")
+
+
+def test_hyperoptlossresolver_wrongname(mocker, default_conf, caplog) -> None:
+    default_conf.update({'hyperopt_loss': "NonExistingLossClass"})
+
+    with pytest.raises(OperationalException, match=r'Impossible to load HyperoptLoss.*'):
+        HyperOptLossResolver(default_conf, ).hyperopt
 
 
 def test_start(mocker, default_conf, caplog) -> None:
     start_mock = MagicMock()
-    mocker.patch(
-        'freqtrade.configuration.Configuration._load_config_file',
-        lambda *args, **kwargs: default_conf
-    )
+    patched_configuration_load_config_file(mocker, default_conf)
     mocker.patch('freqtrade.optimize.hyperopt.Hyperopt.start', start_mock)
     patch_exchange(mocker)
 
     args = [
         '--config', 'config.json',
-        '--strategy', 'DefaultStrategy',
         'hyperopt',
         '--epochs', '5'
     ]
     args = get_args(args)
-    StrategyResolver({'strategy': 'DefaultStrategy'})
-    start(args)
+    start_hyperopt(args)
 
     import pprint
     pprint.pprint(caplog.record_tuples)
@@ -90,12 +235,33 @@ def test_start(mocker, default_conf, caplog) -> None:
     assert start_mock.call_count == 1
 
 
+def test_start_no_data(mocker, default_conf, caplog) -> None:
+    patched_configuration_load_config_file(mocker, default_conf)
+    mocker.patch('freqtrade.optimize.hyperopt.load_data', MagicMock(return_value={}))
+    mocker.patch(
+        'freqtrade.optimize.hyperopt.get_timeframe',
+        MagicMock(return_value=(datetime(2017, 12, 10), datetime(2017, 12, 13)))
+    )
+
+    patch_exchange(mocker)
+
+    args = [
+        '--config', 'config.json',
+        'hyperopt',
+        '--epochs', '5'
+    ]
+    args = get_args(args)
+    start_hyperopt(args)
+
+    import pprint
+    pprint.pprint(caplog.record_tuples)
+
+    assert log_has('No data found. Terminating.', caplog.record_tuples)
+
+
 def test_start_failure(mocker, default_conf, caplog) -> None:
     start_mock = MagicMock()
-    mocker.patch(
-        'freqtrade.configuration.Configuration._load_config_file',
-        lambda *args, **kwargs: default_conf
-    )
+    patched_configuration_load_config_file(mocker, default_conf)
     mocker.patch('freqtrade.optimize.hyperopt.Hyperopt.start', start_mock)
     patch_exchange(mocker)
 
@@ -106,36 +272,99 @@ def test_start_failure(mocker, default_conf, caplog) -> None:
         '--epochs', '5'
     ]
     args = get_args(args)
-    StrategyResolver({'strategy': 'DefaultStrategy'})
-    with pytest.raises(ValueError):
-        start(args)
+    with pytest.raises(DependencyException):
+        start_hyperopt(args)
     assert log_has(
         "Please don't use --strategy for hyperopt.",
         caplog.record_tuples
     )
 
 
-def test_loss_calculation_prefer_correct_trade_count(hyperopt) -> None:
-    StrategyResolver({'strategy': 'DefaultStrategy'})
+def test_start_filelock(mocker, default_conf, caplog) -> None:
+    start_mock = MagicMock(side_effect=Timeout(HYPEROPT_LOCKFILE))
+    patched_configuration_load_config_file(mocker, default_conf)
+    mocker.patch('freqtrade.optimize.hyperopt.Hyperopt.start', start_mock)
+    patch_exchange(mocker)
 
-    correct = hyperopt.calculate_loss(1, hyperopt.target_trades, 20)
-    over = hyperopt.calculate_loss(1, hyperopt.target_trades + 100, 20)
-    under = hyperopt.calculate_loss(1, hyperopt.target_trades - 100, 20)
+    args = [
+        '--config', 'config.json',
+        'hyperopt',
+        '--epochs', '5'
+    ]
+    args = get_args(args)
+    start_hyperopt(args)
+    assert log_has(
+        "Another running instance of freqtrade Hyperopt detected.",
+        caplog.record_tuples
+    )
+
+
+def test_loss_calculation_prefer_correct_trade_count(default_conf, hyperopt_results) -> None:
+    hl = HyperOptLossResolver(default_conf).hyperoptloss
+    correct = hl.hyperopt_loss_function(hyperopt_results, 600)
+    over = hl.hyperopt_loss_function(hyperopt_results, 600 + 100)
+    under = hl.hyperopt_loss_function(hyperopt_results, 600 - 100)
     assert over > correct
     assert under > correct
 
 
-def test_loss_calculation_prefer_shorter_trades(hyperopt) -> None:
-    shorter = hyperopt.calculate_loss(1, 100, 20)
-    longer = hyperopt.calculate_loss(1, 100, 30)
+def test_loss_calculation_prefer_shorter_trades(default_conf, hyperopt_results) -> None:
+    resultsb = hyperopt_results.copy()
+    resultsb.loc[1, 'trade_duration'] = 20
+
+    hl = HyperOptLossResolver(default_conf).hyperoptloss
+    longer = hl.hyperopt_loss_function(hyperopt_results, 100)
+    shorter = hl.hyperopt_loss_function(resultsb, 100)
     assert shorter < longer
 
 
-def test_loss_calculation_has_limited_profit(hyperopt) -> None:
-    correct = hyperopt.calculate_loss(hyperopt.expected_max_profit, hyperopt.target_trades, 20)
-    over = hyperopt.calculate_loss(hyperopt.expected_max_profit * 2, hyperopt.target_trades, 20)
-    under = hyperopt.calculate_loss(hyperopt.expected_max_profit / 2, hyperopt.target_trades, 20)
-    assert over == correct
+def test_loss_calculation_has_limited_profit(default_conf, hyperopt_results) -> None:
+    results_over = hyperopt_results.copy()
+    results_over['profit_percent'] = hyperopt_results['profit_percent'] * 2
+    results_under = hyperopt_results.copy()
+    results_under['profit_percent'] = hyperopt_results['profit_percent'] / 2
+
+    hl = HyperOptLossResolver(default_conf).hyperoptloss
+    correct = hl.hyperopt_loss_function(hyperopt_results, 600)
+    over = hl.hyperopt_loss_function(results_over, 600)
+    under = hl.hyperopt_loss_function(results_under, 600)
+    assert over < correct
+    assert under > correct
+
+
+def test_sharpe_loss_prefers_higher_profits(default_conf, hyperopt_results) -> None:
+    results_over = hyperopt_results.copy()
+    results_over['profit_percent'] = hyperopt_results['profit_percent'] * 2
+    results_under = hyperopt_results.copy()
+    results_under['profit_percent'] = hyperopt_results['profit_percent'] / 2
+
+    default_conf.update({'hyperopt_loss': 'SharpeHyperOptLoss'})
+    hl = HyperOptLossResolver(default_conf).hyperoptloss
+    correct = hl.hyperopt_loss_function(hyperopt_results, len(hyperopt_results),
+                                        datetime(2019, 1, 1), datetime(2019, 5, 1))
+    over = hl.hyperopt_loss_function(results_over, len(hyperopt_results),
+                                     datetime(2019, 1, 1), datetime(2019, 5, 1))
+    under = hl.hyperopt_loss_function(results_under, len(hyperopt_results),
+                                      datetime(2019, 1, 1), datetime(2019, 5, 1))
+    assert over < correct
+    assert under > correct
+
+
+def test_onlyprofit_loss_prefers_higher_profits(default_conf, hyperopt_results) -> None:
+    results_over = hyperopt_results.copy()
+    results_over['profit_percent'] = hyperopt_results['profit_percent'] * 2
+    results_under = hyperopt_results.copy()
+    results_under['profit_percent'] = hyperopt_results['profit_percent'] / 2
+
+    default_conf.update({'hyperopt_loss': 'OnlyProfitHyperOptLoss'})
+    hl = HyperOptLossResolver(default_conf).hyperoptloss
+    correct = hl.hyperopt_loss_function(hyperopt_results, len(hyperopt_results),
+                                        datetime(2019, 1, 1), datetime(2019, 5, 1))
+    over = hl.hyperopt_loss_function(results_over, len(hyperopt_results),
+                                     datetime(2019, 1, 1), datetime(2019, 5, 1))
+    under = hl.hyperopt_loss_function(results_under, len(hyperopt_results),
+                                      datetime(2019, 1, 1), datetime(2019, 5, 1))
+    assert over < correct
     assert under > correct
 
 
@@ -146,11 +375,12 @@ def test_log_results_if_loss_improves(hyperopt, capsys) -> None:
             'loss': 1,
             'current_tries': 1,
             'total_tries': 2,
-            'result': 'foo'
+            'result': 'foo.',
+            'initial_point': False
         }
     )
     out, err = capsys.readouterr()
-    assert '    1/2: foo. Loss 1.00000' in out
+    assert '    2/2: foo. Objective: 1.00000' in out
 
 
 def test_no_log_if_loss_does_not_improve(hyperopt, caplog) -> None:
@@ -206,26 +436,37 @@ def test_roi_table_generation(hyperopt) -> None:
 def test_start_calls_optimizer(mocker, default_conf, caplog) -> None:
     dumper = mocker.patch('freqtrade.optimize.hyperopt.dump', MagicMock())
     mocker.patch('freqtrade.optimize.hyperopt.load_data', MagicMock())
-    mocker.patch('freqtrade.optimize.hyperopt.multiprocessing.cpu_count', MagicMock(return_value=1))
+    mocker.patch(
+        'freqtrade.optimize.hyperopt.get_timeframe',
+        MagicMock(return_value=(datetime(2017, 12, 10), datetime(2017, 12, 13)))
+    )
+
     parallel = mocker.patch(
         'freqtrade.optimize.hyperopt.Hyperopt.run_optimizer_parallel',
         MagicMock(return_value=[{'loss': 1, 'result': 'foo result', 'params': {}}])
     )
     patch_exchange(mocker)
 
-    default_conf.update({'config': 'config.json.example'})
-    default_conf.update({'epochs': 1})
-    default_conf.update({'timerange': None})
-    default_conf.update({'spaces': 'all'})
+    default_conf.update({'config': 'config.json.example',
+                         'epochs': 1,
+                         'timerange': None,
+                         'spaces': 'all',
+                         'hyperopt_jobs': 1, })
 
     hyperopt = Hyperopt(default_conf)
     hyperopt.strategy.tickerdata_to_dataframe = MagicMock()
 
     hyperopt.start()
     parallel.assert_called_once()
-
-    assert 'Best result:\nfoo result\nwith values:\n\n' in caplog.text
+    assert log_has('Best result:\nfoo result\nwith values:\n', caplog.record_tuples)
     assert dumper.called
+    # Should be called twice, once for tickerdata, once to save evaluations
+    assert dumper.call_count == 2
+    assert hasattr(hyperopt, "advise_sell")
+    assert hasattr(hyperopt, "advise_buy")
+    assert hasattr(hyperopt, "max_open_trades")
+    assert hyperopt.max_open_trades == default_conf['max_open_trades']
+    assert hasattr(hyperopt, "position_stacking")
 
 
 def test_format_results(hyperopt):
@@ -266,7 +507,8 @@ def test_has_space(hyperopt):
 
 def test_populate_indicators(hyperopt) -> None:
     tick = load_tickerdata_file(None, 'UNITTEST/BTC', '1m')
-    tickerlist = {'UNITTEST/BTC': parse_ticker_dataframe(tick, '1m', fill_missing=True)}
+    tickerlist = {'UNITTEST/BTC': parse_ticker_dataframe(tick, '1m', pair="UNITTEST/BTC",
+                                                         fill_missing=True)}
     dataframes = hyperopt.strategy.tickerdata_to_dataframe(tickerlist)
     dataframe = hyperopt.custom_hyperopt.populate_indicators(dataframes['UNITTEST/BTC'],
                                                              {'pair': 'UNITTEST/BTC'})
@@ -279,7 +521,8 @@ def test_populate_indicators(hyperopt) -> None:
 
 def test_buy_strategy_generator(hyperopt) -> None:
     tick = load_tickerdata_file(None, 'UNITTEST/BTC', '1m')
-    tickerlist = {'UNITTEST/BTC': parse_ticker_dataframe(tick, '1m', fill_missing=True)}
+    tickerlist = {'UNITTEST/BTC': parse_ticker_dataframe(tick, '1m', pair="UNITTEST/BTC",
+                                                         fill_missing=True)}
     dataframes = hyperopt.strategy.tickerdata_to_dataframe(tickerlist)
     dataframe = hyperopt.custom_hyperopt.populate_indicators(dataframes['UNITTEST/BTC'],
                                                              {'pair': 'UNITTEST/BTC'})
@@ -307,6 +550,7 @@ def test_generate_optimizer(mocker, default_conf) -> None:
     default_conf.update({'config': 'config.json.example'})
     default_conf.update({'timerange': None})
     default_conf.update({'spaces': 'all'})
+    default_conf.update({'hyperopt_min_trades': 1})
 
     trades = [
         ('POWR/BTC', 0.023117, 0.000233, 100)
@@ -320,7 +564,7 @@ def test_generate_optimizer(mocker, default_conf) -> None:
     )
     mocker.patch(
         'freqtrade.optimize.hyperopt.get_timeframe',
-        MagicMock(return_value=(datetime(2017, 12, 10), datetime(2017, 12, 13)))
+        MagicMock(return_value=(Arrow(2017, 12, 10), Arrow(2017, 12, 13)))
     )
     patch_exchange(mocker)
     mocker.patch('freqtrade.optimize.hyperopt.load', MagicMock())
@@ -355,10 +599,43 @@ def test_generate_optimizer(mocker, default_conf) -> None:
     response_expected = {
         'loss': 1.9840569076926293,
         'result': '     1 trades. Avg profit  2.31%. Total profit  0.00023300 BTC '
-                  '(0.0231Σ%). Avg duration 100.0 mins.',
+                  '(   2.31Σ%). Avg duration 100.0 mins.',
         'params': optimizer_param
     }
 
     hyperopt = Hyperopt(default_conf)
     generate_optimizer_value = hyperopt.generate_optimizer(list(optimizer_param.values()))
     assert generate_optimizer_value == response_expected
+
+
+def test_clean_hyperopt(mocker, default_conf, caplog):
+    patch_exchange(mocker)
+    default_conf.update({'config': 'config.json.example',
+                         'epochs': 1,
+                         'timerange': None,
+                         'spaces': 'all',
+                         'hyperopt_jobs': 1,
+                         })
+    mocker.patch("freqtrade.optimize.hyperopt.Path.is_file", MagicMock(return_value=True))
+    unlinkmock = mocker.patch("freqtrade.optimize.hyperopt.Path.unlink", MagicMock())
+    Hyperopt(default_conf)
+
+    assert unlinkmock.call_count == 2
+    assert log_has(f"Removing `{TICKERDATA_PICKLE}`.", caplog.record_tuples)
+
+
+def test_continue_hyperopt(mocker, default_conf, caplog):
+    patch_exchange(mocker)
+    default_conf.update({'config': 'config.json.example',
+                         'epochs': 1,
+                         'timerange': None,
+                         'spaces': 'all',
+                         'hyperopt_jobs': 1,
+                         'hyperopt_continue': True
+                         })
+    mocker.patch("freqtrade.optimize.hyperopt.Path.is_file", MagicMock(return_value=True))
+    unlinkmock = mocker.patch("freqtrade.optimize.hyperopt.Path.unlink", MagicMock())
+    Hyperopt(default_conf)
+
+    assert unlinkmock.call_count == 0
+    assert log_has(f"Continuing on previous hyperopt results.", caplog.record_tuples)

freqtrade/tests/optimize/test_optimize.py

@@ -1,66 +0,0 @@
-# pragma pylint: disable=missing-docstring, protected-access, C0103
-from freqtrade import optimize
-from freqtrade.arguments import TimeRange
-from freqtrade.data import history
-from freqtrade.misc import timeframe_to_minutes
-from freqtrade.strategy.default_strategy import DefaultStrategy
-from freqtrade.tests.conftest import log_has, patch_exchange
-
-
-def test_get_timeframe(default_conf, mocker) -> None:
-    patch_exchange(mocker)
-    strategy = DefaultStrategy(default_conf)
-
-    data = strategy.tickerdata_to_dataframe(
-        history.load_data(
-            datadir=None,
-            ticker_interval='1m',
-            pairs=['UNITTEST/BTC']
-        )
-    )
-    min_date, max_date = optimize.get_timeframe(data)
-    assert min_date.isoformat() == '2017-11-04T23:02:00+00:00'
-    assert max_date.isoformat() == '2017-11-14T22:58:00+00:00'
-
-
-def test_validate_backtest_data_warn(default_conf, mocker, caplog) -> None:
-    patch_exchange(mocker)
-    strategy = DefaultStrategy(default_conf)
-
-    data = strategy.tickerdata_to_dataframe(
-        history.load_data(
-            datadir=None,
-            ticker_interval='1m',
-            pairs=['UNITTEST/BTC'],
-            fill_up_missing=False
-        )
-    )
-    min_date, max_date = optimize.get_timeframe(data)
-    caplog.clear()
-    assert optimize.validate_backtest_data(data, min_date, max_date,
-                                           timeframe_to_minutes('1m'))
-    assert len(caplog.record_tuples) == 1
-    assert log_has(
-        "UNITTEST/BTC has missing frames: expected 14396, got 13680, that's 716 missing values",
-        caplog.record_tuples)
-
-
-def test_validate_backtest_data(default_conf, mocker, caplog) -> None:
-    patch_exchange(mocker)
-    strategy = DefaultStrategy(default_conf)
-
-    timerange = TimeRange('index', 'index', 200, 250)
-    data = strategy.tickerdata_to_dataframe(
-        history.load_data(
-            datadir=None,
-            ticker_interval='5m',
-            pairs=['UNITTEST/BTC'],
-            timerange=timerange
-        )
-    )
-
-    min_date, max_date = optimize.get_timeframe(data)
-    caplog.clear()
-    assert not optimize.validate_backtest_data(data, min_date, max_date,
-                                               timeframe_to_minutes('5m'))
-    assert len(caplog.record_tuples) == 0

freqtrade/tests/pairlist/test_pairlist.py

@@ -34,9 +34,9 @@ def whitelist_conf(default_conf):
 def test_load_pairlist_noexist(mocker, markets, default_conf):
     freqtradebot = get_patched_freqtradebot(mocker, default_conf)
     mocker.patch('freqtrade.exchange.Exchange.markets', PropertyMock(return_value=markets))
-    with pytest.raises(ImportError,
-                       match=r"Impossible to load Pairlist 'NonexistingPairList'."
-                             r" This class does not exist or contains Python code errors"):
+    with pytest.raises(OperationalException,
+                       match=r"Impossible to load Pairlist 'NonexistingPairList'. "
+                             r"This class does not exist or contains Python code errors."):
         PairListResolver('NonexistingPairList', freqtradebot, default_conf).pairlist
 
 

freqtrade/tests/rpc/test_rpc.py

@@ -14,8 +14,7 @@ from freqtrade.persistence import Trade
 from freqtrade.rpc import RPC, RPCException
 from freqtrade.rpc.fiat_convert import CryptoToFiatConverter
 from freqtrade.state import State
-from freqtrade.tests.conftest import patch_exchange
-from freqtrade.tests.test_freqtradebot import patch_get_signal
+from freqtrade.tests.conftest import patch_exchange, patch_get_signal
 
 
 # Functions for recurrent object patching
@@ -47,12 +46,14 @@ def test_rpc_trade_status(default_conf, ticker, fee, markets, mocker) -> None:
 
     freqtradebot.create_trade()
     results = rpc._rpc_trade_status()
-
     assert {
         'trade_id': 1,
         'pair': 'ETH/BTC',
         'base_currency': 'BTC',
-        'date': ANY,
+        'open_date': ANY,
+        'open_date_hum': ANY,
+        'close_date': None,
+        'close_date_hum': None,
         'open_rate': 1.099e-05,
         'close_rate': None,
         'current_rate': 1.098e-05,
@@ -78,7 +79,10 @@ def test_rpc_trade_status(default_conf, ticker, fee, markets, mocker) -> None:
         'trade_id': 1,
         'pair': 'ETH/BTC',
         'base_currency': 'BTC',
-        'date': ANY,
+        'open_date': ANY,
+        'open_date_hum': ANY,
+        'close_date': None,
+        'close_date_hum': None,
         'open_rate': 1.099e-05,
         'close_rate': None,
         'current_rate': ANY,
@@ -114,7 +118,7 @@ def test_rpc_status_table(default_conf, ticker, fee, markets, mocker) -> None:
 
     freqtradebot.create_trade()
     result = rpc._rpc_status_table()
-    assert 'just now' in result['Since'].all()
+    assert 'instantly' in result['Since'].all()
     assert 'ETH/BTC' in result['Pair'].all()
     assert '-0.59%' in result['Profit'].all()
 
@@ -123,7 +127,7 @@ def test_rpc_status_table(default_conf, ticker, fee, markets, mocker) -> None:
     # invalidate ticker cache
     rpc._freqtrade.exchange._cached_ticker = {}
     result = rpc._rpc_status_table()
-    assert 'just now' in result['Since'].all()
+    assert 'instantly' in result['Since'].all()
     assert 'ETH/BTC' in result['Pair'].all()
     assert 'nan%' in result['Profit'].all()
 
@@ -320,7 +324,7 @@ def test_rpc_trade_statistics_closed(mocker, default_conf, ticker, fee, markets,
     assert prec_satoshi(stats['best_rate'], 6.2)
 
 
-def test_rpc_balance_handle(default_conf, mocker):
+def test_rpc_balance_handle_error(default_conf, mocker):
     mock_balance = {
         'BTC': {
             'free': 10.0,
@@ -367,6 +371,72 @@ def test_rpc_balance_handle(default_conf, mocker):
     assert result['total'] == 12.0
 
 
+def test_rpc_balance_handle(default_conf, mocker):
+    mock_balance = {
+        'BTC': {
+            'free': 10.0,
+            'total': 12.0,
+            'used': 2.0,
+        },
+        'ETH': {
+            'free': 1.0,
+            'total': 5.0,
+            'used': 4.0,
+        },
+        'PAX': {
+            'free': 5.0,
+            'total': 10.0,
+            'used': 5.0,
+        }
+    }
+
+    mocker.patch.multiple(
+        'freqtrade.rpc.fiat_convert.Market',
+        ticker=MagicMock(return_value={'price_usd': 15000.0}),
+    )
+    patch_exchange(mocker)
+    mocker.patch('freqtrade.rpc.rpc.CryptoToFiatConverter._find_price', return_value=15000.0)
+    mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        get_balances=MagicMock(return_value=mock_balance),
+        get_ticker=MagicMock(
+            side_effect=lambda p, r: {'bid': 100} if p == "BTC/PAX" else {'bid': 0.01}),
+        get_valid_pair_combination=MagicMock(
+            side_effect=lambda a, b: f"{b}/{a}" if a == "PAX" else f"{a}/{b}")
+    )
+
+    freqtradebot = FreqtradeBot(default_conf)
+    patch_get_signal(freqtradebot, (True, False))
+    rpc = RPC(freqtradebot)
+    rpc._fiat_converter = CryptoToFiatConverter()
+
+    result = rpc._rpc_balance(default_conf['fiat_display_currency'])
+    assert prec_satoshi(result['total'], 12.15)
+    assert prec_satoshi(result['value'], 182250)
+    assert 'USD' == result['symbol']
+    assert result['currencies'] == [
+        {'currency': 'BTC',
+            'available': 10.0,
+            'balance': 12.0,
+            'pending': 2.0,
+            'est_btc': 12.0,
+         },
+        {'available': 1.0,
+         'balance': 5.0,
+         'currency': 'ETH',
+         'est_btc': 0.05,
+         'pending': 4.0
+         },
+        {'available': 5.0,
+         'balance': 10.0,
+         'currency': 'PAX',
+         'est_btc': 0.1,
+         'pending': 5.0}
+    ]
+    assert result['total'] == 12.15
+
+
 def test_rpc_start(mocker, default_conf) -> None:
     patch_exchange(mocker)
     mocker.patch('freqtrade.rpc.telegram.Telegram', MagicMock())
@@ -463,12 +533,15 @@ def test_rpc_forcesell(default_conf, ticker, fee, mocker, markets) -> None:
     with pytest.raises(RPCException, match=r'.*invalid argument*'):
         rpc._rpc_forcesell(None)
 
-    rpc._rpc_forcesell('all')
+    msg = rpc._rpc_forcesell('all')
+    assert msg == {'result': 'Created sell orders for all open trades.'}
 
     freqtradebot.create_trade()
-    rpc._rpc_forcesell('all')
+    msg = rpc._rpc_forcesell('all')
+    assert msg == {'result': 'Created sell orders for all open trades.'}
 
-    rpc._rpc_forcesell('1')
+    msg = rpc._rpc_forcesell('1')
+    assert msg == {'result': 'Created sell order for trade 1.'}
 
     freqtradebot.state = State.STOPPED
     with pytest.raises(RPCException, match=r'.*trader is not running*'):
@@ -511,7 +584,8 @@ def test_rpc_forcesell(default_conf, ticker, fee, mocker, markets) -> None:
         }
     )
     # check that the trade is called, which is done by ensuring exchange.cancel_order is called
-    rpc._rpc_forcesell('2')
+    msg = rpc._rpc_forcesell('2')
+    assert msg == {'result': 'Created sell order for trade 2.'}
     assert cancel_order_mock.call_count == 2
     assert trade.amount == amount
 
@@ -525,7 +599,8 @@ def test_rpc_forcesell(default_conf, ticker, fee, mocker, markets) -> None:
             'side': 'sell'
         }
     )
-    rpc._rpc_forcesell('3')
+    msg = rpc._rpc_forcesell('3')
+    assert msg == {'result': 'Created sell order for trade 3.'}
     # status quo, no exchange calls
     assert cancel_order_mock.call_count == 2
 

freqtrade/tests/rpc/test_rpc_apiserver.py

@@ -0,0 +1,558 @@
+"""
+Unit test file for rpc/api_server.py
+"""
+
+from datetime import datetime
+from unittest.mock import ANY, MagicMock, PropertyMock
+
+import pytest
+from flask import Flask
+from requests.auth import _basic_auth_str
+
+from freqtrade.__init__ import __version__
+from freqtrade.persistence import Trade
+from freqtrade.rpc.api_server import BASE_URI, ApiServer
+from freqtrade.state import State
+from freqtrade.tests.conftest import (get_patched_freqtradebot, log_has,
+                                      patch_get_signal)
+
+
+_TEST_USER = "FreqTrader"
+_TEST_PASS = "SuperSecurePassword1!"
+
+
+@pytest.fixture
+def botclient(default_conf, mocker):
+    default_conf.update({"api_server": {"enabled": True,
+                                        "listen_ip_address": "127.0.0.1",
+                                        "listen_port": "8080",
+                                        "username": _TEST_USER,
+                                        "password": _TEST_PASS,
+                                        }})
+
+    ftbot = get_patched_freqtradebot(mocker, default_conf)
+    mocker.patch('freqtrade.rpc.api_server.ApiServer.run', MagicMock())
+    apiserver = ApiServer(ftbot)
+    yield ftbot, apiserver.app.test_client()
+    # Cleanup ... ?
+
+
+def client_post(client, url, data={}):
+    return client.post(url,
+                       content_type="application/json",
+                       data=data,
+                       headers={'Authorization': _basic_auth_str(_TEST_USER, _TEST_PASS)})
+
+
+def client_get(client, url):
+    return client.get(url, headers={'Authorization': _basic_auth_str(_TEST_USER, _TEST_PASS)})
+
+
+def assert_response(response, expected_code=200):
+    assert response.status_code == expected_code
+    assert response.content_type == "application/json"
+
+
+def test_api_not_found(botclient):
+    ftbot, client = botclient
+
+    rc = client_post(client, f"{BASE_URI}/invalid_url")
+    assert_response(rc, 404)
+    assert rc.json == {"status": "error",
+                       "reason": f"There's no API call for http://localhost{BASE_URI}/invalid_url.",
+                       "code": 404
+                       }
+
+
+def test_api_unauthorized(botclient):
+    ftbot, client = botclient
+    # Don't send user/pass information
+    rc = client.get(f"{BASE_URI}/version")
+    assert_response(rc, 401)
+    assert rc.json == {'error': 'Unauthorized'}
+
+    # Change only username
+    ftbot.config['api_server']['username'] = "Ftrader"
+    rc = client_get(client, f"{BASE_URI}/version")
+    assert_response(rc, 401)
+    assert rc.json == {'error': 'Unauthorized'}
+
+    # Change only password
+    ftbot.config['api_server']['username'] = _TEST_USER
+    ftbot.config['api_server']['password'] = "WrongPassword"
+    rc = client_get(client, f"{BASE_URI}/version")
+    assert_response(rc, 401)
+    assert rc.json == {'error': 'Unauthorized'}
+
+    ftbot.config['api_server']['username'] = "Ftrader"
+    ftbot.config['api_server']['password'] = "WrongPassword"
+
+    rc = client_get(client, f"{BASE_URI}/version")
+    assert_response(rc, 401)
+    assert rc.json == {'error': 'Unauthorized'}
+
+
+def test_api_stop_workflow(botclient):
+    ftbot, client = botclient
+    assert ftbot.state == State.RUNNING
+    rc = client_post(client, f"{BASE_URI}/stop")
+    assert_response(rc)
+    assert rc.json == {'status': 'stopping trader ...'}
+    assert ftbot.state == State.STOPPED
+
+    # Stop bot again
+    rc = client_post(client, f"{BASE_URI}/stop")
+    assert_response(rc)
+    assert rc.json == {'status': 'already stopped'}
+
+    # Start bot
+    rc = client_post(client, f"{BASE_URI}/start")
+    assert_response(rc)
+    assert rc.json == {'status': 'starting trader ...'}
+    assert ftbot.state == State.RUNNING
+
+    # Call start again
+    rc = client_post(client, f"{BASE_URI}/start")
+    assert_response(rc)
+    assert rc.json == {'status': 'already running'}
+
+
+def test_api__init__(default_conf, mocker):
+    """
+    Test __init__() method
+    """
+    mocker.patch('freqtrade.rpc.telegram.Updater', MagicMock())
+    mocker.patch('freqtrade.rpc.api_server.ApiServer.run', MagicMock())
+
+    apiserver = ApiServer(get_patched_freqtradebot(mocker, default_conf))
+    assert apiserver._config == default_conf
+
+
+def test_api_run(default_conf, mocker, caplog):
+    default_conf.update({"api_server": {"enabled": True,
+                                        "listen_ip_address": "127.0.0.1",
+                                        "listen_port": "8080"}})
+    mocker.patch('freqtrade.rpc.telegram.Updater', MagicMock())
+    mocker.patch('freqtrade.rpc.api_server.threading.Thread', MagicMock())
+
+    server_mock = MagicMock()
+    mocker.patch('freqtrade.rpc.api_server.make_server', server_mock)
+
+    apiserver = ApiServer(get_patched_freqtradebot(mocker, default_conf))
+
+    assert apiserver._config == default_conf
+    apiserver.run()
+    assert server_mock.call_count == 1
+    assert server_mock.call_args_list[0][0][0] == "127.0.0.1"
+    assert server_mock.call_args_list[0][0][1] == "8080"
+    assert isinstance(server_mock.call_args_list[0][0][2], Flask)
+    assert hasattr(apiserver, "srv")
+
+    assert log_has("Starting HTTP Server at 127.0.0.1:8080", caplog.record_tuples)
+    assert log_has("Starting Local Rest Server.", caplog.record_tuples)
+
+    # Test binding to public
+    caplog.clear()
+    server_mock.reset_mock()
+    apiserver._config.update({"api_server": {"enabled": True,
+                                             "listen_ip_address": "0.0.0.0",
+                                             "listen_port": "8089",
+                                             "password": "",
+                                             }})
+    apiserver.run()
+
+    assert server_mock.call_count == 1
+    assert server_mock.call_args_list[0][0][0] == "0.0.0.0"
+    assert server_mock.call_args_list[0][0][1] == "8089"
+    assert isinstance(server_mock.call_args_list[0][0][2], Flask)
+    assert log_has("Starting HTTP Server at 0.0.0.0:8089", caplog.record_tuples)
+    assert log_has("Starting Local Rest Server.", caplog.record_tuples)
+    assert log_has("SECURITY WARNING - Local Rest Server listening to external connections",
+                   caplog.record_tuples)
+    assert log_has("SECURITY WARNING - This is insecure please set to your loopback,"
+                   "e.g 127.0.0.1 in config.json",
+                   caplog.record_tuples)
+    assert log_has("SECURITY WARNING - No password for local REST Server defined. "
+                   "Please make sure that this is intentional!",
+                   caplog.record_tuples)
+
+    # Test crashing flask
+    caplog.clear()
+    mocker.patch('freqtrade.rpc.api_server.make_server', MagicMock(side_effect=Exception))
+    apiserver.run()
+    assert log_has("Api server failed to start.", caplog.record_tuples)
+
+
+def test_api_cleanup(default_conf, mocker, caplog):
+    default_conf.update({"api_server": {"enabled": True,
+                                        "listen_ip_address": "127.0.0.1",
+                                        "listen_port": "8080"}})
+    mocker.patch('freqtrade.rpc.telegram.Updater', MagicMock())
+    mocker.patch('freqtrade.rpc.api_server.threading.Thread', MagicMock())
+    mocker.patch('freqtrade.rpc.api_server.make_server', MagicMock())
+
+    apiserver = ApiServer(get_patched_freqtradebot(mocker, default_conf))
+    apiserver.run()
+    stop_mock = MagicMock()
+    stop_mock.shutdown = MagicMock()
+    apiserver.srv = stop_mock
+
+    apiserver.cleanup()
+    assert stop_mock.shutdown.call_count == 1
+    assert log_has("Stopping API Server", caplog.record_tuples)
+
+
+def test_api_reloadconf(botclient):
+    ftbot, client = botclient
+
+    rc = client_post(client, f"{BASE_URI}/reload_conf")
+    assert_response(rc)
+    assert rc.json == {'status': 'reloading config ...'}
+    assert ftbot.state == State.RELOAD_CONF
+
+
+def test_api_stopbuy(botclient):
+    ftbot, client = botclient
+    assert ftbot.config['max_open_trades'] != 0
+
+    rc = client_post(client, f"{BASE_URI}/stopbuy")
+    assert_response(rc)
+    assert rc.json == {'status': 'No more buy will occur from now. Run /reload_conf to reset.'}
+    assert ftbot.config['max_open_trades'] == 0
+
+
+def test_api_balance(botclient, mocker, rpc_balance):
+    ftbot, client = botclient
+
+    def mock_ticker(symbol, refresh):
+        if symbol == 'BTC/USDT':
+            return {
+                'bid': 10000.00,
+                'ask': 10000.00,
+                'last': 10000.00,
+            }
+        elif symbol == 'XRP/BTC':
+            return {
+                'bid': 0.00001,
+                'ask': 0.00001,
+                'last': 0.00001,
+            }
+        return {
+            'bid': 0.1,
+            'ask': 0.1,
+            'last': 0.1,
+        }
+    mocker.patch('freqtrade.exchange.Exchange.get_balances', return_value=rpc_balance)
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker', side_effect=mock_ticker)
+    mocker.patch('freqtrade.exchange.Exchange.get_valid_pair_combination',
+                 side_effect=lambda a, b: f"{a}/{b}")
+
+    rc = client_get(client, f"{BASE_URI}/balance")
+    assert_response(rc)
+    assert "currencies" in rc.json
+    assert len(rc.json["currencies"]) == 5
+    assert rc.json['currencies'][0] == {
+        'currency': 'BTC',
+        'available': 12.0,
+        'balance': 12.0,
+        'pending': 0.0,
+        'est_btc': 12.0,
+    }
+
+
+def test_api_count(botclient, mocker, ticker, fee, markets):
+    ftbot, client = botclient
+    patch_get_signal(ftbot, (True, False))
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        get_balances=MagicMock(return_value=ticker),
+        get_ticker=ticker,
+        get_fee=fee,
+        markets=PropertyMock(return_value=markets)
+    )
+    rc = client_get(client, f"{BASE_URI}/count")
+    assert_response(rc)
+
+    assert rc.json["current"] == 0
+    assert rc.json["max"] == 1.0
+
+    # Create some test data
+    ftbot.create_trade()
+    rc = client_get(client, f"{BASE_URI}/count")
+    assert_response(rc)
+    assert rc.json["current"] == 1.0
+    assert rc.json["max"] == 1.0
+
+
+def test_api_daily(botclient, mocker, ticker, fee, markets):
+    ftbot, client = botclient
+    patch_get_signal(ftbot, (True, False))
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        get_balances=MagicMock(return_value=ticker),
+        get_ticker=ticker,
+        get_fee=fee,
+        markets=PropertyMock(return_value=markets)
+    )
+    rc = client_get(client, f"{BASE_URI}/daily")
+    assert_response(rc)
+    assert len(rc.json) == 7
+    assert rc.json[0][0] == str(datetime.utcnow().date())
+
+
+def test_api_edge_disabled(botclient, mocker, ticker, fee, markets):
+    ftbot, client = botclient
+    patch_get_signal(ftbot, (True, False))
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        get_balances=MagicMock(return_value=ticker),
+        get_ticker=ticker,
+        get_fee=fee,
+        markets=PropertyMock(return_value=markets)
+    )
+    rc = client_get(client, f"{BASE_URI}/edge")
+    assert_response(rc, 502)
+    assert rc.json == {"error": "Error querying _edge: Edge is not enabled."}
+
+
+def test_api_profit(botclient, mocker, ticker, fee, markets, limit_buy_order, limit_sell_order):
+    ftbot, client = botclient
+    patch_get_signal(ftbot, (True, False))
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        get_balances=MagicMock(return_value=ticker),
+        get_ticker=ticker,
+        get_fee=fee,
+        markets=PropertyMock(return_value=markets)
+    )
+
+    rc = client_get(client, f"{BASE_URI}/profit")
+    assert_response(rc, 502)
+    assert len(rc.json) == 1
+    assert rc.json == {"error": "Error querying _profit: no closed trade"}
+
+    ftbot.create_trade()
+    trade = Trade.query.first()
+
+    # Simulate fulfilled LIMIT_BUY order for trade
+    trade.update(limit_buy_order)
+    rc = client_get(client, f"{BASE_URI}/profit")
+    assert_response(rc, 502)
+    assert rc.json == {"error": "Error querying _profit: no closed trade"}
+
+    trade.update(limit_sell_order)
+
+    trade.close_date = datetime.utcnow()
+    trade.is_open = False
+
+    rc = client_get(client, f"{BASE_URI}/profit")
+    assert_response(rc)
+    assert rc.json == {'avg_duration': '0:00:00',
+                       'best_pair': 'ETH/BTC',
+                       'best_rate': 6.2,
+                       'first_trade_date': 'just now',
+                       'latest_trade_date': 'just now',
+                       'profit_all_coin': 6.217e-05,
+                       'profit_all_fiat': 0,
+                       'profit_all_percent': 6.2,
+                       'profit_closed_coin': 6.217e-05,
+                       'profit_closed_fiat': 0,
+                       'profit_closed_percent': 6.2,
+                       'trade_count': 1
+                       }
+
+
+def test_api_performance(botclient, mocker, ticker, fee):
+    ftbot, client = botclient
+    patch_get_signal(ftbot, (True, False))
+
+    trade = Trade(
+        pair='LTC/ETH',
+        amount=1,
+        exchange='binance',
+        stake_amount=1,
+        open_rate=0.245441,
+        open_order_id="123456",
+        is_open=False,
+        fee_close=fee.return_value,
+        fee_open=fee.return_value,
+        close_rate=0.265441,
+
+    )
+    trade.close_profit = trade.calc_profit_percent()
+    Trade.session.add(trade)
+
+    trade = Trade(
+        pair='XRP/ETH',
+        amount=5,
+        stake_amount=1,
+        exchange='binance',
+        open_rate=0.412,
+        open_order_id="123456",
+        is_open=False,
+        fee_close=fee.return_value,
+        fee_open=fee.return_value,
+        close_rate=0.391
+    )
+    trade.close_profit = trade.calc_profit_percent()
+    Trade.session.add(trade)
+    Trade.session.flush()
+
+    rc = client_get(client, f"{BASE_URI}/performance")
+    assert_response(rc)
+    assert len(rc.json) == 2
+    assert rc.json == [{'count': 1, 'pair': 'LTC/ETH', 'profit': 7.61},
+                       {'count': 1, 'pair': 'XRP/ETH', 'profit': -5.57}]
+
+
+def test_api_status(botclient, mocker, ticker, fee, markets):
+    ftbot, client = botclient
+    patch_get_signal(ftbot, (True, False))
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        get_balances=MagicMock(return_value=ticker),
+        get_ticker=ticker,
+        get_fee=fee,
+        markets=PropertyMock(return_value=markets)
+    )
+
+    rc = client_get(client, f"{BASE_URI}/status")
+    assert_response(rc, 502)
+    assert rc.json == {'error': 'Error querying _status: no active trade'}
+
+    ftbot.create_trade()
+    rc = client_get(client, f"{BASE_URI}/status")
+    assert_response(rc)
+    assert len(rc.json) == 1
+    assert rc.json == [{'amount': 90.99181074,
+                        'base_currency': 'BTC',
+                        'close_date': None,
+                        'close_date_hum': None,
+                        'close_profit': None,
+                        'close_rate': None,
+                        'current_profit': -0.59,
+                        'current_rate': 1.098e-05,
+                        'initial_stop_loss': 0.0,
+                        'initial_stop_loss_pct': None,
+                        'open_date': ANY,
+                        'open_date_hum': 'just now',
+                        'open_order': '(limit buy rem=0.00000000)',
+                        'open_rate': 1.099e-05,
+                        'pair': 'ETH/BTC',
+                        'stake_amount': 0.001,
+                        'stop_loss': 0.0,
+                        'stop_loss_pct': None,
+                        'trade_id': 1}]
+
+
+def test_api_version(botclient):
+    ftbot, client = botclient
+
+    rc = client_get(client, f"{BASE_URI}/version")
+    assert_response(rc)
+    assert rc.json == {"version": __version__}
+
+
+def test_api_blacklist(botclient, mocker):
+    ftbot, client = botclient
+
+    rc = client_get(client, f"{BASE_URI}/blacklist")
+    assert_response(rc)
+    assert rc.json == {"blacklist": ["DOGE/BTC", "HOT/BTC"],
+                       "length": 2,
+                       "method": "StaticPairList"}
+
+    # Add ETH/BTC to blacklist
+    rc = client_post(client, f"{BASE_URI}/blacklist",
+                     data='{"blacklist": ["ETH/BTC"]}')
+    assert_response(rc)
+    assert rc.json == {"blacklist": ["DOGE/BTC", "HOT/BTC", "ETH/BTC"],
+                       "length": 3,
+                       "method": "StaticPairList"}
+
+
+def test_api_whitelist(botclient):
+    ftbot, client = botclient
+
+    rc = client_get(client, f"{BASE_URI}/whitelist")
+    assert_response(rc)
+    assert rc.json == {"whitelist": ['ETH/BTC', 'LTC/BTC', 'XRP/BTC', 'NEO/BTC'],
+                       "length": 4,
+                       "method": "StaticPairList"}
+
+
+def test_api_forcebuy(botclient, mocker, fee):
+    ftbot, client = botclient
+
+    rc = client_post(client, f"{BASE_URI}/forcebuy",
+                     data='{"pair": "ETH/BTC"}')
+    assert_response(rc, 502)
+    assert rc.json == {"error": "Error querying _forcebuy: Forcebuy not enabled."}
+
+    # enable forcebuy
+    ftbot.config["forcebuy_enable"] = True
+
+    fbuy_mock = MagicMock(return_value=None)
+    mocker.patch("freqtrade.rpc.RPC._rpc_forcebuy", fbuy_mock)
+    rc = client_post(client, f"{BASE_URI}/forcebuy",
+                     data='{"pair": "ETH/BTC"}')
+    assert_response(rc)
+    assert rc.json == {"status": "Error buying pair ETH/BTC."}
+
+    # Test creating trae
+    fbuy_mock = MagicMock(return_value=Trade(
+        pair='ETH/ETH',
+        amount=1,
+        exchange='bittrex',
+        stake_amount=1,
+        open_rate=0.245441,
+        open_order_id="123456",
+        open_date=datetime.utcnow(),
+        is_open=False,
+        fee_close=fee.return_value,
+        fee_open=fee.return_value,
+        close_rate=0.265441,
+    ))
+    mocker.patch("freqtrade.rpc.RPC._rpc_forcebuy", fbuy_mock)
+
+    rc = client_post(client, f"{BASE_URI}/forcebuy",
+                     data='{"pair": "ETH/BTC"}')
+    assert_response(rc)
+    assert rc.json == {'amount': 1,
+                       'close_date': None,
+                       'close_date_hum': None,
+                       'close_rate': 0.265441,
+                       'initial_stop_loss': None,
+                       'initial_stop_loss_pct': None,
+                       'open_date': ANY,
+                       'open_date_hum': 'just now',
+                       'open_rate': 0.245441,
+                       'pair': 'ETH/ETH',
+                       'stake_amount': 1,
+                       'stop_loss': None,
+                       'stop_loss_pct': None,
+                       'trade_id': None}
+
+
+def test_api_forcesell(botclient, mocker, ticker, fee, markets):
+    ftbot, client = botclient
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        get_balances=MagicMock(return_value=ticker),
+        get_ticker=ticker,
+        get_fee=fee,
+        markets=PropertyMock(return_value=markets)
+    )
+    patch_get_signal(ftbot, (True, False))
+
+    rc = client_post(client, f"{BASE_URI}/forcesell",
+                     data='{"tradeid": "1"}')
+    assert_response(rc, 502)
+    assert rc.json == {"error": "Error querying _forcesell: invalid argument"}
+
+    ftbot.create_trade()
+
+    rc = client_post(client, f"{BASE_URI}/forcesell",
+                     data='{"tradeid": "1"}')
+    assert_response(rc)
+    assert rc.json == {'result': 'Created sell order for trade 1.'}

freqtrade/tests/rpc/test_rpc_manager.py

@@ -135,3 +135,32 @@ def test_startupmessages_telegram_enabled(mocker, default_conf, caplog) -> None:
     rpc_manager.startup_messages(default_conf,  freqtradebot.pairlists)
     assert telegram_mock.call_count == 3
     assert "Dry run is enabled." in telegram_mock.call_args_list[0][0][0]['status']
+
+
+def test_init_apiserver_disabled(mocker, default_conf, caplog) -> None:
+    caplog.set_level(logging.DEBUG)
+    run_mock = MagicMock()
+    mocker.patch('freqtrade.rpc.api_server.ApiServer.run', run_mock)
+    default_conf['telegram']['enabled'] = False
+    rpc_manager = RPCManager(get_patched_freqtradebot(mocker, default_conf))
+
+    assert not log_has('Enabling rpc.api_server', caplog.record_tuples)
+    assert rpc_manager.registered_modules == []
+    assert run_mock.call_count == 0
+
+
+def test_init_apiserver_enabled(mocker, default_conf, caplog) -> None:
+    caplog.set_level(logging.DEBUG)
+    run_mock = MagicMock()
+    mocker.patch('freqtrade.rpc.api_server.ApiServer.run', run_mock)
+
+    default_conf["telegram"]["enabled"] = False
+    default_conf["api_server"] = {"enabled": True,
+                                  "listen_ip_address": "127.0.0.1",
+                                  "listen_port": "8080"}
+    rpc_manager = RPCManager(get_patched_freqtradebot(mocker, default_conf))
+
+    assert log_has('Enabling rpc.api_server', caplog.record_tuples)
+    assert len(rpc_manager.registered_modules) == 1
+    assert 'apiserver' in [mod.name for mod in rpc_manager.registered_modules]
+    assert run_mock.call_count == 1

freqtrade/tests/rpc/test_rpc_telegram.py

@@ -22,8 +22,7 @@ from freqtrade.rpc.telegram import Telegram, authorized_only
 from freqtrade.state import State
 from freqtrade.strategy.interface import SellType
 from freqtrade.tests.conftest import (get_patched_freqtradebot, log_has,
-                                      patch_exchange)
-from freqtrade.tests.test_freqtradebot import patch_get_signal
+                                      patch_exchange, patch_get_signal)
 
 
 class DummyCls(Telegram):
@@ -192,7 +191,10 @@ def test_status(default_conf, update, mocker, fee, ticker, markets) -> None:
             'trade_id': 1,
             'pair': 'ETH/BTC',
             'base_currency': 'BTC',
-            'date': arrow.utcnow(),
+            'open_date': arrow.utcnow(),
+            'open_date_hum': arrow.utcnow().humanize,
+            'close_date': None,
+            'close_date_hum': None,
             'open_rate': 1.099e-05,
             'close_rate': None,
             'current_rate': 1.098e-05,
@@ -493,34 +495,7 @@ def test_profit_handle(default_conf, update, ticker, ticker_sell_up, fee,
     assert '*Best Performing:* `ETH/BTC: 6.20%`' in msg_mock.call_args_list[-1][0][0]
 
 
-def test_telegram_balance_handle(default_conf, update, mocker) -> None:
-    mock_balance = {
-        'BTC': {
-            'total': 12.0,
-            'free': 12.0,
-            'used': 0.0
-        },
-        'ETH': {
-            'total': 0.0,
-            'free': 0.0,
-            'used': 0.0
-        },
-        'USDT': {
-            'total': 10000.0,
-            'free': 10000.0,
-            'used': 0.0
-        },
-        'LTC': {
-            'total': 10.0,
-            'free': 10.0,
-            'used': 0.0
-        },
-        'XRP': {
-            'total': 1.0,
-            'free': 1.0,
-            'used': 0.0
-            }
-    }
+def test_telegram_balance_handle(default_conf, update, mocker, rpc_balance) -> None:
 
     def mock_ticker(symbol, refresh):
         if symbol == 'BTC/USDT':
@@ -541,8 +516,10 @@ def test_telegram_balance_handle(default_conf, update, mocker) -> None:
             'last': 0.1,
         }
 
-    mocker.patch('freqtrade.exchange.Exchange.get_balances', return_value=mock_balance)
+    mocker.patch('freqtrade.exchange.Exchange.get_balances', return_value=rpc_balance)
     mocker.patch('freqtrade.exchange.Exchange.get_ticker', side_effect=mock_ticker)
+    mocker.patch('freqtrade.exchange.Exchange.get_valid_pair_combination',
+                 side_effect=lambda a, b: f"{a}/{b}")
 
     msg_mock = MagicMock()
     mocker.patch.multiple(
@@ -562,6 +539,7 @@ def test_telegram_balance_handle(default_conf, update, mocker) -> None:
     assert '*BTC:*' in result
     assert '*ETH:*' not in result
     assert '*USDT:*' in result
+    assert '*EUR:*' in result
     assert 'Balance:' in result
     assert 'Est. BTC:' in result
     assert 'BTC:  12.00000000' in result
@@ -583,10 +561,32 @@ def test_balance_handle_empty_response(default_conf, update, mocker) -> None:
 
     telegram = Telegram(freqtradebot)
 
+    freqtradebot.config['dry_run'] = False
     telegram._balance(bot=MagicMock(), update=update)
     result = msg_mock.call_args_list[0][0][0]
     assert msg_mock.call_count == 1
-    assert 'all balances are zero' in result
+    assert 'All balances are zero.' in result
+
+
+def test_balance_handle_empty_response_dry(default_conf, update, mocker) -> None:
+    mocker.patch('freqtrade.exchange.Exchange.get_balances', return_value={})
+
+    msg_mock = MagicMock()
+    mocker.patch.multiple(
+        'freqtrade.rpc.telegram.Telegram',
+        _init=MagicMock(),
+        _send_msg=msg_mock
+    )
+
+    freqtradebot = get_patched_freqtradebot(mocker, default_conf)
+    patch_get_signal(freqtradebot, (True, False))
+
+    telegram = Telegram(freqtradebot)
+
+    telegram._balance(bot=MagicMock(), update=update)
+    result = msg_mock.call_args_list[0][0][0]
+    assert msg_mock.call_count == 1
+    assert "Running in Dry Run, balances are not available." in result
 
 
 def test_balance_handle_too_large_response(default_conf, update, mocker) -> None:
@@ -780,6 +780,7 @@ def test_forcesell_handle(default_conf, update, ticker, fee,
         'gain': 'profit',
         'limit': 1.172e-05,
         'amount': 90.99181073703367,
+        'order_type': 'limit',
         'open_rate': 1.099e-05,
         'current_rate': 1.172e-05,
         'profit_amount': 6.126e-05,
@@ -834,6 +835,7 @@ def test_forcesell_down_handle(default_conf, update, ticker, fee,
         'gain': 'loss',
         'limit': 1.044e-05,
         'amount': 90.99181073703367,
+        'order_type': 'limit',
         'open_rate': 1.099e-05,
         'current_rate': 1.044e-05,
         'profit_amount': -5.492e-05,
@@ -879,6 +881,7 @@ def test_forcesell_all_handle(default_conf, update, ticker, fee, markets, mocker
         'gain': 'loss',
         'limit': 1.098e-05,
         'amount': 90.99181073703367,
+        'order_type': 'limit',
         'open_rate': 1.099e-05,
         'current_rate': 1.098e-05,
         'profit_amount': -5.91e-06,
@@ -1212,6 +1215,7 @@ def test_send_msg_buy_notification(default_conf, mocker) -> None:
         'exchange': 'Bittrex',
         'pair': 'ETH/BTC',
         'limit': 1.099e-05,
+        'order_type': 'limit',
         'stake_amount': 0.001,
         'stake_amount_fiat': 0.0,
         'stake_currency': 'BTC',
@@ -1219,7 +1223,7 @@ def test_send_msg_buy_notification(default_conf, mocker) -> None:
     })
     assert msg_mock.call_args[0][0] \
         == '*Bittrex:* Buying ETH/BTC\n' \
-           'with limit `0.00001099\n' \
+           'at rate `0.00001099\n' \
            '(0.001000 BTC,0.000 USD)`'
 
 
@@ -1241,6 +1245,7 @@ def test_send_msg_sell_notification(default_conf, mocker) -> None:
         'gain': 'loss',
         'limit': 3.201e-05,
         'amount': 1333.3333333333335,
+        'order_type': 'market',
         'open_rate': 7.5e-05,
         'current_rate': 3.201e-05,
         'profit_amount': -0.05746268,
@@ -1251,7 +1256,7 @@ def test_send_msg_sell_notification(default_conf, mocker) -> None:
     })
     assert msg_mock.call_args[0][0] \
         == ('*Binance:* Selling KEY/ETH\n'
-            '*Limit:* `0.00003201`\n'
+            '*Rate:* `0.00003201`\n'
             '*Amount:* `1333.33333333`\n'
             '*Open Rate:* `0.00007500`\n'
             '*Current Rate:* `0.00003201`\n'
@@ -1266,6 +1271,7 @@ def test_send_msg_sell_notification(default_conf, mocker) -> None:
         'gain': 'loss',
         'limit': 3.201e-05,
         'amount': 1333.3333333333335,
+        'order_type': 'market',
         'open_rate': 7.5e-05,
         'current_rate': 3.201e-05,
         'profit_amount': -0.05746268,
@@ -1275,7 +1281,7 @@ def test_send_msg_sell_notification(default_conf, mocker) -> None:
     })
     assert msg_mock.call_args[0][0] \
         == ('*Binance:* Selling KEY/ETH\n'
-            '*Limit:* `0.00003201`\n'
+            '*Rate:* `0.00003201`\n'
             '*Amount:* `1333.33333333`\n'
             '*Open Rate:* `0.00007500`\n'
             '*Current Rate:* `0.00003201`\n'
@@ -1363,6 +1369,7 @@ def test_send_msg_buy_notification_no_fiat(default_conf, mocker) -> None:
         'exchange': 'Bittrex',
         'pair': 'ETH/BTC',
         'limit': 1.099e-05,
+        'order_type': 'limit',
         'stake_amount': 0.001,
         'stake_amount_fiat': 0.0,
         'stake_currency': 'BTC',
@@ -1370,7 +1377,7 @@ def test_send_msg_buy_notification_no_fiat(default_conf, mocker) -> None:
     })
     assert msg_mock.call_args[0][0] \
         == '*Bittrex:* Buying ETH/BTC\n' \
-           'with limit `0.00001099\n' \
+           'at rate `0.00001099\n' \
            '(0.001000 BTC)`'
 
 
@@ -1391,6 +1398,7 @@ def test_send_msg_sell_notification_no_fiat(default_conf, mocker) -> None:
         'gain': 'loss',
         'limit': 3.201e-05,
         'amount': 1333.3333333333335,
+        'order_type': 'limit',
         'open_rate': 7.5e-05,
         'current_rate': 3.201e-05,
         'profit_amount': -0.05746268,
@@ -1401,7 +1409,7 @@ def test_send_msg_sell_notification_no_fiat(default_conf, mocker) -> None:
     })
     assert msg_mock.call_args[0][0] \
         == '*Binance:* Selling KEY/ETH\n' \
-           '*Limit:* `0.00003201`\n' \
+           '*Rate:* `0.00003201`\n' \
            '*Amount:* `1333.33333333`\n' \
            '*Open Rate:* `0.00007500`\n' \
            '*Current Rate:* `0.00003201`\n' \

freqtrade/tests/rpc/test_rpc_webhook.py

@@ -74,6 +74,7 @@ def test_send_msg(default_conf, mocker):
         'gain': "profit",
         'limit': 0.005,
         'amount': 0.8,
+        'order_type': 'limit',
         'open_rate': 0.004,
         'current_rate': 0.005,
         'profit_amount': 0.001,
@@ -126,6 +127,7 @@ def test_exception_send_msg(default_conf, mocker, caplog):
         'exchange': 'Bittrex',
         'pair': 'ETH/BTC',
         'limit': 0.005,
+        'order_type': 'limit',
         'stake_amount': 0.8,
         'stake_amount_fiat': 500,
         'stake_currency': 'BTC',

freqtrade/tests/strategy/test_default_strategy.py

@@ -10,7 +10,8 @@ from freqtrade.strategy.default_strategy import DefaultStrategy
 @pytest.fixture
 def result():
     with open('freqtrade/tests/testdata/ETH_BTC-1m.json') as data_file:
-        return parse_ticker_dataframe(json.load(data_file), '1m', fill_missing=True)
+        return parse_ticker_dataframe(json.load(data_file), '1m', pair="UNITTEST/BTC",
+                                      fill_missing=True)
 
 
 def test_default_strategy_structure():

freqtrade/tests/strategy/test_interface.py

@@ -6,7 +6,7 @@ from unittest.mock import MagicMock
 import arrow
 from pandas import DataFrame
 
-from freqtrade.arguments import TimeRange
+from freqtrade.configuration import TimeRange
 from freqtrade.data.converter import parse_ticker_dataframe
 from freqtrade.data.history import load_tickerdata_file
 from freqtrade.persistence import Trade
@@ -111,7 +111,8 @@ def test_tickerdata_to_dataframe(default_conf) -> None:
 
     timerange = TimeRange(None, 'line', 0, -100)
     tick = load_tickerdata_file(None, 'UNITTEST/BTC', '1m', timerange=timerange)
-    tickerlist = {'UNITTEST/BTC': parse_ticker_dataframe(tick, '1m', True)}
+    tickerlist = {'UNITTEST/BTC': parse_ticker_dataframe(tick, '1m', pair="UNITTEST/BTC",
+                                                         fill_missing=True)}
     data = strategy.tickerdata_to_dataframe(tickerlist)
     assert len(data['UNITTEST/BTC']) == 102       # partial candle was removed
 
@@ -185,6 +186,39 @@ def test_min_roi_reached2(default_conf, fee) -> None:
         assert strategy.min_roi_reached(trade, 0.31, arrow.utcnow().shift(minutes=-2).datetime)
 
 
+def test_min_roi_reached3(default_conf, fee) -> None:
+
+    # test for issue #1948
+    min_roi = {20: 0.07,
+               30: 0.05,
+               55: 0.30,
+               }
+    strategy = DefaultStrategy(default_conf)
+    strategy.minimal_roi = min_roi
+    trade = Trade(
+            pair='ETH/BTC',
+            stake_amount=0.001,
+            open_date=arrow.utcnow().shift(hours=-1).datetime,
+            fee_open=fee.return_value,
+            fee_close=fee.return_value,
+            exchange='bittrex',
+            open_rate=1,
+    )
+
+    assert not strategy.min_roi_reached(trade, 0.02, arrow.utcnow().shift(minutes=-56).datetime)
+    assert not strategy.min_roi_reached(trade, 0.12, arrow.utcnow().shift(minutes=-56).datetime)
+
+    assert not strategy.min_roi_reached(trade, 0.04, arrow.utcnow().shift(minutes=-39).datetime)
+    assert strategy.min_roi_reached(trade, 0.071, arrow.utcnow().shift(minutes=-39).datetime)
+
+    assert not strategy.min_roi_reached(trade, 0.04, arrow.utcnow().shift(minutes=-26).datetime)
+    assert strategy.min_roi_reached(trade, 0.06, arrow.utcnow().shift(minutes=-26).datetime)
+
+    # Should not trigger with 20% profit since after 55 minutes only 30% is active.
+    assert not strategy.min_roi_reached(trade, 0.20, arrow.utcnow().shift(minutes=-2).datetime)
+    assert strategy.min_roi_reached(trade, 0.31, arrow.utcnow().shift(minutes=-2).datetime)
+
+
 def test_analyze_ticker_default(ticker_history, mocker, caplog) -> None:
     caplog.set_level(logging.DEBUG)
     ind_mock = MagicMock(side_effect=lambda x, meta: x)

freqtrade/tests/strategy/test_strategy.py

@@ -1,5 +1,6 @@
 # pragma pylint: disable=missing-docstring, protected-access, C0103
 import logging
+import tempfile
 import warnings
 from base64 import urlsafe_b64encode
 from os import path
@@ -9,6 +10,7 @@ from unittest.mock import Mock
 import pytest
 from pandas import DataFrame
 
+from freqtrade import OperationalException
 from freqtrade.resolvers import StrategyResolver
 from freqtrade.strategy import import_strategy
 from freqtrade.strategy.default_strategy import DefaultStrategy
@@ -43,65 +45,65 @@ def test_import_strategy(caplog):
 
 def test_search_strategy():
     default_config = {}
-    default_location = Path(__file__).parent.parent.joinpath('strategy').resolve()
-    assert isinstance(
-        StrategyResolver._search_object(
-            directory=default_location,
-            object_type=IStrategy,
-            kwargs={'config': default_config},
-            object_name='DefaultStrategy'
-        ),
-        IStrategy
+    default_location = Path(__file__).parent.parent.parent.joinpath('strategy').resolve()
+
+    s, _ = StrategyResolver._search_object(
+        directory=default_location,
+        object_type=IStrategy,
+        kwargs={'config': default_config},
+        object_name='DefaultStrategy'
     )
-    assert StrategyResolver._search_object(
+    assert isinstance(s, IStrategy)
+
+    s, _ = StrategyResolver._search_object(
         directory=default_location,
         object_type=IStrategy,
         kwargs={'config': default_config},
         object_name='NotFoundStrategy'
-    ) is None
+    )
+    assert s is None
 
 
 def test_load_strategy(result):
     resolver = StrategyResolver({'strategy': 'TestStrategy'})
-    metadata = {'pair': 'ETH/BTC'}
-    assert 'adx' in resolver.strategy.advise_indicators(result, metadata=metadata)
+    assert 'adx' in resolver.strategy.advise_indicators(result, {'pair': 'ETH/BTC'})
 
 
-def test_load_strategy_byte64(result):
-    with open("freqtrade/tests/strategy/test_strategy.py", "r") as file:
-        encoded_string = urlsafe_b64encode(file.read().encode("utf-8")).decode("utf-8")
+def test_load_strategy_base64(result, caplog):
+    with open("user_data/strategies/test_strategy.py", "rb") as file:
+        encoded_string = urlsafe_b64encode(file.read()).decode("utf-8")
     resolver = StrategyResolver({'strategy': 'TestStrategy:{}'.format(encoded_string)})
-    assert 'adx' in resolver.strategy.advise_indicators(result, 'ETH/BTC')
+    assert 'adx' in resolver.strategy.advise_indicators(result, {'pair': 'ETH/BTC'})
+    # Make sure strategy was loaded from base64 (using temp directory)!!
+    assert log_has_re(r"Using resolved strategy TestStrategy from '"
+                      + tempfile.gettempdir() + r"/.*/TestStrategy\.py'\.\.\.",
+                      caplog.record_tuples)
 
 
 def test_load_strategy_invalid_directory(result, caplog):
     resolver = StrategyResolver()
-    extra_dir = path.join('some', 'path')
+    extra_dir = Path.cwd() / 'some/path'
     resolver._load_strategy('TestStrategy', config={}, extra_dir=extra_dir)
 
-    assert (
-        'freqtrade.resolvers.strategy_resolver',
-        logging.WARNING,
-        'Path "{}" does not exist'.format(extra_dir),
-    ) in caplog.record_tuples
+    assert log_has_re(r'Path .*' + r'some.*path.*' + r'.* does not exist', caplog.record_tuples)
 
     assert 'adx' in resolver.strategy.advise_indicators(result, {'pair': 'ETH/BTC'})
 
 
 def test_load_not_found_strategy():
     strategy = StrategyResolver()
-    with pytest.raises(ImportError,
-                       match=r"Impossible to load Strategy 'NotFoundStrategy'."
-                             r" This class does not exist or contains Python code errors"):
+    with pytest.raises(OperationalException,
+                       match=r"Impossible to load Strategy 'NotFoundStrategy'. "
+                             r"This class does not exist or contains Python code errors."):
         strategy._load_strategy(strategy_name='NotFoundStrategy', config={})
 
 
 def test_load_staticmethod_importerror(mocker, caplog):
     mocker.patch("freqtrade.resolvers.strategy_resolver.import_strategy", Mock(
         side_effect=TypeError("can't pickle staticmethod objects")))
-    with pytest.raises(ImportError,
-                       match=r"Impossible to load Strategy 'DefaultStrategy'."
-                             r" This class does not exist or contains Python code errors"):
+    with pytest.raises(OperationalException,
+                       match=r"Impossible to load Strategy 'DefaultStrategy'. "
+                             r"This class does not exist or contains Python code errors."):
         StrategyResolver()
     assert log_has_re(r".*Error: can't pickle staticmethod objects", caplog.record_tuples)
 
@@ -364,6 +366,7 @@ def test_strategy_override_use_sell_profit_only(caplog):
             ) in caplog.record_tuples
 
 
+@pytest.mark.filterwarnings("ignore:deprecated")
 def test_deprecate_populate_indicators(result):
     default_location = path.join(path.dirname(path.realpath(__file__)))
     resolver = StrategyResolver({'strategy': 'TestStrategyLegacy',
@@ -371,7 +374,7 @@ def test_deprecate_populate_indicators(result):
     with warnings.catch_warnings(record=True) as w:
         # Cause all warnings to always be triggered.
         warnings.simplefilter("always")
-        indicators = resolver.strategy.advise_indicators(result, 'ETH/BTC')
+        indicators = resolver.strategy.advise_indicators(result, {'pair': 'ETH/BTC'})
         assert len(w) == 1
         assert issubclass(w[-1].category, DeprecationWarning)
         assert "deprecated - check out the Sample strategy to see the current function headers!" \
@@ -380,7 +383,7 @@ def test_deprecate_populate_indicators(result):
     with warnings.catch_warnings(record=True) as w:
         # Cause all warnings to always be triggered.
         warnings.simplefilter("always")
-        resolver.strategy.advise_buy(indicators, 'ETH/BTC')
+        resolver.strategy.advise_buy(indicators, {'pair': 'ETH/BTC'})
         assert len(w) == 1
         assert issubclass(w[-1].category, DeprecationWarning)
         assert "deprecated - check out the Sample strategy to see the current function headers!" \
@@ -389,13 +392,14 @@ def test_deprecate_populate_indicators(result):
     with warnings.catch_warnings(record=True) as w:
         # Cause all warnings to always be triggered.
         warnings.simplefilter("always")
-        resolver.strategy.advise_sell(indicators, 'ETH_BTC')
+        resolver.strategy.advise_sell(indicators, {'pair': 'ETH_BTC'})
         assert len(w) == 1
         assert issubclass(w[-1].category, DeprecationWarning)
         assert "deprecated - check out the Sample strategy to see the current function headers!" \
             in str(w[-1].message)
 
 
+@pytest.mark.filterwarnings("ignore:deprecated")
 def test_call_deprecated_function(result, monkeypatch):
     default_location = path.join(path.dirname(path.realpath(__file__)))
     resolver = StrategyResolver({'strategy': 'TestStrategyLegacy',