diff --git a/config.json.example b/config.json.example
index e5bdc95b1..e8473e919 100644
--- a/config.json.example
+++ b/config.json.example
@@ -5,7 +5,11 @@
"fiat_display_currency": "USD",
"ticker_interval" : "5m",
"dry_run": false,
- "unfilledtimeout": 600,
+ "trailing_stop": false,
+ "unfilledtimeout": {
+ "buy": 10,
+ "sell": 30
+ },
"bid_strategy": {
"ask_last_balance": 0.0
},
diff --git a/config_full.json.example b/config_full.json.example
index 231384acc..4003b1c5c 100644
--- a/config_full.json.example
+++ b/config_full.json.example
@@ -5,6 +5,8 @@
"fiat_display_currency": "USD",
"dry_run": false,
"ticker_interval": "5m",
+ "trailing_stop": false,
+ "trailing_stop_positive": 0.005,
"minimal_roi": {
"40": 0.0,
"30": 0.01,
@@ -12,7 +14,10 @@
"0": 0.04
},
"stoploss": -0.10,
- "unfilledtimeout": 600,
+ "unfilledtimeout": {
+ "buy": 10,
+ "sell": 30
+ },
"bid_strategy": {
"ask_last_balance": 0.0
},
diff --git a/docs/backtesting.md b/docs/backtesting.md
index 1efb46b43..172969ae2 100644
--- a/docs/backtesting.md
+++ b/docs/backtesting.md
@@ -70,6 +70,34 @@ Where `-s TestStrategy` refers to the class name within the strategy file `test_
python3 ./freqtrade/main.py backtesting --export trades
```
+The exported trades can be read using the following code for manual analysis, or can be used by the plotting script `plot_dataframe.py` in the scripts folder.
+
+``` python
+import json
+from pathlib import Path
+import pandas as pd
+
+filename=Path('user_data/backtest_data/backtest-result.json')
+
+with filename.open() as file:
+ data = json.load(file)
+
+columns = ["pair", "profit", "opents", "closets", "index", "duration",
+ "open_rate", "close_rate", "open_at_end"]
+df = pd.DataFrame(data, columns=columns)
+
+df['opents'] = pd.to_datetime(df['opents'],
+ unit='s',
+ utc=True,
+ infer_datetime_format=True
+ )
+df['closets'] = pd.to_datetime(df['closets'],
+ unit='s',
+ utc=True,
+ infer_datetime_format=True
+ )
+```
+
#### Exporting trades to file specifying a custom filename
```bash
diff --git a/docs/configuration.md b/docs/configuration.md
index 5279ed06e..dd16ef6b5 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -1,12 +1,15 @@
# Configure the bot
+
This page explains how to configure your `config.json` file.
## Table of Contents
+
- [Bot commands](#bot-commands)
- [Backtesting commands](#backtesting-commands)
- [Hyperopt commands](#hyperopt-commands)
## Setup config.json
+
We recommend to copy and use the `config.json.example` as a template
for your bot configuration.
@@ -22,7 +25,10 @@ The table below will list all configuration parameters.
| `dry_run` | true | Yes | Define if the bot must be in Dry-run or production mode.
| `minimal_roi` | See below | No | Set the threshold in percent the bot will use to sell a trade. More information below. If set, this parameter will override `minimal_roi` from your strategy file.
| `stoploss` | -0.10 | No | Value of the stoploss in percent used by the bot. More information below. If set, this parameter will override `stoploss` from your strategy file.
-| `unfilledtimeout` | 0 | No | How long (in minutes) the bot will wait for an unfilled order to complete, after which the order will be cancelled.
+| `trailing_stoploss` | false | No | Enables trailing stop-loss (based on `stoploss` in either configuration or strategy file).
+| `trailing_stoploss_positve` | 0 | No | Changes stop-loss once profit has been reached.
+| `unfilledtimeout.buy` | 10 | Yes | How long (in minutes) the bot will wait for an unfilled buy order to complete, after which the order will be cancelled.
+| `unfilledtimeout.sell` | 10 | Yes | How long (in minutes) the bot will wait for an unfilled sell order to complete, after which the order will be cancelled.
| `bid_strategy.ask_last_balance` | 0.0 | Yes | Set the bidding price. More information below.
| `exchange.name` | bittrex | Yes | Name of the exchange class to use. [List below](#user-content-what-values-for-exchangename).
| `exchange.key` | key | No | API key to use for the exchange. Only required when you are in production mode.
@@ -41,10 +47,10 @@ The table below will list all configuration parameters.
| `strategy_path` | null | No | Adds an additional strategy lookup path (must be a folder).
| `internals.process_throttle_secs` | 5 | Yes | Set the process throttle. Value in second.
-The definition of each config parameters is in
-[misc.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/misc.py#L205).
+The definition of each config parameters is in [misc.py](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/misc.py#L205).
### Understand stake_amount
+
`stake_amount` is an amount of crypto-currency your bot will use for each trade.
The minimal value is 0.0005. If there is not enough crypto-currency in
the account an exception is generated.
@@ -52,9 +58,11 @@ To allow the bot to trade all the avaliable `stake_currency` in your account set
In this case a trade amount is calclulated as `currency_balanse / (max_open_trades - current_open_trades)`.
### Understand minimal_roi
+
`minimal_roi` is a JSON object where the key is a duration
in minutes and the value is the minimum ROI in percent.
See the example below:
+
```
"minimal_roi": {
"40": 0.0, # Sell after 40 minutes if the profit is not negative
@@ -69,6 +77,7 @@ value. This parameter is optional. If you use it, it will take over the
`minimal_roi` value from the strategy file.
### Understand stoploss
+
`stoploss` is loss in percentage that should trigger a sale.
For example value `-0.10` will cause immediate sell if the
profit dips below -10% for a given trade. This parameter is optional.
@@ -77,82 +86,100 @@ Most of the strategy files already include the optimal `stoploss`
value. This parameter is optional. If you use it, it will take over the
`stoploss` value from the strategy file.
+### Understand trailing stoploss
+
+Go to the [trailing stoploss Documentation](stoploss.md) for details on trailing stoploss.
+
### Understand initial_state
+
`initial_state` is an optional field that defines the initial application state.
Possible values are `running` or `stopped`. (default=`running`)
If the value is `stopped` the bot has to be started with `/start` first.
### Understand process_throttle_secs
+
`process_throttle_secs` is an optional field that defines in seconds how long the bot should wait
before asking the strategy if we should buy or a sell an asset. After each wait period, the strategy is asked again for
every opened trade wether or not we should sell, and for all the remaining pairs (either the dynamic list of pairs or
the static list of pairs) if we should buy.
### Understand ask_last_balance
+
`ask_last_balance` sets the bidding price. Value `0.0` will use `ask` price, `1.0` will
use the `last` price and values between those interpolate between ask and last
price. Using `ask` price will guarantee quick success in bid, but bot will also
end up paying more then would probably have been necessary.
### What values for exchange.name?
+
Freqtrade is based on [CCXT library](https://github.com/ccxt/ccxt) that supports 115 cryptocurrency
exchange markets and trading APIs. The complete up-to-date list can be found in the
[CCXT repo homepage](https://github.com/ccxt/ccxt/tree/master/python). However, the bot was tested
with only Bittrex and Binance.
The bot was tested with the following exchanges:
+
- [Bittrex](https://bittrex.com/): "bittrex"
- [Binance](https://www.binance.com/): "binance"
Feel free to test other exchanges and submit your PR to improve the bot.
### What values for fiat_display_currency?
+
`fiat_display_currency` set the base currency to use for the conversion from coin to fiat in Telegram.
The valid values are: "AUD", "BRL", "CAD", "CHF", "CLP", "CNY", "CZK", "DKK", "EUR", "GBP", "HKD", "HUF", "IDR", "ILS", "INR", "JPY", "KRW", "MXN", "MYR", "NOK", "NZD", "PHP", "PKR", "PLN", "RUB", "SEK", "SGD", "THB", "TRY", "TWD", "ZAR", "USD".
In addition to central bank currencies, a range of cryto currencies are supported.
The valid values are: "BTC", "ETH", "XRP", "LTC", "BCH", "USDT".
## Switch to dry-run mode
+
We recommend starting the bot in dry-run mode to see how your bot will
behave and how is the performance of your strategy. In Dry-run mode the
bot does not engage your money. It only runs a live simulation without
creating trades.
### To switch your bot in Dry-run mode:
+
1. Edit your `config.json` file
2. Switch dry-run to true and specify db_url for a persistent db
+
```json
"dry_run": true,
"db_url": "sqlite///tradesv3.dryrun.sqlite",
```
3. Remove your Exchange API key (change them by fake api credentials)
+
```json
"exchange": {
"name": "bittrex",
"key": "key",
"secret": "secret",
...
-}
+}
```
Once you will be happy with your bot performance, you can switch it to
production mode.
## Switch to production mode
+
In production mode, the bot will engage your money. Be careful a wrong
strategy can lose all your money. Be aware of what you are doing when
you run it in production mode.
### To switch your bot in production mode:
+
1. Edit your `config.json` file
2. Switch dry-run to false and don't forget to adapt your database URL if set
+
```json
"dry_run": false,
```
3. Insert your Exchange API key (change them by fake api keys)
+
```json
"exchange": {
"name": "bittrex",
@@ -160,10 +187,10 @@ you run it in production mode.
"secret": "08a9dc6db3d7b53e1acebd9275677f4b0a04f1a5",
...
}
+
```
-If you have not your Bittrex API key yet,
-[see our tutorial](https://github.com/freqtrade/freqtrade/blob/develop/docs/pre-requisite.md).
+If you have not your Bittrex API key yet, [see our tutorial](https://github.com/freqtrade/freqtrade/blob/develop/docs/pre-requisite.md).
## Next step
-Now you have configured your config.json, the next step is to
-[start your bot](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md).
+
+Now you have configured your config.json, the next step is to [start your bot](https://github.com/freqtrade/freqtrade/blob/develop/docs/bot-usage.md).
diff --git a/docs/hyperopt.md b/docs/hyperopt.md
index 2ad94896a..f4b69b632 100644
--- a/docs/hyperopt.md
+++ b/docs/hyperopt.md
@@ -1,155 +1,114 @@
# Hyperopt
-This page explains how to tune your strategy by finding the optimal
-parameters with Hyperopt.
+This page explains how to tune your strategy by finding the optimal
+parameters, a process called hyperparameter optimization. The bot uses several
+algorithms included in the `scikit-optimize` package to accomplish this. The
+search will burn all your CPU cores, make your laptop sound like a fighter jet
+and still take a long time.
## Table of Contents
- [Prepare your Hyperopt](#prepare-hyperopt)
- - [1. Configure your Guards and Triggers](#1-configure-your-guards-and-triggers)
- - [2. Update the hyperopt config file](#2-update-the-hyperopt-config-file)
-- [Advanced Hyperopt notions](#advanced-notions)
- - [Understand the Guards and Triggers](#understand-the-guards-and-triggers)
+- [Configure your Guards and Triggers](#configure-your-guards-and-triggers)
+- [Solving a Mystery](#solving-a-mystery)
+- [Adding New Indicators](#adding-new-indicators)
- [Execute Hyperopt](#execute-hyperopt)
- [Understand the hyperopts result](#understand-the-backtesting-result)
-## Prepare Hyperopt
-Before we start digging in Hyperopt, we recommend you to take a look at
-your strategy file located into [user_data/strategies/](https://github.com/freqtrade/freqtrade/blob/develop/user_data/strategies/test_strategy.py)
+## Prepare Hyperopting
+We recommend you start by taking a look at `hyperopt.py` file located in [freqtrade/optimize](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/optimize/hyperopt.py)
-### 1. Configure your Guards and Triggers
-There are two places you need to change in your strategy file to add a
-new buy strategy for testing:
-- Inside [populate_buy_trend()](https://github.com/freqtrade/freqtrade/blob/develop/user_data/strategies/test_strategy.py#L278-L294).
-- Inside [hyperopt_space()](https://github.com/freqtrade/freqtrade/blob/develop/user_data/strategies/test_strategy.py#L244-L297) known as `SPACE`.
+### Configure your Guards and Triggers
+There are two places you need to change to add a new buy strategy for testing:
+- Inside [populate_buy_trend()](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/optimize/hyperopt.py#L278-L294).
+- Inside [hyperopt_space()](https://github.com/freqtrade/freqtrade/blob/develop/freqtrade/optimize/hyperopt.py#L218-L229)
+and the associated methods `indicator_space`, `roi_space`, `stoploss_space`.
-There you have two different type of indicators: 1. `guards` and 2.
-`triggers`.
-1. Guards are conditions like "never buy if ADX < 10", or never buy if
-current price is over EMA10.
+There you have two different type of indicators: 1. `guards` and 2. `triggers`.
+1. Guards are conditions like "never buy if ADX < 10", or "never buy if
+current price is over EMA10".
2. Triggers are ones that actually trigger buy in specific moment, like
-"buy when EMA5 crosses over EMA10" or buy when close price touches lower
-bollinger band.
+"buy when EMA5 crosses over EMA10" or "buy when close price touches lower
+bollinger band".
-HyperOpt will, for each eval round, pick just ONE trigger, and possibly
-multiple guards. So that the constructed strategy will be something like
+Hyperoptimization will, for each eval round, pick one trigger and possibly
+multiple guards. The constructed strategy will be something like
"*buy exactly when close price touches lower bollinger band, BUT only if
ADX > 10*".
-
-If you have updated the buy strategy, means change the content of
+If you have updated the buy strategy, ie. changed the contents of
`populate_buy_trend()` method you have to update the `guards` and
-`triggers` hyperopts must used.
+`triggers` hyperopts must use.
-As for an example if your `populate_buy_trend()` method is:
-```python
-def populate_buy_trend(dataframe: DataFrame) -> DataFrame:
- dataframe.loc[
- (dataframe['rsi'] < 35) &
- (dataframe['adx'] > 65),
- 'buy'] = 1
+## Solving a Mystery
- return dataframe
-```
+Let's say you are curious: should you use MACD crossings or lower Bollinger
+Bands to trigger your buys. And you also wonder should you use RSI or ADX to
+help with those buy decisions. If you decide to use RSI or ADX, which values
+should I use for them? So let's use hyperparameter optimization to solve this
+mystery.
-Your hyperopt file must contain `guards` to find the right value for
-`(dataframe['adx'] > 65)` & and `(dataframe['plus_di'] > 0.5)`. That
-means you will need to enable/disable triggers.
-
-In our case the `SPACE` and `populate_buy_trend` in your strategy file
-will look like:
-```python
-space = {
- 'rsi': hp.choice('rsi', [
- {'enabled': False},
- {'enabled': True, 'value': hp.quniform('rsi-value', 20, 40, 1)}
- ]),
- 'adx': hp.choice('adx', [
- {'enabled': False},
- {'enabled': True, 'value': hp.quniform('adx-value', 15, 50, 1)}
- ]),
- 'trigger': hp.choice('trigger', [
- {'type': 'lower_bb'},
- {'type': 'faststoch10'},
- {'type': 'ao_cross_zero'},
- {'type': 'ema5_cross_ema10'},
- {'type': 'macd_cross_signal'},
- {'type': 'sar_reversal'},
- {'type': 'stochf_cross'},
- {'type': 'ht_sine'},
- ]),
-}
-
-...
-
-def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
- conditions = []
- # GUARDS AND TRENDS
- if params['adx']['enabled']:
- conditions.append(dataframe['adx'] > params['adx']['value'])
- if params['rsi']['enabled']:
- conditions.append(dataframe['rsi'] < params['rsi']['value'])
-
- # TRIGGERS
- triggers = {
- 'lower_bb': dataframe['tema'] <= dataframe['blower'],
- 'faststoch10': (crossed_above(dataframe['fastd'], 10.0)),
- 'ao_cross_zero': (crossed_above(dataframe['ao'], 0.0)),
- 'ema5_cross_ema10': (crossed_above(dataframe['ema5'], dataframe['ema10'])),
- 'macd_cross_signal': (crossed_above(dataframe['macd'], dataframe['macdsignal'])),
- 'sar_reversal': (crossed_above(dataframe['close'], dataframe['sar'])),
- 'stochf_cross': (crossed_above(dataframe['fastk'], dataframe['fastd'])),
- 'ht_sine': (crossed_above(dataframe['htleadsine'], dataframe['htsine'])),
- }
- ...
-```
-
-
-### 2. Update the hyperopt config file
-Hyperopt is using a dedicated config file. Currently hyperopt
-cannot use your config file. It is also made on purpose to allow you
-testing your strategy with different configurations.
-
-The Hyperopt configuration is located in
-[user_data/hyperopt_conf.py](https://github.com/freqtrade/freqtrade/blob/develop/user_data/hyperopt_conf.py).
-
-
-## Advanced notions
-### Understand the Guards and Triggers
-When you need to add the new guards and triggers to be hyperopt
-parameters, you do this by adding them into the [hyperopt_space()](https://github.com/freqtrade/freqtrade/blob/develop/user_data/strategies/test_strategy.py#L244-L297).
-
-If it's a trigger, you add one line to the 'trigger' choice group and that's it.
-
-If it's a guard, you will add a line like this:
-```
-'rsi': hp.choice('rsi', [
- {'enabled': False},
- {'enabled': True, 'value': hp.quniform('rsi-value', 20, 40, 1)}
-]),
-```
-This says, "*one of the guards is RSI, it can have two values, enabled or
-disabled. If it is enabled, try different values for it between 20 and 40*".
-
-So, the part of the strategy builder using the above setting looks like
-this:
+We will start by defining a search space:
```
-if params['rsi']['enabled']:
- conditions.append(dataframe['rsi'] < params['rsi']['value'])
+ def indicator_space() -> List[Dimension]:
+ """
+ Define your Hyperopt space for searching strategy parameters
+ """
+ return [
+ Integer(20, 40, name='adx-value'),
+ Integer(20, 40, name='rsi-value'),
+ Categorical([True, False], name='adx-enabled'),
+ Categorical([True, False], name='rsi-enabled'),
+ Categorical(['bb_lower', 'macd_cross_signal'], name='trigger')
+ ]
```
-It checks if Hyperopt wants the RSI guard to be enabled for this
-round `params['rsi']['enabled']` and if it is, then it will add a
-condition that says RSI must be smaller than the value hyperopt picked
-for this evaluation, which is given in the `params['rsi']['value']`.
+Above definition says: I have five parameters I want you to randomly combine
+to find the best combination. Two of them are integer values (`adx-value`
+and `rsi-value`) and I want you test in the range of values 20 to 40.
+Then we have three category variables. First two are either `True` or `False`.
+We use these to either enable or disable the ADX and RSI guards. The last
+one we call `trigger` and use it to decide which buy trigger we want to use.
-That's it. Now you can add new parts of strategies to Hyperopt and it
-will try all the combinations with all different values in the search
-for best working algo.
+So let's write the buy strategy using these values:
+```
+ def populate_buy_trend(dataframe: DataFrame) -> DataFrame:
+ conditions = []
+ # GUARDS AND TRENDS
+ if 'adx-enabled' in params and params['adx-enabled']:
+ conditions.append(dataframe['adx'] > params['adx-value'])
+ if 'rsi-enabled' in params and params['rsi-enabled']:
+ conditions.append(dataframe['rsi'] < params['rsi-value'])
-### Add a new Indicators
-If you want to test an indicator that isn't used by the bot currently,
-you need to add it to the `populate_indicators()` method in `hyperopt.py`.
+ # TRIGGERS
+ if params['trigger'] == 'bb_lower':
+ conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
+ if params['trigger'] == 'macd_cross_signal':
+ conditions.append(qtpylib.crossed_above(
+ dataframe['macd'], dataframe['macdsignal']
+ ))
+
+ dataframe.loc[
+ reduce(lambda x, y: x & y, conditions),
+ 'buy'] = 1
+
+ return dataframe
+
+ return populate_buy_trend
+```
+
+Hyperopting will now call this `populate_buy_trend` as many times you ask it (`epochs`)
+with different value combinations. It will then use the given historical data and make
+buys based on the buy signals generated with the above function and based on the results
+it will end with telling you which paramter combination produced the best profits.
+
+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`.
+
+The above setup expects to find ADX, RSI and Bollinger Bands in the populated indicators.
+When you want to test an indicator that isn't used by the bot currently, remember to
+add it to the `populate_indicators()` method in `hyperopt.py`.
## Execute Hyperopt
Once you have updated your hyperopt configuration you can run it.
@@ -164,12 +123,12 @@ python3 ./freqtrade/main.py -c config.json hyperopt -e 5000
The `-e` flag will set how many evaluations hyperopt will do. We recommend
running at least several thousand evaluations.
-### Execute hyperopt with different ticker-data source
+### Execute Hyperopt with Different Ticker-Data Source
If you would like to hyperopt parameters using an alternate ticker data that
you have on-disk, use the `--datadir PATH` option. Default hyperopt will
use data from directory `user_data/data`.
-### Running hyperopt with smaller testset
+### Running Hyperopt with Smaller Testset
Use the `--timeperiod` argument to change how much of the testset
you want to use. The last N ticks/timeframes will be used.
Example:
@@ -178,7 +137,7 @@ Example:
python3 ./freqtrade/main.py hyperopt --timeperiod -200
```
-### Running hyperopt with smaller search space
+### Running Hyperopt with Smaller Search Space
Use the `--spaces` argument to limit the search space used by hyperopt.
Letting Hyperopt optimize everything is a huuuuge search space. Often it
might make more sense to start by just searching for initial buy algorithm.
@@ -193,87 +152,44 @@ Legal values are:
- `stoploss`: search for the best stoploss value
- space-separated list of any of the above values for example `--spaces roi stoploss`
-## Understand the hyperopts result
-Once Hyperopt is completed you can use the result to adding new buy
-signal. Given following result from hyperopt:
-```
-Best parameters:
-{
- "adx": {
- "enabled": true,
- "value": 15.0
- },
- "fastd": {
- "enabled": true,
- "value": 40.0
- },
- "green_candle": {
- "enabled": true
- },
- "mfi": {
- "enabled": false
- },
- "over_sar": {
- "enabled": false
- },
- "rsi": {
- "enabled": true,
- "value": 37.0
- },
- "trigger": {
- "type": "lower_bb"
- },
- "uptrend_long_ema": {
- "enabled": true
- },
- "uptrend_short_ema": {
- "enabled": false
- },
- "uptrend_sma": {
- "enabled": false
- }
-}
+## Understand the Hyperopts Result
+Once Hyperopt is completed you can use the result to create a new strategy.
+Given the following result from hyperopt:
-Best Result:
- 2197 trades. Avg profit 1.84%. Total profit 0.79367541 BTC. Avg duration 241.0 mins.
+```
+Best result:
+ 135 trades. Avg profit 0.57%. Total profit 0.03871918 BTC (0.7722Σ%). Avg duration 180.4 mins.
+with values:
+{'adx-value': 44, 'rsi-value': 29, 'adx-enabled': False, 'rsi-enabled': True, 'trigger': 'bb_lower'}
```
You should understand this result like:
-- You should **consider** the guard "adx" (`"adx"` is `"enabled": true`)
-and the best value is `15.0` (`"value": 15.0,`)
-- You should **consider** the guard "fastd" (`"fastd"` is `"enabled":
-true`) and the best value is `40.0` (`"value": 40.0,`)
-- You should **consider** to enable the guard "green_candle"
-(`"green_candle"` is `"enabled": true`) but this guards as no
-customizable value.
-- You should **ignore** the guard "mfi" (`"mfi"` is `"enabled": false`)
-- and so on...
+- The buy trigger that worked best was `bb_lower`.
+- You should not use ADX because `adx-enabled: False`)
+- You should **consider** using the RSI indicator (`rsi-enabled: True` and the best value is `29.0` (`rsi-value: 29.0`)
You have to look inside your strategy file into `buy_strategy_generator()`
method, what those values match to.
-So for example you had `adx:` with the `value: 15.0` so we would look
-at `adx`-block, that translates to the following code block:
+So for example you had `rsi-value: 29.0` so we would look
+at `rsi`-block, that translates to the following code block:
```
-(dataframe['adx'] > 15.0)
+(dataframe['rsi'] < 29.0)
```
-Translating your whole hyperopt result to as the new buy-signal
-would be the following:
+Translating your whole hyperopt result as the new buy-signal
+would then look like:
```
def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
dataframe.loc[
(
- (dataframe['adx'] > 15.0) & # adx-value
- (dataframe['fastd'] < 40.0) & # fastd-value
- (dataframe['close'] > dataframe['open']) & # green_candle
- (dataframe['rsi'] < 37.0) & # rsi-value
- (dataframe['ema50'] > dataframe['ema100']) # uptrend_long_ema
+ (dataframe['rsi'] < 29.0) & # rsi-value
+ dataframe['close'] < dataframe['bb_lowerband'] # trigger
),
'buy'] = 1
return dataframe
```
-## Next step
+## Next Step
Now you have a perfect bot and want to control it from Telegram. Your
next step is to learn the [Telegram usage](https://github.com/freqtrade/freqtrade/blob/develop/docs/telegram-usage.md).
diff --git a/docs/index.md b/docs/index.md
index afde2d5eb..fd6bf4378 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -1,4 +1,5 @@
# freqtrade documentation
+
Welcome to freqtrade documentation. Please feel free to contribute to
this documentation if you see it became outdated by sending us a
Pull-request. Do not hesitate to reach us on
@@ -6,6 +7,7 @@ Pull-request. Do not hesitate to reach us on
if you do not find the answer to your questions.
## Table of Contents
+
- [Pre-requisite](https://github.com/freqtrade/freqtrade/blob/develop/docs/pre-requisite.md)
- [Setup your Bittrex account](https://github.com/freqtrade/freqtrade/blob/develop/docs/pre-requisite.md#setup-your-bittrex-account)
- [Setup your Telegram bot](https://github.com/freqtrade/freqtrade/blob/develop/docs/pre-requisite.md#setup-your-telegram-bot)
diff --git a/docs/stoploss.md b/docs/stoploss.md
new file mode 100644
index 000000000..db4433a02
--- /dev/null
+++ b/docs/stoploss.md
@@ -0,0 +1,48 @@
+# Stop Loss support
+
+At this stage the bot contains the following stoploss support modes:
+
+1. static stop loss, defined in either the strategy or configuration
+2. trailing stop loss, defined in the configuration
+3. trailing stop loss, custom positive loss, defined in configuration
+
+## Static Stop Loss
+
+This is very simple, basically you define a stop loss of x in your strategy file or alternative in the configuration, which
+will overwrite the strategy definition. This will basically try to sell your asset, the second the loss exceeds the defined loss.
+
+## Trail Stop Loss
+
+The initial value for this stop loss, is defined in your strategy or configuration. Just as you would define your Stop Loss normally.
+To enable this Feauture all you have to do is to define the configuration element:
+
+``` json
+"trailing_stop" : True
+```
+
+This will now activate an algorithm, which automatically moves your stop loss up every time the price of your asset increases.
+
+For example, simplified math,
+
+* you buy an asset at a price of 100$
+* your stop loss is defined at 2%
+* which means your stop loss, gets triggered once your asset dropped below 98$
+* assuming your asset now increases to 102$
+* your stop loss, will now be 2% of 102$ or 99.96$
+* now your asset drops in value to 101$, your stop loss, will still be 99.96$
+
+basically what this means is that your stop loss will be adjusted to be always be 2% of the highest observed price
+
+### Custom positive loss
+
+Due to demand, it is possible to have a default stop loss, when you are in the red with your buy, but once your buy turns positive,
+the system will utilize a new stop loss, which can be a different value. For example your default stop loss is 5%, but once you are in the
+black, it will be changed to be only a 1% stop loss
+
+This can be configured in the main configuration file and requires `"trailing_stop": true` to be set to true.
+
+``` json
+ "trailing_stop_positive": 0.01,
+```
+
+The 0.01 would translate to a 1% stop loss, once you hit profit.
diff --git a/freqtrade/__init__.py b/freqtrade/__init__.py
index 7cf0fa996..ac00264f0 100644
--- a/freqtrade/__init__.py
+++ b/freqtrade/__init__.py
@@ -1,5 +1,5 @@
""" FreqTrade bot """
-__version__ = '0.17.0'
+__version__ = '0.17.1'
class DependencyException(BaseException):
diff --git a/freqtrade/__main__.py b/freqtrade/__main__.py
index fe1318a35..7d271dfd1 100644
--- a/freqtrade/__main__.py
+++ b/freqtrade/__main__.py
@@ -7,8 +7,8 @@ To launch Freqtrade as a module
"""
import sys
-from freqtrade import main
+from freqtrade import main
if __name__ == '__main__':
main.set_loggers()
diff --git a/freqtrade/analyze.py b/freqtrade/analyze.py
index 36e00dd0e..6d6a85596 100644
--- a/freqtrade/analyze.py
+++ b/freqtrade/analyze.py
@@ -12,8 +12,7 @@ from pandas import DataFrame, to_datetime
from freqtrade import constants
from freqtrade.exchange import Exchange
from freqtrade.persistence import Trade
-from freqtrade.strategy.resolver import StrategyResolver, IStrategy
-
+from freqtrade.strategy.resolver import IStrategy, StrategyResolver
logger = logging.getLogger(__name__)
@@ -180,7 +179,7 @@ class Analyze(object):
:return: True if trade should be sold, False otherwise
"""
current_profit = trade.calc_profit_percent(rate)
- if self.stop_loss_reached(current_profit=current_profit):
+ if self.stop_loss_reached(current_rate=rate, trade=trade, current_time=date):
return True
experimental = self.config.get('experimental', {})
@@ -204,12 +203,46 @@ class Analyze(object):
return False
- def stop_loss_reached(self, current_profit: float) -> bool:
- """Based on current profit of the trade and configured stoploss, decides to sell or not"""
+ def stop_loss_reached(self, current_rate: float, trade: Trade, current_time: datetime) -> bool:
+ """
+ Based on current profit of the trade and configured (trailing) stoploss,
+ decides to sell or not
+ """
+
+ current_profit = trade.calc_profit_percent(current_rate)
+ trailing_stop = self.config.get('trailing_stop', False)
+
+ trade.adjust_stop_loss(trade.open_rate, self.strategy.stoploss, initial=True)
+
+ # evaluate if the stoploss was hit
+ if self.strategy.stoploss is not None and trade.stop_loss >= current_rate:
+
+ if trailing_stop:
+ logger.debug(
+ f"HIT STOP: current price at {current_rate:.6f}, "
+ f"stop loss is {trade.stop_loss:.6f}, "
+ f"initial stop loss was at {trade.initial_stop_loss:.6f}, "
+ f"trade opened at {trade.open_rate:.6f}")
+ logger.debug(f"trailing stop saved {trade.stop_loss - trade.initial_stop_loss:.6f}")
- if self.strategy.stoploss is not None and current_profit < self.strategy.stoploss:
logger.debug('Stop loss hit.')
return True
+
+ # update the stop loss afterwards, after all by definition it's supposed to be hanging
+ if trailing_stop:
+
+ # check if we have a special stop loss for positive condition
+ # and if profit is positive
+ stop_loss_value = self.strategy.stoploss
+ if 'trailing_stop_positive' in self.config and current_profit > 0:
+
+ # Ignore mypy error check in configuration that this is a float
+ stop_loss_value = self.config.get('trailing_stop_positive') # type: ignore
+ logger.debug(f"using positive stop loss mode: {stop_loss_value} "
+ f"since we have profit {current_profit}")
+
+ trade.adjust_stop_loss(current_rate, stop_loss_value)
+
return False
def min_roi_reached(self, trade: Trade, current_profit: float, current_time: datetime) -> bool:
diff --git a/freqtrade/arguments.py b/freqtrade/arguments.py
index 31232f1ff..731c5d88c 100644
--- a/freqtrade/arguments.py
+++ b/freqtrade/arguments.py
@@ -2,12 +2,13 @@
This module contains the argument manager class
"""
-import os
import argparse
import logging
+import os
import re
+from typing import List, NamedTuple, Optional
+
import arrow
-from typing import List, Optional, NamedTuple
from freqtrade import __version__, constants
@@ -334,3 +335,10 @@ class Arguments(object):
nargs='+',
dest='timeframes',
)
+
+ self.parser.add_argument(
+ '--erase',
+ help='Clean all existing data for the selected exchange/pairs/timeframes',
+ dest='erase',
+ action='store_true'
+ )
diff --git a/freqtrade/configuration.py b/freqtrade/configuration.py
index 7c3a5eb4b..582b2889c 100644
--- a/freqtrade/configuration.py
+++ b/freqtrade/configuration.py
@@ -1,18 +1,18 @@
"""
This module contains the configuration class
"""
-import os
import json
import logging
+import os
from argparse import Namespace
-from typing import Optional, Dict, Any
+from typing import Any, Dict, Optional
+
+import ccxt
from jsonschema import Draft4Validator, validate
from jsonschema.exceptions import ValidationError, best_match
-import ccxt
from freqtrade import OperationalException, constants
-
logger = logging.getLogger(__name__)
@@ -62,8 +62,8 @@ class Configuration(object):
conf = json.load(file)
except FileNotFoundError:
raise OperationalException(
- 'Config file "{}" not found!'
- ' Please create a config file or check whether it exists.'.format(path))
+ f'Config file "{path}" not found!'
+ ' Please create a config file or check whether it exists.')
if 'internals' not in conf:
conf['internals'] = {}
@@ -109,7 +109,7 @@ class Configuration(object):
config['db_url'] = constants.DEFAULT_DB_PROD_URL
logger.info('Dry run is disabled')
- logger.info('Using DB: "{}"'.format(config['db_url']))
+ logger.info(f'Using DB: "{config["db_url"]}"')
# Check if the exchange set by the user is supported
self.check_exchange(config)
diff --git a/freqtrade/constants.py b/freqtrade/constants.py
index 0f12905e3..ec7765455 100644
--- a/freqtrade/constants.py
+++ b/freqtrade/constants.py
@@ -61,7 +61,15 @@ CONF_SCHEMA = {
'minProperties': 1
},
'stoploss': {'type': 'number', 'maximum': 0, 'exclusiveMaximum': True},
- 'unfilledtimeout': {'type': 'integer', 'minimum': 0},
+ 'trailing_stop': {'type': 'boolean'},
+ 'trailing_stop_positive': {'type': 'number', 'minimum': 0, 'maximum': 1},
+ 'unfilledtimeout': {
+ 'type': 'object',
+ 'properties': {
+ 'buy': {'type': 'number', 'minimum': 3},
+ 'sell': {'type': 'number', 'minimum': 10}
+ }
+ },
'bid_strategy': {
'type': 'object',
'properties': {
diff --git a/freqtrade/fiat_convert.py b/freqtrade/fiat_convert.py
index 44a4f3054..2e1a7cac8 100644
--- a/freqtrade/fiat_convert.py
+++ b/freqtrade/fiat_convert.py
@@ -7,10 +7,12 @@ import logging
import time
from typing import Dict, List
-from coinmarketcap import Market
from requests.exceptions import RequestException
+from coinmarketcap import Market
+
from freqtrade.constants import SUPPORTED_FIAT
+
logger = logging.getLogger(__name__)
diff --git a/freqtrade/freqtradebot.py b/freqtrade/freqtradebot.py
index e25ed66cf..9def7078c 100644
--- a/freqtrade/freqtradebot.py
+++ b/freqtrade/freqtradebot.py
@@ -7,16 +7,14 @@ import logging
import time
import traceback
from datetime import datetime
-from typing import Dict, List, Optional, Any, Callable
+from typing import Any, Callable, Dict, List, Optional
import arrow
import requests
from cachetools import TTLCache, cached
-from freqtrade import (
- DependencyException, OperationalException, TemporaryError, persistence, __version__,
-)
-from freqtrade import constants
+from freqtrade import (DependencyException, OperationalException,
+ TemporaryError, __version__, constants, persistence)
from freqtrade.analyze import Analyze
from freqtrade.exchange import Exchange
from freqtrade.fiat_convert import CryptoToFiatConverter
@@ -160,7 +158,7 @@ class FreqtradeBot(object):
if 'unfilledtimeout' in self.config:
# Check and handle any timed out open orders
- self.check_handle_timedout(self.config['unfilledtimeout'])
+ self.check_handle_timedout()
Trade.session.flush()
except TemporaryError as error:
@@ -277,11 +275,14 @@ class FreqtradeBot(object):
return None
min_stake_amounts = []
- if 'cost' in market['limits'] and 'min' in market['limits']['cost']:
- min_stake_amounts.append(market['limits']['cost']['min'])
+ limits = market['limits']
+ if ('cost' in limits and 'min' in limits['cost']
+ and limits['cost']['min'] is not None):
+ min_stake_amounts.append(limits['cost']['min'])
- if 'amount' in market['limits'] and 'min' in market['limits']['amount']:
- min_stake_amounts.append(market['limits']['amount']['min'] * price)
+ if ('amount' in limits and 'min' in limits['amount']
+ and limits['amount']['min'] is not None):
+ min_stake_amounts.append(limits['amount']['min'] * price)
if not min_stake_amounts:
return None
@@ -492,13 +493,16 @@ with limit `{buy_limit:.8f} ({stake_amount:.6f} \
logger.info('Found no sell signals for whitelisted currencies. Trying again..')
return False
- def check_handle_timedout(self, timeoutvalue: int) -> None:
+ def check_handle_timedout(self) -> None:
"""
Check if any orders are timed out and cancel if neccessary
:param timeoutvalue: Number of minutes until order is considered timed out
:return: None
"""
- timeoutthreashold = arrow.utcnow().shift(minutes=-timeoutvalue).datetime
+ buy_timeout = self.config['unfilledtimeout']['buy']
+ sell_timeout = self.config['unfilledtimeout']['sell']
+ buy_timeoutthreashold = arrow.utcnow().shift(minutes=-buy_timeout).datetime
+ sell_timeoutthreashold = arrow.utcnow().shift(minutes=-sell_timeout).datetime
for trade in Trade.query.filter(Trade.open_order_id.isnot(None)).all():
try:
@@ -521,10 +525,12 @@ with limit `{buy_limit:.8f} ({stake_amount:.6f} \
if int(order['remaining']) == 0:
continue
- if order['side'] == 'buy' and ordertime < timeoutthreashold:
- self.handle_timedout_limit_buy(trade, order)
- elif order['side'] == 'sell' and ordertime < timeoutthreashold:
- self.handle_timedout_limit_sell(trade, order)
+ # Check if trade is still actually open
+ if order['status'] == 'open':
+ if order['side'] == 'buy' and ordertime < buy_timeoutthreashold:
+ self.handle_timedout_limit_buy(trade, order)
+ elif order['side'] == 'sell' and ordertime < sell_timeoutthreashold:
+ self.handle_timedout_limit_sell(trade, order)
# FIX: 20180110, why is cancel.order unconditionally here, whereas
# it is conditionally called in the
@@ -620,12 +626,8 @@ with limit `{buy_limit:.8f} ({stake_amount:.6f} \
# Because telegram._forcesell does not have the configuration
# Ignore the FIAT value and does not show the stake_currency as well
else:
- message += '` ({gain}: {profit_percent:.2f}%, {profit_coin:.8f})`'.format(
- gain="profit" if fmt_exp_profit > 0 else "loss",
- profit_percent=fmt_exp_profit,
- profit_coin=profit_trade
- )
-
+ gain = "profit" if fmt_exp_profit > 0 else "loss"
+ message += f'` ({gain}: {fmt_exp_profit:.2f}%, {profit_trade:.8f})`'
# Send the message
self.rpc.send_msg(message)
Trade.session.flush()
diff --git a/freqtrade/indicator_helpers.py b/freqtrade/indicator_helpers.py
index 50586578a..f8ea0d939 100644
--- a/freqtrade/indicator_helpers.py
+++ b/freqtrade/indicator_helpers.py
@@ -1,4 +1,4 @@
-from math import exp, pi, sqrt, cos
+from math import cos, exp, pi, sqrt
import numpy as np
import talib as ta
diff --git a/freqtrade/main.py b/freqtrade/main.py
index 9d17a403a..79080ce37 100755
--- a/freqtrade/main.py
+++ b/freqtrade/main.py
@@ -74,10 +74,7 @@ def reconfigure(freqtrade: FreqtradeBot, args: Namespace) -> FreqtradeBot:
# Create new instance
freqtrade = FreqtradeBot(Configuration(args).get_config())
freqtrade.rpc.send_msg(
- '*Status:* `Config reloaded ...`'.format(
- freqtrade.state.name.lower()
- )
- )
+ '*Status:* `Config reloaded {freqtrade.state.name.lower()}...`')
return freqtrade
diff --git a/freqtrade/misc.py b/freqtrade/misc.py
index 90a1db42b..832437951 100644
--- a/freqtrade/misc.py
+++ b/freqtrade/misc.py
@@ -2,10 +2,10 @@
Various tool function for Freqtrade and scripts
"""
+import gzip
import json
import logging
import re
-import gzip
from datetime import datetime
from typing import Dict
diff --git a/freqtrade/optimize/__init__.py b/freqtrade/optimize/__init__.py
index 1e76808e7..e806ff2b8 100644
--- a/freqtrade/optimize/__init__.py
+++ b/freqtrade/optimize/__init__.py
@@ -54,11 +54,8 @@ def load_tickerdata_file(
:return dict OR empty if unsuccesful
"""
path = make_testdata_path(datadir)
- pair_file_string = pair.replace('/', '_')
- file = os.path.join(path, '{pair}-{ticker_interval}.json'.format(
- pair=pair_file_string,
- ticker_interval=ticker_interval,
- ))
+ pair_s = pair.replace('/', '_')
+ file = os.path.join(path, f'{pair_s}-{ticker_interval}.json')
gzipfile = file + '.gz'
# If the file does not exist we download it when None is returned.
diff --git a/freqtrade/optimize/backtesting.py b/freqtrade/optimize/backtesting.py
index 6982b36cb..16c21258f 100644
--- a/freqtrade/optimize/backtesting.py
+++ b/freqtrade/optimize/backtesting.py
@@ -7,18 +7,18 @@ import logging
import operator
from argparse import Namespace
from datetime import datetime
-from typing import Dict, Tuple, Any, List, Optional, NamedTuple
+from typing import Any, Dict, List, NamedTuple, Optional, Tuple
import arrow
from pandas import DataFrame
from tabulate import tabulate
import freqtrade.optimize as optimize
-from freqtrade import constants, DependencyException
-from freqtrade.exchange import Exchange
+from freqtrade import DependencyException, constants
from freqtrade.analyze import Analyze
from freqtrade.arguments import Arguments
from freqtrade.configuration import Configuration
+from freqtrade.exchange import Exchange
from freqtrade.misc import file_dump_json
from freqtrade.persistence import Trade
@@ -38,6 +38,8 @@ class BacktestResult(NamedTuple):
close_index: int
trade_duration: float
open_at_end: bool
+ open_rate: float
+ close_rate: float
class Backtesting(object):
@@ -116,11 +118,10 @@ class Backtesting(object):
def _store_backtest_result(self, recordfilename: Optional[str], results: DataFrame) -> None:
- records = [(trade_entry.pair, trade_entry.profit_percent,
- trade_entry.open_time.timestamp(),
- trade_entry.close_time.timestamp(),
- trade_entry.open_index - 1, trade_entry.trade_duration)
- for index, trade_entry in results.iterrows()]
+ records = [(t.pair, t.profit_percent, t.open_time.timestamp(),
+ t.close_time.timestamp(), t.open_index - 1, t.trade_duration,
+ t.open_rate, t.close_rate, t.open_at_end)
+ for index, t in results.iterrows()]
if records:
logger.info('Dumping backtest results to %s', recordfilename)
@@ -159,7 +160,9 @@ class Backtesting(object):
trade_duration=(sell_row.date - buy_row.date).seconds // 60,
open_index=buy_row.Index,
close_index=sell_row.Index,
- open_at_end=False
+ open_at_end=False,
+ open_rate=buy_row.close,
+ close_rate=sell_row.close
)
if partial_ticker:
# no sell condition found - trade stil open at end of backtest period
@@ -172,7 +175,9 @@ class Backtesting(object):
trade_duration=(sell_row.date - buy_row.date).seconds // 60,
open_index=buy_row.Index,
close_index=sell_row.Index,
- open_at_end=True
+ open_at_end=True,
+ open_rate=buy_row.close,
+ close_rate=sell_row.close
)
logger.debug('Force_selling still open trade %s with %s perc - %s', btr.pair,
btr.profit_percent, btr.profit_abs)
diff --git a/freqtrade/optimize/hyperopt.py b/freqtrade/optimize/hyperopt.py
index 7a313a3ac..72bf34eb3 100644
--- a/freqtrade/optimize/hyperopt.py
+++ b/freqtrade/optimize/hyperopt.py
@@ -4,22 +4,21 @@
This module contains the hyperopt logic
"""
-import json
import logging
+import multiprocessing
import os
-import pickle
-import signal
import sys
from argparse import Namespace
from functools import reduce
from math import exp
from operator import itemgetter
-from typing import Dict, Any, Callable, Optional
+from typing import Any, Callable, Dict, List
-import numpy
import talib.abstract as ta
-from hyperopt import STATUS_FAIL, STATUS_OK, Trials, fmin, hp, space_eval, tpe
from pandas import DataFrame
+from sklearn.externals.joblib import Parallel, delayed, dump, load
+from skopt import Optimizer
+from skopt.space import Categorical, Dimension, Integer, Real
import freqtrade.vendor.qtpylib.indicators as qtpylib
from freqtrade.arguments import Arguments
@@ -29,6 +28,9 @@ from freqtrade.optimize.backtesting import Backtesting
logger = logging.getLogger(__name__)
+MAX_LOSS = 100000 # just a big enough number to be bad result in loss optimization
+TICKERDATA_PICKLE = os.path.join('user_data', 'hyperopt_tickerdata.pkl')
+
class Hyperopt(Backtesting):
"""
@@ -44,7 +46,6 @@ class Hyperopt(Backtesting):
# to the number of days
self.target_trades = 600
self.total_tries = config.get('epochs', 0)
- self.current_tries = 0
self.current_best_loss = 100
# max average trade duration in minutes
@@ -56,130 +57,38 @@ class Hyperopt(Backtesting):
# check that the reported Σ% values do not exceed this!
self.expected_max_profit = 3.0
- # Configuration and data used by hyperopt
- self.processed: Optional[Dict[str, Any]] = None
+ # Previous evaluations
+ self.trials_file = os.path.join('user_data', 'hyperopt_results.pickle')
+ self.trials: List = []
- # Hyperopt Trials
- self.trials_file = os.path.join('user_data', 'hyperopt_trials.pickle')
- self.trials = Trials()
+ def get_args(self, params):
+ dimensions = self.hyperopt_space()
+ # Ensure the number of dimensions match
+ # the number of parameters in the list x.
+ if len(params) != len(dimensions):
+ raise ValueError('Mismatch in number of search-space dimensions. '
+ f'len(dimensions)=={len(dimensions)} and len(x)=={len(params)}')
+
+ # Create a dict where the keys are the names of the dimensions
+ # and the values are taken from the list of parameters x.
+ arg_dict = {dim.name: value for dim, value in zip(dimensions, params)}
+ return arg_dict
@staticmethod
def populate_indicators(dataframe: DataFrame) -> DataFrame:
- """
- Adds several different TA indicators to the given DataFrame
- """
dataframe['adx'] = ta.ADX(dataframe)
- dataframe['ao'] = qtpylib.awesome_oscillator(dataframe)
- dataframe['cci'] = ta.CCI(dataframe)
macd = ta.MACD(dataframe)
dataframe['macd'] = macd['macd']
dataframe['macdsignal'] = macd['macdsignal']
- dataframe['macdhist'] = macd['macdhist']
dataframe['mfi'] = ta.MFI(dataframe)
- dataframe['minus_dm'] = ta.MINUS_DM(dataframe)
- dataframe['minus_di'] = ta.MINUS_DI(dataframe)
- dataframe['plus_dm'] = ta.PLUS_DM(dataframe)
- dataframe['plus_di'] = ta.PLUS_DI(dataframe)
- dataframe['roc'] = ta.ROC(dataframe)
dataframe['rsi'] = ta.RSI(dataframe)
- # Inverse Fisher transform on RSI, values [-1.0, 1.0] (https://goo.gl/2JGGoy)
- rsi = 0.1 * (dataframe['rsi'] - 50)
- dataframe['fisher_rsi'] = (numpy.exp(2 * rsi) - 1) / (numpy.exp(2 * rsi) + 1)
- # Inverse Fisher transform on RSI normalized, value [0.0, 100.0] (https://goo.gl/2JGGoy)
- dataframe['fisher_rsi_norma'] = 50 * (dataframe['fisher_rsi'] + 1)
- # Stoch
- stoch = ta.STOCH(dataframe)
- dataframe['slowd'] = stoch['slowd']
- dataframe['slowk'] = stoch['slowk']
- # Stoch fast
stoch_fast = ta.STOCHF(dataframe)
dataframe['fastd'] = stoch_fast['fastd']
- dataframe['fastk'] = stoch_fast['fastk']
- # Stoch RSI
- stoch_rsi = ta.STOCHRSI(dataframe)
- dataframe['fastd_rsi'] = stoch_rsi['fastd']
- dataframe['fastk_rsi'] = stoch_rsi['fastk']
+ dataframe['minus_di'] = ta.MINUS_DI(dataframe)
# Bollinger bands
bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2)
dataframe['bb_lowerband'] = bollinger['lower']
- dataframe['bb_middleband'] = bollinger['mid']
- dataframe['bb_upperband'] = bollinger['upper']
- # EMA - Exponential Moving Average
- dataframe['ema3'] = ta.EMA(dataframe, timeperiod=3)
- dataframe['ema5'] = ta.EMA(dataframe, timeperiod=5)
- dataframe['ema10'] = ta.EMA(dataframe, timeperiod=10)
- dataframe['ema50'] = ta.EMA(dataframe, timeperiod=50)
- dataframe['ema100'] = ta.EMA(dataframe, timeperiod=100)
- # SAR Parabolic
dataframe['sar'] = ta.SAR(dataframe)
- # SMA - Simple Moving Average
- dataframe['sma'] = ta.SMA(dataframe, timeperiod=40)
- # TEMA - Triple Exponential Moving Average
- dataframe['tema'] = ta.TEMA(dataframe, timeperiod=9)
- # Hilbert Transform Indicator - SineWave
- hilbert = ta.HT_SINE(dataframe)
- dataframe['htsine'] = hilbert['sine']
- dataframe['htleadsine'] = hilbert['leadsine']
-
- # Pattern Recognition - Bullish candlestick patterns
- # ------------------------------------
- """
- # Hammer: values [0, 100]
- dataframe['CDLHAMMER'] = ta.CDLHAMMER(dataframe)
- # Inverted Hammer: values [0, 100]
- dataframe['CDLINVERTEDHAMMER'] = ta.CDLINVERTEDHAMMER(dataframe)
- # Dragonfly Doji: values [0, 100]
- dataframe['CDLDRAGONFLYDOJI'] = ta.CDLDRAGONFLYDOJI(dataframe)
- # Piercing Line: values [0, 100]
- dataframe['CDLPIERCING'] = ta.CDLPIERCING(dataframe) # values [0, 100]
- # Morningstar: values [0, 100]
- dataframe['CDLMORNINGSTAR'] = ta.CDLMORNINGSTAR(dataframe) # values [0, 100]
- # Three White Soldiers: values [0, 100]
- dataframe['CDL3WHITESOLDIERS'] = ta.CDL3WHITESOLDIERS(dataframe) # values [0, 100]
- """
-
- # Pattern Recognition - Bearish candlestick patterns
- # ------------------------------------
- """
- # Hanging Man: values [0, 100]
- dataframe['CDLHANGINGMAN'] = ta.CDLHANGINGMAN(dataframe)
- # Shooting Star: values [0, 100]
- dataframe['CDLSHOOTINGSTAR'] = ta.CDLSHOOTINGSTAR(dataframe)
- # Gravestone Doji: values [0, 100]
- dataframe['CDLGRAVESTONEDOJI'] = ta.CDLGRAVESTONEDOJI(dataframe)
- # Dark Cloud Cover: values [0, 100]
- dataframe['CDLDARKCLOUDCOVER'] = ta.CDLDARKCLOUDCOVER(dataframe)
- # Evening Doji Star: values [0, 100]
- dataframe['CDLEVENINGDOJISTAR'] = ta.CDLEVENINGDOJISTAR(dataframe)
- # Evening Star: values [0, 100]
- dataframe['CDLEVENINGSTAR'] = ta.CDLEVENINGSTAR(dataframe)
- """
-
- # Pattern Recognition - Bullish/Bearish candlestick patterns
- # ------------------------------------
- """
- # Three Line Strike: values [0, -100, 100]
- dataframe['CDL3LINESTRIKE'] = ta.CDL3LINESTRIKE(dataframe)
- # Spinning Top: values [0, -100, 100]
- dataframe['CDLSPINNINGTOP'] = ta.CDLSPINNINGTOP(dataframe) # values [0, -100, 100]
- # Engulfing: values [0, -100, 100]
- dataframe['CDLENGULFING'] = ta.CDLENGULFING(dataframe) # values [0, -100, 100]
- # Harami: values [0, -100, 100]
- dataframe['CDLHARAMI'] = ta.CDLHARAMI(dataframe) # values [0, -100, 100]
- # Three Outside Up/Down: values [0, -100, 100]
- dataframe['CDL3OUTSIDE'] = ta.CDL3OUTSIDE(dataframe) # values [0, -100, 100]
- # Three Inside Up/Down: values [0, -100, 100]
- dataframe['CDL3INSIDE'] = ta.CDL3INSIDE(dataframe) # values [0, -100, 100]
- """
-
- # Chart type
- # ------------------------------------
- # Heikinashi stategy
- heikinashi = qtpylib.heikinashi(dataframe)
- dataframe['ha_open'] = heikinashi['open']
- dataframe['ha_close'] = heikinashi['close']
- dataframe['ha_high'] = heikinashi['high']
- dataframe['ha_low'] = heikinashi['low']
return dataframe
@@ -187,15 +96,16 @@ class Hyperopt(Backtesting):
"""
Save hyperopt trials to file
"""
- logger.info('Saving Trials to \'%s\'', self.trials_file)
- pickle.dump(self.trials, open(self.trials_file, 'wb'))
+ if self.trials:
+ logger.info('Saving %d evaluations to \'%s\'', len(self.trials), self.trials_file)
+ dump(self.trials, self.trials_file)
- def read_trials(self) -> Trials:
+ def read_trials(self) -> List:
"""
Read hyperopt trials file
"""
logger.info('Reading Trials from \'%s\'', self.trials_file)
- trials = pickle.load(open(self.trials_file, 'rb'))
+ trials = load(self.trials_file)
os.remove(self.trials_file)
return trials
@@ -203,22 +113,27 @@ class Hyperopt(Backtesting):
"""
Display Best hyperopt result
"""
- vals = json.dumps(self.trials.best_trial['misc']['vals'], indent=4)
- results = self.trials.best_trial['result']['result']
- logger.info('Best result:\n%s\nwith values:\n%s', results, vals)
+ results = sorted(self.trials, key=itemgetter('loss'))
+ best_result = results[0]
+ logger.info(
+ 'Best result:\n%s\nwith values:\n%s',
+ best_result['result'],
+ best_result['params']
+ )
+ if 'roi_t1' in best_result['params']:
+ logger.info('ROI table:\n%s', self.generate_roi_table(best_result['params']))
def log_results(self, results) -> None:
"""
Log results if it is better than any previous evaluation
"""
if results['loss'] < self.current_best_loss:
+ current = results['current_tries']
+ total = results['total_tries']
+ res = results['result']
+ loss = results['loss']
self.current_best_loss = results['loss']
- log_msg = '\n{:5d}/{}: {}. Loss {:.5f}'.format(
- results['current_tries'],
- results['total_tries'],
- results['result'],
- results['loss']
- )
+ log_msg = f'\n{current:5d}/{total}: {res}. Loss {loss:.5f}'
print(log_msg)
else:
print('.', end='')
@@ -231,7 +146,8 @@ class Hyperopt(Backtesting):
trade_loss = 1 - 0.25 * exp(-(trade_count - self.target_trades) ** 2 / 10 ** 5.8)
profit_loss = max(0, 1 - total_profit / self.expected_max_profit)
duration_loss = 0.4 * min(trade_duration / self.max_accepted_trade_duration, 1)
- return trade_loss + profit_loss + duration_loss
+ result = trade_loss + profit_loss + duration_loss
+ return result
@staticmethod
def generate_roi_table(params: Dict) -> Dict[int, float]:
@@ -247,87 +163,44 @@ class Hyperopt(Backtesting):
return roi_table
@staticmethod
- def roi_space() -> Dict[str, Any]:
+ def roi_space() -> List[Dimension]:
"""
Values to search for each ROI steps
"""
- return {
- 'roi_t1': hp.quniform('roi_t1', 10, 120, 20),
- 'roi_t2': hp.quniform('roi_t2', 10, 60, 15),
- 'roi_t3': hp.quniform('roi_t3', 10, 40, 10),
- 'roi_p1': hp.quniform('roi_p1', 0.01, 0.04, 0.01),
- 'roi_p2': hp.quniform('roi_p2', 0.01, 0.07, 0.01),
- 'roi_p3': hp.quniform('roi_p3', 0.01, 0.20, 0.01),
- }
+ return [
+ Integer(10, 120, name='roi_t1'),
+ Integer(10, 60, name='roi_t2'),
+ Integer(10, 40, name='roi_t3'),
+ Real(0.01, 0.04, name='roi_p1'),
+ Real(0.01, 0.07, name='roi_p2'),
+ Real(0.01, 0.20, name='roi_p3'),
+ ]
@staticmethod
- def stoploss_space() -> Dict[str, Any]:
+ def stoploss_space() -> List[Dimension]:
"""
- Stoploss Value to search
+ Stoploss search space
"""
- return {
- 'stoploss': hp.quniform('stoploss', -0.5, -0.02, 0.02),
- }
+ return [
+ Real(-0.5, -0.02, name='stoploss'),
+ ]
@staticmethod
- def indicator_space() -> Dict[str, Any]:
+ def indicator_space() -> List[Dimension]:
"""
Define your Hyperopt space for searching strategy parameters
"""
- return {
- 'macd_below_zero': hp.choice('macd_below_zero', [
- {'enabled': False},
- {'enabled': True}
- ]),
- 'mfi': hp.choice('mfi', [
- {'enabled': False},
- {'enabled': True, 'value': hp.quniform('mfi-value', 10, 25, 5)}
- ]),
- 'fastd': hp.choice('fastd', [
- {'enabled': False},
- {'enabled': True, 'value': hp.quniform('fastd-value', 15, 45, 5)}
- ]),
- 'adx': hp.choice('adx', [
- {'enabled': False},
- {'enabled': True, 'value': hp.quniform('adx-value', 20, 50, 5)}
- ]),
- 'rsi': hp.choice('rsi', [
- {'enabled': False},
- {'enabled': True, 'value': hp.quniform('rsi-value', 20, 40, 5)}
- ]),
- 'uptrend_long_ema': hp.choice('uptrend_long_ema', [
- {'enabled': False},
- {'enabled': True}
- ]),
- 'uptrend_short_ema': hp.choice('uptrend_short_ema', [
- {'enabled': False},
- {'enabled': True}
- ]),
- 'over_sar': hp.choice('over_sar', [
- {'enabled': False},
- {'enabled': True}
- ]),
- 'green_candle': hp.choice('green_candle', [
- {'enabled': False},
- {'enabled': True}
- ]),
- 'uptrend_sma': hp.choice('uptrend_sma', [
- {'enabled': False},
- {'enabled': True}
- ]),
- 'trigger': hp.choice('trigger', [
- {'type': 'lower_bb'},
- {'type': 'lower_bb_tema'},
- {'type': 'faststoch10'},
- {'type': 'ao_cross_zero'},
- {'type': 'ema3_cross_ema10'},
- {'type': 'macd_cross_signal'},
- {'type': 'sar_reversal'},
- {'type': 'ht_sine'},
- {'type': 'heiken_reversal_bull'},
- {'type': 'di_cross'},
- ]),
- }
+ return [
+ Integer(10, 25, name='mfi-value'),
+ Integer(15, 45, name='fastd-value'),
+ Integer(20, 50, name='adx-value'),
+ Integer(20, 40, name='rsi-value'),
+ Categorical([True, False], name='mfi-enabled'),
+ Categorical([True, False], name='fastd-enabled'),
+ Categorical([True, False], name='adx-enabled'),
+ Categorical([True, False], name='rsi-enabled'),
+ Categorical(['bb_lower', 'macd_cross_signal', 'sar_reversal'], name='trigger')
+ ]
def has_space(self, space: str) -> bool:
"""
@@ -337,17 +210,17 @@ class Hyperopt(Backtesting):
return True
return False
- def hyperopt_space(self) -> Dict[str, Any]:
+ def hyperopt_space(self) -> List[Dimension]:
"""
Return the space to use during Hyperopt
"""
- spaces: Dict = {}
+ spaces: List[Dimension] = []
if self.has_space('buy'):
- spaces = {**spaces, **Hyperopt.indicator_space()}
+ spaces += Hyperopt.indicator_space()
if self.has_space('roi'):
- spaces = {**spaces, **Hyperopt.roi_space()}
+ spaces += Hyperopt.roi_space()
if self.has_space('stoploss'):
- spaces = {**spaces, **Hyperopt.stoploss_space()}
+ spaces += Hyperopt.stoploss_space()
return spaces
@staticmethod
@@ -361,63 +234,26 @@ class Hyperopt(Backtesting):
"""
conditions = []
# GUARDS AND TRENDS
- if 'uptrend_long_ema' in params and params['uptrend_long_ema']['enabled']:
- conditions.append(dataframe['ema50'] > dataframe['ema100'])
- if 'macd_below_zero' in params and params['macd_below_zero']['enabled']:
- conditions.append(dataframe['macd'] < 0)
- if 'uptrend_short_ema' in params and params['uptrend_short_ema']['enabled']:
- conditions.append(dataframe['ema5'] > dataframe['ema10'])
- if 'mfi' in params and params['mfi']['enabled']:
- conditions.append(dataframe['mfi'] < params['mfi']['value'])
- if 'fastd' in params and params['fastd']['enabled']:
- conditions.append(dataframe['fastd'] < params['fastd']['value'])
- if 'adx' in params and params['adx']['enabled']:
- conditions.append(dataframe['adx'] > params['adx']['value'])
- if 'rsi' in params and params['rsi']['enabled']:
- conditions.append(dataframe['rsi'] < params['rsi']['value'])
- if 'over_sar' in params and params['over_sar']['enabled']:
- conditions.append(dataframe['close'] > dataframe['sar'])
- if 'green_candle' in params and params['green_candle']['enabled']:
- conditions.append(dataframe['close'] > dataframe['open'])
- if 'uptrend_sma' in params and params['uptrend_sma']['enabled']:
- prevsma = dataframe['sma'].shift(1)
- conditions.append(dataframe['sma'] > prevsma)
+ if 'mfi-enabled' in params and params['mfi-enabled']:
+ conditions.append(dataframe['mfi'] < params['mfi-value'])
+ if 'fastd-enabled' in params and params['fastd-enabled']:
+ conditions.append(dataframe['fastd'] < params['fastd-value'])
+ if 'adx-enabled' in params and params['adx-enabled']:
+ conditions.append(dataframe['adx'] > params['adx-value'])
+ if 'rsi-enabled' in params and params['rsi-enabled']:
+ conditions.append(dataframe['rsi'] < params['rsi-value'])
# TRIGGERS
- triggers = {
- 'lower_bb': (
- dataframe['close'] < dataframe['bb_lowerband']
- ),
- 'lower_bb_tema': (
- dataframe['tema'] < dataframe['bb_lowerband']
- ),
- 'faststoch10': (qtpylib.crossed_above(
- dataframe['fastd'], 10.0
- )),
- 'ao_cross_zero': (qtpylib.crossed_above(
- dataframe['ao'], 0.0
- )),
- 'ema3_cross_ema10': (qtpylib.crossed_above(
- dataframe['ema3'], dataframe['ema10']
- )),
- 'macd_cross_signal': (qtpylib.crossed_above(
+ if params['trigger'] == 'bb_lower':
+ conditions.append(dataframe['close'] < dataframe['bb_lowerband'])
+ if params['trigger'] == 'macd_cross_signal':
+ conditions.append(qtpylib.crossed_above(
dataframe['macd'], dataframe['macdsignal']
- )),
- 'sar_reversal': (qtpylib.crossed_above(
+ ))
+ if params['trigger'] == 'sar_reversal':
+ conditions.append(qtpylib.crossed_above(
dataframe['close'], dataframe['sar']
- )),
- 'ht_sine': (qtpylib.crossed_above(
- dataframe['htleadsine'], dataframe['htsine']
- )),
- 'heiken_reversal_bull': (
- (qtpylib.crossed_above(dataframe['ha_close'], dataframe['ha_open'])) &
- (dataframe['ha_low'] == dataframe['ha_open'])
- ),
- 'di_cross': (qtpylib.crossed_above(
- dataframe['plus_di'], dataframe['minus_di']
- )),
- }
- conditions.append(triggers.get(params['trigger']['type']))
+ ))
dataframe.loc[
reduce(lambda x, y: x & y, conditions),
@@ -427,7 +263,9 @@ class Hyperopt(Backtesting):
return populate_buy_trend
- def generate_optimizer(self, params: Dict) -> Dict:
+ def generate_optimizer(self, _params) -> Dict:
+ params = self.get_args(_params)
+
if self.has_space('roi'):
self.analyze.strategy.minimal_roi = self.generate_roi_table(params)
@@ -437,10 +275,11 @@ class Hyperopt(Backtesting):
if self.has_space('stoploss'):
self.analyze.strategy.stoploss = params['stoploss']
+ processed = load(TICKERDATA_PICKLE)
results = self.backtest(
{
'stake_amount': self.config['stake_amount'],
- 'processed': self.processed,
+ 'processed': processed,
'realistic': self.config.get('realistic_simulation', False),
}
)
@@ -450,30 +289,18 @@ class Hyperopt(Backtesting):
trade_count = len(results.index)
trade_duration = results.trade_duration.mean()
- if trade_count == 0 or trade_duration > self.max_accepted_trade_duration:
- print('.', end='')
- sys.stdout.flush()
+ if trade_count == 0:
return {
- 'status': STATUS_FAIL,
- 'loss': float('inf')
+ 'loss': MAX_LOSS,
+ 'params': params,
+ 'result': result_explanation,
}
loss = self.calculate_loss(total_profit, trade_count, trade_duration)
- self.current_tries += 1
-
- self.log_results(
- {
- 'loss': loss,
- 'current_tries': self.current_tries,
- 'total_tries': self.total_tries,
- 'result': result_explanation,
- }
- )
-
return {
'loss': loss,
- 'status': STATUS_OK,
+ 'params': params,
'result': result_explanation,
}
@@ -481,15 +308,37 @@ class Hyperopt(Backtesting):
"""
Return the format result in a string
"""
- return ('{:6d} trades. Avg profit {: 5.2f}%. '
- 'Total profit {: 11.8f} {} ({:.4f}Σ%). Avg duration {:5.1f} mins.').format(
- len(results.index),
- results.profit_percent.mean() * 100.0,
- results.profit_abs.sum(),
- self.config['stake_currency'],
- results.profit_percent.sum(),
- results.trade_duration.mean(),
- )
+ trades = len(results.index)
+ avg_profit = results.profit_percent.mean() * 100.0
+ total_profit = results.profit_abs.sum()
+ stake_cur = self.config['stake_currency']
+ profit = results.profit_percent.sum()
+ duration = results.trade_duration.mean()
+
+ return (f'{trades:6d} trades. Avg profit {avg_profit: 5.2f}%. '
+ f'Total profit {total_profit: 11.8f} {stake_cur} '
+ f'({profit:.4f}Σ%). Avg duration {duration:5.1f} mins.')
+
+ def get_optimizer(self, cpu_count) -> Optimizer:
+ return Optimizer(
+ self.hyperopt_space(),
+ base_estimator="ET",
+ acq_optimizer="auto",
+ n_initial_points=30,
+ acq_optimizer_kwargs={'n_jobs': cpu_count}
+ )
+
+ def run_optimizer_parallel(self, parallel, asked) -> List:
+ return parallel(delayed(self.generate_optimizer)(v) for v in asked)
+
+ def load_previous_results(self):
+ """ read trials file if we have one """
+ if os.path.exists(self.trials_file) and os.path.getsize(self.trials_file) > 0:
+ self.trials = self.read_trials()
+ logger.info(
+ 'Loaded %d previous evaluations from disk.',
+ len(self.trials)
+ )
def start(self) -> None:
timerange = Arguments.parse_timerange(None if self.config.get(
@@ -503,67 +352,35 @@ class Hyperopt(Backtesting):
if self.has_space('buy'):
self.analyze.populate_indicators = Hyperopt.populate_indicators # type: ignore
- self.processed = self.tickerdata_to_dataframe(data)
+ dump(self.tickerdata_to_dataframe(data), TICKERDATA_PICKLE)
+ self.exchange = None # type: ignore
+ self.load_previous_results()
- logger.info('Preparing Trials..')
- signal.signal(signal.SIGINT, self.signal_handler)
- # read trials file if we have one
- if os.path.exists(self.trials_file) and os.path.getsize(self.trials_file) > 0:
- self.trials = self.read_trials()
-
- self.current_tries = len(self.trials.results)
- self.total_tries += self.current_tries
- logger.info(
- 'Continuing with trials. Current: %d, Total: %d',
- self.current_tries,
- self.total_tries
- )
+ cpus = multiprocessing.cpu_count()
+ logger.info(f'Found {cpus} CPU cores. Let\'s make them scream!')
+ opt = self.get_optimizer(cpus)
+ EVALS = max(self.total_tries//cpus, 1)
try:
- best_parameters = fmin(
- fn=self.generate_optimizer,
- space=self.hyperopt_space(),
- algo=tpe.suggest,
- max_evals=self.total_tries,
- trials=self.trials
- )
+ with Parallel(n_jobs=cpus) as parallel:
+ for i in range(EVALS):
+ asked = opt.ask(n_points=cpus)
+ f_val = self.run_optimizer_parallel(parallel, asked)
+ opt.tell(asked, [i['loss'] for i in f_val])
- results = sorted(self.trials.results, key=itemgetter('loss'))
- best_result = results[0]['result']
-
- except ValueError:
- best_parameters = {}
- best_result = 'Sorry, Hyperopt was not able to find good parameters. Please ' \
- 'try with more epochs (param: -e).'
-
- # Improve best parameter logging display
- if best_parameters:
- best_parameters = space_eval(
- self.hyperopt_space(),
- best_parameters
- )
-
- logger.info('Best parameters:\n%s', json.dumps(best_parameters, indent=4))
- if 'roi_t1' in best_parameters:
- logger.info('ROI table:\n%s', self.generate_roi_table(best_parameters))
-
- logger.info('Best Result:\n%s', best_result)
-
- # Store trials result to file to resume next time
- self.save_trials()
-
- def signal_handler(self, sig, frame) -> None:
- """
- Hyperopt SIGINT handler
- """
- logger.info(
- 'Hyperopt received %s',
- signal.Signals(sig).name
- )
+ self.trials += f_val
+ for j in range(cpus):
+ self.log_results({
+ 'loss': f_val[j]['loss'],
+ 'current_tries': i * cpus + j,
+ 'total_tries': self.total_tries,
+ 'result': f_val[j]['result'],
+ })
+ except KeyboardInterrupt:
+ print('User interrupted..')
self.save_trials()
self.log_trials_result()
- sys.exit(0)
def start(args: Namespace) -> None:
diff --git a/freqtrade/persistence.py b/freqtrade/persistence.py
index 20a7db4bb..0e0b22e82 100644
--- a/freqtrade/persistence.py
+++ b/freqtrade/persistence.py
@@ -5,12 +5,11 @@ This module contains the class to persist trades into SQLite
import logging
from datetime import datetime
from decimal import Decimal, getcontext
-from typing import Dict, Optional, Any
+from typing import Any, Dict, Optional
import arrow
from sqlalchemy import (Boolean, Column, DateTime, Float, Integer, String,
- create_engine)
-from sqlalchemy import inspect
+ create_engine, inspect)
from sqlalchemy.exc import NoSuchModuleError
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm.scoping import scoped_session
@@ -22,6 +21,7 @@ from freqtrade import OperationalException
logger = logging.getLogger(__name__)
_DECL_BASE: Any = declarative_base()
+_SQL_DOCS_URL = 'http://docs.sqlalchemy.org/en/latest/core/engines.html#database-urls'
def init(config: Dict) -> None:
@@ -46,10 +46,8 @@ def init(config: Dict) -> None:
try:
engine = create_engine(db_url, **kwargs)
except NoSuchModuleError:
- error = 'Given value for db_url: \'{}\' is no valid database URL! (See {}).'.format(
- db_url, 'http://docs.sqlalchemy.org/en/latest/core/engines.html#database-urls'
- )
- raise OperationalException(error)
+ raise OperationalException(f'Given value for db_url: \'{db_url}\' '
+ f'is no valid database URL! (See {_SQL_DOCS_URL})')
session = scoped_session(sessionmaker(bind=engine, autoflush=True, autocommit=True))
Trade.session = session()
@@ -66,6 +64,10 @@ def has_column(columns, searchname: str) -> bool:
return len(list(filter(lambda x: x["name"] == searchname, columns))) == 1
+def get_column_def(columns, column: str, default: str) -> str:
+ return default if not has_column(columns, column) else column
+
+
def check_migrate(engine) -> None:
"""
Checks if migration is necessary and migrates if necessary
@@ -73,18 +75,32 @@ def check_migrate(engine) -> None:
inspector = inspect(engine)
cols = inspector.get_columns('trades')
+ tabs = inspector.get_table_names()
+ table_back_name = 'trades_bak'
+ for i, table_back_name in enumerate(tabs):
+ table_back_name = f'trades_bak{i}'
+ logger.info(f'trying {table_back_name}')
+
+ # Check for latest column
+ if not has_column(cols, 'max_rate'):
+ open_rate_requested = get_column_def(cols, 'open_rate_requested', 'null')
+ close_rate_requested = get_column_def(cols, 'close_rate_requested', 'null')
+ stop_loss = get_column_def(cols, 'stop_loss', '0.0')
+ initial_stop_loss = get_column_def(cols, 'initial_stop_loss', '0.0')
+ max_rate = get_column_def(cols, 'max_rate', '0.0')
- if not has_column(cols, 'fee_open'):
# Schema migration necessary
- engine.execute("alter table trades rename to trades_bak")
+ engine.execute(f"alter table trades rename to {table_back_name}")
# let SQLAlchemy create the schema as required
_DECL_BASE.metadata.create_all(engine)
# Copy data back - following the correct schema
- engine.execute("""insert into trades
+ engine.execute(f"""insert into trades
(id, exchange, pair, is_open, fee_open, fee_close, open_rate,
open_rate_requested, close_rate, close_rate_requested, close_profit,
- stake_amount, amount, open_date, close_date, open_order_id)
+ stake_amount, amount, open_date, close_date, open_order_id,
+ stop_loss, initial_stop_loss, max_rate
+ )
select id, lower(exchange),
case
when instr(pair, '_') != 0 then
@@ -94,21 +110,18 @@ def check_migrate(engine) -> None:
end
pair,
is_open, fee fee_open, fee fee_close,
- open_rate, null open_rate_requested, close_rate,
- null close_rate_requested, close_profit,
- stake_amount, amount, open_date, close_date, open_order_id
- from trades_bak
+ open_rate, {open_rate_requested} open_rate_requested, close_rate,
+ {close_rate_requested} close_rate_requested, close_profit,
+ stake_amount, amount, open_date, close_date, open_order_id,
+ {stop_loss} stop_loss, {initial_stop_loss} initial_stop_loss,
+ {max_rate} max_rate
+ from {table_back_name}
""")
# Reread columns - the above recreated the table!
inspector = inspect(engine)
cols = inspector.get_columns('trades')
- if not has_column(cols, 'open_rate_requested'):
- engine.execute("alter table trades add open_rate_requested float")
- if not has_column(cols, 'close_rate_requested'):
- engine.execute("alter table trades add close_rate_requested float")
-
def cleanup() -> None:
"""
@@ -151,15 +164,57 @@ class Trade(_DECL_BASE):
open_date = Column(DateTime, nullable=False, default=datetime.utcnow)
close_date = Column(DateTime)
open_order_id = Column(String)
+ # absolute value of the stop loss
+ stop_loss = Column(Float, nullable=True, default=0.0)
+ # absolute value of the initial stop loss
+ initial_stop_loss = Column(Float, nullable=True, default=0.0)
+ # absolute value of the highest reached price
+ max_rate = Column(Float, nullable=True, default=0.0)
def __repr__(self):
- return 'Trade(id={}, pair={}, amount={:.8f}, open_rate={:.8f}, open_since={})'.format(
- self.id,
- self.pair,
- self.amount,
- self.open_rate,
- arrow.get(self.open_date).humanize() if self.is_open else 'closed'
- )
+ open_since = arrow.get(self.open_date).humanize() if self.is_open else 'closed'
+
+ return (f'Trade(id={self.id}, pair={self.pair}, amount={self.amount:.8f}, '
+ f'open_rate={self.open_rate:.8f}, open_since={open_since})')
+
+ def adjust_stop_loss(self, current_price: float, stoploss: float, initial: bool = False):
+ """this adjusts the stop loss to it's most recently observed setting"""
+
+ if initial and not (self.stop_loss is None or self.stop_loss == 0):
+ # Don't modify if called with initial and nothing to do
+ return
+
+ new_loss = float(current_price * (1 - abs(stoploss)))
+
+ # keeping track of the highest observed rate for this trade
+ if self.max_rate is None:
+ self.max_rate = current_price
+ else:
+ if current_price > self.max_rate:
+ self.max_rate = current_price
+
+ # no stop loss assigned yet
+ if not self.stop_loss:
+ logger.debug("assigning new stop loss")
+ self.stop_loss = new_loss
+ self.initial_stop_loss = new_loss
+
+ # evaluate if the stop loss needs to be updated
+ else:
+ if new_loss > self.stop_loss: # stop losses only walk up, never down!
+ self.stop_loss = new_loss
+ logger.debug("adjusted stop loss")
+ else:
+ logger.debug("keeping current stop loss")
+
+ logger.debug(
+ f"{self.pair} - current price {current_price:.8f}, "
+ f"bought at {self.open_rate:.8f} and calculated "
+ f"stop loss is at: {self.initial_stop_loss:.8f} initial "
+ f"stop at {self.stop_loss:.8f}. "
+ f"trailing stop loss saved us: "
+ f"{float(self.stop_loss) - float(self.initial_stop_loss):.8f} "
+ f"and max observed rate was {self.max_rate:.8f}")
def update(self, order: Dict) -> None:
"""
@@ -167,6 +222,7 @@ class Trade(_DECL_BASE):
:param order: order retrieved by exchange.get_order()
:return: None
"""
+ order_type = order['type']
# Ignore open and cancelled orders
if order['status'] == 'open' or order['price'] is None:
return
@@ -174,16 +230,16 @@ class Trade(_DECL_BASE):
logger.info('Updating trade (id=%d) ...', self.id)
getcontext().prec = 8 # Bittrex do not go above 8 decimal
- if order['type'] == 'limit' and order['side'] == 'buy':
+ if order_type == 'limit' and order['side'] == 'buy':
# Update open rate and actual amount
self.open_rate = Decimal(order['price'])
self.amount = Decimal(order['amount'])
logger.info('LIMIT_BUY has been fulfilled for %s.', self)
self.open_order_id = None
- elif order['type'] == 'limit' and order['side'] == 'sell':
+ elif order_type == 'limit' and order['side'] == 'sell':
self.close(order['price'])
else:
- raise ValueError('Unknown order type: {}'.format(order['type']))
+ raise ValueError(f'Unknown order type: {order_type}')
cleanup()
def close(self, rate: float) -> None:
@@ -254,7 +310,8 @@ class Trade(_DECL_BASE):
rate=(rate or self.close_rate),
fee=(fee or self.fee_close)
)
- return float("{0:.8f}".format(close_trade_price - open_trade_price))
+ profit = close_trade_price - open_trade_price
+ return float(f"{profit:.8f}")
def calc_profit_percent(
self,
@@ -274,5 +331,5 @@ class Trade(_DECL_BASE):
rate=(rate or self.close_rate),
fee=(fee or self.fee_close)
)
-
- return float("{0:.8f}".format((close_trade_price / open_trade_price) - 1))
+ profit_percent = (close_trade_price / open_trade_price) - 1
+ return float(f"{profit_percent:.8f}")
diff --git a/freqtrade/rpc/rpc.py b/freqtrade/rpc/rpc.py
index ee6ecb770..11658c6fb 100644
--- a/freqtrade/rpc/rpc.py
+++ b/freqtrade/rpc/rpc.py
@@ -3,9 +3,9 @@ This module contains class to define a RPC communications
"""
import logging
from abc import abstractmethod
-from datetime import datetime, timedelta, date
+from datetime import date, datetime, timedelta
from decimal import Decimal
-from typing import Dict, Tuple, Any, List
+from typing import Any, Dict, List, Tuple
import arrow
import sqlalchemy as sql
@@ -74,34 +74,32 @@ class RPC(object):
# calculate profit and send message to user
current_rate = self._freqtrade.exchange.get_ticker(trade.pair, False)['bid']
current_profit = trade.calc_profit_percent(current_rate)
- fmt_close_profit = '{:.2f}%'.format(
- round(trade.close_profit * 100, 2)
- ) if trade.close_profit else None
- message = "*Trade ID:* `{trade_id}`\n" \
- "*Current Pair:* [{pair}]({market_url})\n" \
- "*Open Since:* `{date}`\n" \
- "*Amount:* `{amount}`\n" \
- "*Open Rate:* `{open_rate:.8f}`\n" \
- "*Close Rate:* `{close_rate}`\n" \
- "*Current Rate:* `{current_rate:.8f}`\n" \
- "*Close Profit:* `{close_profit}`\n" \
- "*Current Profit:* `{current_profit:.2f}%`\n" \
- "*Open Order:* `{open_order}`"\
- .format(
- trade_id=trade.id,
- pair=trade.pair,
- market_url=self._freqtrade.exchange.get_pair_detail_url(trade.pair),
- date=arrow.get(trade.open_date).humanize(),
- open_rate=trade.open_rate,
- close_rate=trade.close_rate,
- current_rate=current_rate,
- amount=round(trade.amount, 8),
- close_profit=fmt_close_profit,
- current_profit=round(current_profit * 100, 2),
- open_order='({} {} rem={:.8f})'.format(
- order['type'], order['side'], order['remaining']
- ) if order else None,
- )
+ fmt_close_profit = (f'{round(trade.close_profit * 100, 2):.2f}%'
+ if trade.close_profit else None)
+ market_url = self._freqtrade.exchange.get_pair_detail_url(trade.pair)
+ trade_date = arrow.get(trade.open_date).humanize()
+ open_rate = trade.open_rate
+ close_rate = trade.close_rate
+ amount = round(trade.amount, 8)
+ current_profit = round(current_profit * 100, 2)
+ open_order = ''
+ if order:
+ order_type = order['type']
+ order_side = order['side']
+ order_rem = order['remaining']
+ open_order = f'({order_type} {order_side} rem={order_rem:.8f})'
+
+ message = f"*Trade ID:* `{trade.id}`\n" \
+ f"*Current Pair:* [{trade.pair}]({market_url})\n" \
+ f"*Open Since:* `{trade_date}`\n" \
+ f"*Amount:* `{amount}`\n" \
+ f"*Open Rate:* `{open_rate:.8f}`\n" \
+ f"*Close Rate:* `{close_rate}`\n" \
+ f"*Current Rate:* `{current_rate:.8f}`\n" \
+ f"*Close Profit:* `{fmt_close_profit}`\n" \
+ f"*Current Profit:* `{current_profit:.2f}%`\n" \
+ f"*Open Order:* `{open_order}`"\
+
result.append(message)
return result
@@ -116,11 +114,12 @@ class RPC(object):
for trade in trades:
# calculate profit and send message to user
current_rate = self._freqtrade.exchange.get_ticker(trade.pair, False)['bid']
+ trade_perc = (100 * trade.calc_profit_percent(current_rate))
trades_list.append([
trade.id,
trade.pair,
shorten_date(arrow.get(trade.open_date).humanize(only_distance=True)),
- '{:.2f}%'.format(100 * trade.calc_profit_percent(current_rate))
+ f'{trade_perc:.2f}%'
])
columns = ['ID', 'Pair', 'Since', 'Profit']
@@ -148,7 +147,7 @@ class RPC(object):
.all()
curdayprofit = sum(trade.calc_profit() for trade in trades)
profit_days[profitday] = {
- 'amount': format(curdayprofit, '.8f'),
+ 'amount': f'{curdayprofit:.8f}',
'trades': len(trades)
}
diff --git a/freqtrade/rpc/telegram.py b/freqtrade/rpc/telegram.py
index 4dd23971b..13a2b1913 100644
--- a/freqtrade/rpc/telegram.py
+++ b/freqtrade/rpc/telegram.py
@@ -153,7 +153,7 @@ class Telegram(RPC):
try:
df_statuses = self._rpc_status_table()
message = tabulate(df_statuses, headers='keys', tablefmt='simple')
- self._send_msg("{}".format(message), parse_mode=ParseMode.HTML)
+ self._send_msg(f"{message}", parse_mode=ParseMode.HTML)
except RPCException as e:
self._send_msg(str(e), bot=bot)
@@ -166,6 +166,8 @@ class Telegram(RPC):
:param update: message update
:return: None
"""
+ stake_cur = self._config['stake_currency']
+ fiat_disp_cur = self._config['fiat_display_currency']
try:
timescale = int(update.message.text.replace('/daily', '').strip())
except (TypeError, ValueError):
@@ -173,18 +175,17 @@ class Telegram(RPC):
try:
stats = self._rpc_daily_profit(
timescale,
- self._config['stake_currency'],
- self._config['fiat_display_currency']
+ stake_cur,
+ fiat_disp_cur
)
stats = tabulate(stats,
headers=[
'Day',
- 'Profit {}'.format(self._config['stake_currency']),
- 'Profit {}'.format(self._config['fiat_display_currency'])
+ f'Profit {stake_cur}',
+ f'Profit {fiat_disp_cur}'
],
tablefmt='simple')
- message = 'Daily Profit over the last {} days:\n{}'\
- .format(timescale, stats)
+ message = f'Daily Profit over the last {timescale} days:\n{stats}'
self._send_msg(message, bot=bot, parse_mode=ParseMode.HTML)
except RPCException as e:
self._send_msg(str(e), bot=bot)
@@ -198,39 +199,38 @@ class Telegram(RPC):
:param update: message update
:return: None
"""
+ stake_cur = self._config['stake_currency']
+ fiat_disp_cur = self._config['fiat_display_currency']
+
try:
stats = self._rpc_trade_statistics(
- self._config['stake_currency'],
- self._config['fiat_display_currency'])
-
+ stake_cur,
+ fiat_disp_cur)
+ profit_closed_coin = stats['profit_closed_coin']
+ profit_closed_percent = stats['profit_closed_percent']
+ profit_closed_fiat = stats['profit_closed_fiat']
+ profit_all_coin = stats['profit_all_coin']
+ profit_all_percent = stats['profit_all_percent']
+ profit_all_fiat = stats['profit_all_fiat']
+ trade_count = stats['trade_count']
+ first_trade_date = stats['first_trade_date']
+ latest_trade_date = stats['latest_trade_date']
+ avg_duration = stats['avg_duration']
+ best_pair = stats['best_pair']
+ best_rate = stats['best_rate']
# Message to display
markdown_msg = "*ROI:* Close trades\n" \
- "∙ `{profit_closed_coin:.8f} {coin} ({profit_closed_percent:.2f}%)`\n" \
- "∙ `{profit_closed_fiat:.3f} {fiat}`\n" \
- "*ROI:* All trades\n" \
- "∙ `{profit_all_coin:.8f} {coin} ({profit_all_percent:.2f}%)`\n" \
- "∙ `{profit_all_fiat:.3f} {fiat}`\n" \
- "*Total Trade Count:* `{trade_count}`\n" \
- "*First Trade opened:* `{first_trade_date}`\n" \
- "*Latest Trade opened:* `{latest_trade_date}`\n" \
- "*Avg. Duration:* `{avg_duration}`\n" \
- "*Best Performing:* `{best_pair}: {best_rate:.2f}%`"\
- .format(
- coin=self._config['stake_currency'],
- fiat=self._config['fiat_display_currency'],
- profit_closed_coin=stats['profit_closed_coin'],
- profit_closed_percent=stats['profit_closed_percent'],
- profit_closed_fiat=stats['profit_closed_fiat'],
- profit_all_coin=stats['profit_all_coin'],
- profit_all_percent=stats['profit_all_percent'],
- profit_all_fiat=stats['profit_all_fiat'],
- trade_count=stats['trade_count'],
- first_trade_date=stats['first_trade_date'],
- latest_trade_date=stats['latest_trade_date'],
- avg_duration=stats['avg_duration'],
- best_pair=stats['best_pair'],
- best_rate=stats['best_rate']
- )
+ f"∙ `{profit_closed_coin:.8f} {stake_cur} "\
+ f"({profit_closed_percent:.2f}%)`\n" \
+ f"∙ `{profit_closed_fiat:.3f} {fiat_disp_cur}`\n" \
+ f"*ROI:* All trades\n" \
+ f"∙ `{profit_all_coin:.8f} {stake_cur} ({profit_all_percent:.2f}%)`\n" \
+ f"∙ `{profit_all_fiat:.3f} {fiat_disp_cur}`\n" \
+ f"*Total Trade Count:* `{trade_count}`\n" \
+ f"*First Trade opened:* `{first_trade_date}`\n" \
+ f"*Latest Trade opened:* `{latest_trade_date}`\n" \
+ f"*Avg. Duration:* `{avg_duration}`\n" \
+ f"*Best Performing:* `{best_pair}: {best_rate:.2f}%`"
self._send_msg(markdown_msg, bot=bot)
except RPCException as e:
self._send_msg(str(e), bot=bot)
diff --git a/freqtrade/strategy/interface.py b/freqtrade/strategy/interface.py
index 4ae358c6f..f73617f46 100644
--- a/freqtrade/strategy/interface.py
+++ b/freqtrade/strategy/interface.py
@@ -2,8 +2,8 @@
IStrategy interface
This module defines the interface to apply for strategies
"""
-from typing import Dict
from abc import ABC, abstractmethod
+from typing import Dict
from pandas import DataFrame
diff --git a/freqtrade/strategy/resolver.py b/freqtrade/strategy/resolver.py
index 46f70ccc9..25eb81888 100644
--- a/freqtrade/strategy/resolver.py
+++ b/freqtrade/strategy/resolver.py
@@ -8,7 +8,7 @@ import inspect
import logging
from base64 import urlsafe_b64decode
from collections import OrderedDict
-from typing import Optional, Dict, Type
+from typing import Dict, Optional, Type
from freqtrade import constants
from freqtrade.strategy import import_strategy
@@ -17,6 +17,7 @@ import tempfile
import os
from pathlib import Path
+
logger = logging.getLogger(__name__)
@@ -82,8 +83,8 @@ class StrategyResolver(object):
# Add extra strategy directory on top of search paths
abs_paths.insert(0, extra_dir)
- if ":" in strategy_name and "http" not in strategy_name:
- print("loading none http based strategy: {}".format(strategy_name))
+ if ":" in strategy_name:
+ logger.debug(("loading base64 endocded strategy".)
strat = strategy_name.split(":")
if len(strat) == 2:
diff --git a/freqtrade/tests/conftest.py b/freqtrade/tests/conftest.py
index d9ccaa325..9c86d1ece 100644
--- a/freqtrade/tests/conftest.py
+++ b/freqtrade/tests/conftest.py
@@ -2,8 +2,8 @@
import json
import logging
from datetime import datetime
-from typing import Dict, Optional
from functools import reduce
+from typing import Dict, Optional
from unittest.mock import MagicMock
import arrow
@@ -11,8 +11,8 @@ import pytest
from jsonschema import validate
from telegram import Chat, Message, Update
-from freqtrade.analyze import Analyze
from freqtrade import constants
+from freqtrade.analyze import Analyze
from freqtrade.exchange import Exchange
from freqtrade.freqtradebot import FreqtradeBot
@@ -100,7 +100,10 @@ def default_conf():
"0": 0.04
},
"stoploss": -0.10,
- "unfilledtimeout": 600,
+ "unfilledtimeout": {
+ "buy": 10,
+ "sell": 30
+ },
"bid_strategy": {
"ask_last_balance": 0.0
},
diff --git a/freqtrade/tests/exchange/test_exchange.py b/freqtrade/tests/exchange/test_exchange.py
index 53e59b34b..3ddec0ded 100644
--- a/freqtrade/tests/exchange/test_exchange.py
+++ b/freqtrade/tests/exchange/test_exchange.py
@@ -2,16 +2,32 @@
# pragma pylint: disable=protected-access
import logging
from copy import deepcopy
-from random import randint
from datetime import datetime
+from random import randint
from unittest.mock import MagicMock, PropertyMock
import ccxt
import pytest
-from freqtrade import OperationalException, DependencyException, TemporaryError
-from freqtrade.exchange import Exchange, API_RETRY_COUNT
-from freqtrade.tests.conftest import log_has, get_patched_exchange
+from freqtrade import DependencyException, OperationalException, TemporaryError
+from freqtrade.exchange import API_RETRY_COUNT, Exchange
+from freqtrade.tests.conftest import get_patched_exchange, log_has
+
+
+def ccxt_exceptionhandlers(mocker, default_conf, api_mock, fun, mock_ccxt_fun, **kwargs):
+ """Function to test ccxt exception handling """
+
+ with pytest.raises(TemporaryError):
+ api_mock.__dict__[mock_ccxt_fun] = MagicMock(side_effect=ccxt.NetworkError)
+ exchange = get_patched_exchange(mocker, default_conf, api_mock)
+ getattr(exchange, fun)(**kwargs)
+ assert api_mock.__dict__[mock_ccxt_fun].call_count == API_RETRY_COUNT + 1
+
+ with pytest.raises(OperationalException):
+ api_mock.__dict__[mock_ccxt_fun] = MagicMock(side_effect=ccxt.BaseError)
+ exchange = get_patched_exchange(mocker, default_conf, api_mock)
+ getattr(exchange, fun)(**kwargs)
+ assert api_mock.__dict__[mock_ccxt_fun].call_count == 1
def test_init(default_conf, mocker, caplog):
@@ -20,7 +36,7 @@ def test_init(default_conf, mocker, caplog):
assert log_has('Instance is running with dry_run enabled', caplog.record_tuples)
-def test_init_exception(default_conf):
+def test_init_exception(default_conf, mocker):
default_conf['exchange']['name'] = 'wrong_exchange_name'
with pytest.raises(
@@ -28,6 +44,13 @@ def test_init_exception(default_conf):
match='Exchange {} is not supported'.format(default_conf['exchange']['name'])):
Exchange(default_conf)
+ default_conf['exchange']['name'] = 'binance'
+ with pytest.raises(
+ OperationalException,
+ match='Exchange {} is not supported'.format(default_conf['exchange']['name'])):
+ mocker.patch("ccxt.binance", MagicMock(side_effect=AttributeError))
+ Exchange(default_conf)
+
def test_validate_pairs(default_conf, mocker):
api_mock = MagicMock()
@@ -97,6 +120,20 @@ def test_validate_pairs_stake_exception(default_conf, mocker, caplog):
Exchange(conf)
+def test_exchangehas(default_conf, mocker):
+ exchange = get_patched_exchange(mocker, default_conf)
+ assert not exchange.exchange_has('ASDFASDF')
+ api_mock = MagicMock()
+
+ type(api_mock).has = PropertyMock(return_value={'deadbeef': True})
+ exchange = get_patched_exchange(mocker, default_conf, api_mock)
+ assert exchange.exchange_has("deadbeef")
+
+ type(api_mock).has = PropertyMock(return_value={'deadbeef': False})
+ exchange = get_patched_exchange(mocker, default_conf, api_mock)
+ assert not exchange.exchange_has("deadbeef")
+
+
def test_buy_dry_run(default_conf, mocker):
default_conf['dry_run'] = True
exchange = get_patched_exchange(mocker, default_conf)
@@ -216,6 +253,11 @@ def test_get_balance_prod(default_conf, mocker):
exchange.get_balance(currency='BTC')
+ with pytest.raises(TemporaryError, match=r'.*balance due to malformed exchange response:.*'):
+ exchange = get_patched_exchange(mocker, default_conf, api_mock)
+ mocker.patch('freqtrade.exchange.Exchange.get_balances', MagicMock(return_value={}))
+ exchange.get_balance(currency='BTC')
+
def test_get_balances_dry_run(default_conf, mocker):
default_conf['dry_run'] = True
@@ -243,17 +285,8 @@ def test_get_balances_prod(default_conf, mocker):
assert exchange.get_balances()['1ST']['total'] == 10.0
assert exchange.get_balances()['1ST']['used'] == 0.0
- with pytest.raises(TemporaryError):
- api_mock.fetch_balance = MagicMock(side_effect=ccxt.NetworkError)
- exchange = get_patched_exchange(mocker, default_conf, api_mock)
- exchange.get_balances()
- assert api_mock.fetch_balance.call_count == API_RETRY_COUNT + 1
-
- with pytest.raises(OperationalException):
- api_mock.fetch_balance = MagicMock(side_effect=ccxt.BaseError)
- exchange = get_patched_exchange(mocker, default_conf, api_mock)
- exchange.get_balances()
- assert api_mock.fetch_balance.call_count == 1
+ ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+ "get_balances", "fetch_balance")
def test_get_tickers(default_conf, mocker):
@@ -282,15 +315,8 @@ def test_get_tickers(default_conf, mocker):
assert tickers['BCH/BTC']['bid'] == 0.6
assert tickers['BCH/BTC']['ask'] == 0.5
- with pytest.raises(TemporaryError): # test retrier
- api_mock.fetch_tickers = MagicMock(side_effect=ccxt.NetworkError)
- exchange = get_patched_exchange(mocker, default_conf, api_mock)
- exchange.get_tickers()
-
- with pytest.raises(OperationalException):
- api_mock.fetch_tickers = MagicMock(side_effect=ccxt.BaseError)
- exchange = get_patched_exchange(mocker, default_conf, api_mock)
- exchange.get_tickers()
+ ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+ "get_tickers", "fetch_tickers")
with pytest.raises(OperationalException):
api_mock.fetch_tickers = MagicMock(side_effect=ccxt.NotSupported)
@@ -345,15 +371,9 @@ def test_get_ticker(default_conf, mocker):
exchange.get_ticker(pair='ETH/BTC', refresh=False)
assert api_mock.fetch_ticker.call_count == 0
- with pytest.raises(TemporaryError): # test retrier
- api_mock.fetch_ticker = MagicMock(side_effect=ccxt.NetworkError)
- exchange = get_patched_exchange(mocker, default_conf, api_mock)
- exchange.get_ticker(pair='ETH/BTC', refresh=True)
-
- with pytest.raises(OperationalException):
- api_mock.fetch_ticker = MagicMock(side_effect=ccxt.BaseError)
- exchange = get_patched_exchange(mocker, default_conf, api_mock)
- exchange.get_ticker(pair='ETH/BTC', refresh=True)
+ ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+ "get_ticker", "fetch_ticker",
+ pair='ETH/BTC', refresh=True)
api_mock.fetch_ticker = MagicMock(return_value={})
exchange = get_patched_exchange(mocker, default_conf, api_mock)
@@ -416,17 +436,14 @@ def test_get_ticker_history(default_conf, mocker):
assert ticks[0][4] == 9
assert ticks[0][5] == 10
- with pytest.raises(TemporaryError): # test retrier
- api_mock.fetch_ohlcv = MagicMock(side_effect=ccxt.NetworkError)
- exchange = get_patched_exchange(mocker, default_conf, api_mock)
- # new symbol to get around cache
- exchange.get_ticker_history('ABCD/BTC', default_conf['ticker_interval'])
+ ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+ "get_ticker_history", "fetch_ohlcv",
+ pair='ABCD/BTC', tick_interval=default_conf['ticker_interval'])
- with pytest.raises(OperationalException):
- api_mock.fetch_ohlcv = MagicMock(side_effect=ccxt.BaseError)
+ with pytest.raises(OperationalException, match=r'Exchange .* does not support.*'):
+ api_mock.fetch_ohlcv = MagicMock(side_effect=ccxt.NotSupported)
exchange = get_patched_exchange(mocker, default_conf, api_mock)
- # new symbol to get around cache
- exchange.get_ticker_history('EFGH/BTC', default_conf['ticker_interval'])
+ exchange.get_ticker_history(pair='ABCD/BTC', tick_interval=default_conf['ticker_interval'])
def test_get_ticker_history_sort(default_conf, mocker):
@@ -515,24 +532,15 @@ def test_cancel_order(default_conf, mocker):
exchange = get_patched_exchange(mocker, default_conf, api_mock)
assert exchange.cancel_order(order_id='_', pair='TKN/BTC') == 123
- with pytest.raises(TemporaryError):
- api_mock.cancel_order = MagicMock(side_effect=ccxt.NetworkError)
-
- exchange = get_patched_exchange(mocker, default_conf, api_mock)
- exchange.cancel_order(order_id='_', pair='TKN/BTC')
- assert api_mock.cancel_order.call_count == API_RETRY_COUNT + 1
-
with pytest.raises(DependencyException):
api_mock.cancel_order = MagicMock(side_effect=ccxt.InvalidOrder)
exchange = get_patched_exchange(mocker, default_conf, api_mock)
exchange.cancel_order(order_id='_', pair='TKN/BTC')
assert api_mock.cancel_order.call_count == API_RETRY_COUNT + 1
- with pytest.raises(OperationalException):
- api_mock.cancel_order = MagicMock(side_effect=ccxt.BaseError)
- exchange = get_patched_exchange(mocker, default_conf, api_mock)
- exchange.cancel_order(order_id='_', pair='TKN/BTC')
- assert api_mock.cancel_order.call_count == 1
+ ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+ "cancel_order", "cancel_order",
+ order_id='_', pair='TKN/BTC')
def test_get_order(default_conf, mocker):
@@ -550,23 +558,15 @@ def test_get_order(default_conf, mocker):
exchange = get_patched_exchange(mocker, default_conf, api_mock)
assert exchange.get_order('X', 'TKN/BTC') == 456
- with pytest.raises(TemporaryError):
- api_mock.fetch_order = MagicMock(side_effect=ccxt.NetworkError)
- exchange = get_patched_exchange(mocker, default_conf, api_mock)
- exchange.get_order(order_id='_', pair='TKN/BTC')
- assert api_mock.fetch_order.call_count == API_RETRY_COUNT + 1
-
with pytest.raises(DependencyException):
api_mock.fetch_order = MagicMock(side_effect=ccxt.InvalidOrder)
exchange = get_patched_exchange(mocker, default_conf, api_mock)
exchange.get_order(order_id='_', pair='TKN/BTC')
assert api_mock.fetch_order.call_count == API_RETRY_COUNT + 1
- with pytest.raises(OperationalException):
- api_mock.fetch_order = MagicMock(side_effect=ccxt.BaseError)
- exchange = get_patched_exchange(mocker, default_conf, api_mock)
- exchange.get_order(order_id='_', pair='TKN/BTC')
- assert api_mock.fetch_order.call_count == 1
+ ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+ 'get_order', 'fetch_order',
+ order_id='_', pair='TKN/BTC')
def test_name(default_conf, mocker):
@@ -651,19 +651,12 @@ def test_get_trades_for_order(default_conf, mocker):
assert len(orders) == 1
assert orders[0]['price'] == 165
- # test Exceptions
- with pytest.raises(OperationalException):
- api_mock = MagicMock()
- api_mock.fetch_my_trades = MagicMock(side_effect=ccxt.BaseError)
- exchange = get_patched_exchange(mocker, default_conf, api_mock)
- exchange.get_trades_for_order(order_id, 'LTC/BTC', since)
+ ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+ 'get_trades_for_order', 'fetch_my_trades',
+ order_id=order_id, pair='LTC/BTC', since=since)
- with pytest.raises(TemporaryError):
- api_mock = MagicMock()
- api_mock.fetch_my_trades = MagicMock(side_effect=ccxt.NetworkError)
- exchange = get_patched_exchange(mocker, default_conf, api_mock)
- exchange.get_trades_for_order(order_id, 'LTC/BTC', since)
- assert api_mock.fetch_my_trades.call_count == API_RETRY_COUNT + 1
+ mocker.patch('freqtrade.exchange.Exchange.exchange_has', MagicMock(return_value=False))
+ assert exchange.get_trades_for_order(order_id, 'LTC/BTC', since) == []
def test_get_markets(default_conf, mocker, markets):
@@ -677,19 +670,8 @@ def test_get_markets(default_conf, mocker, markets):
assert ret[0]["id"] == "ethbtc"
assert ret[0]["symbol"] == "ETH/BTC"
- # test Exceptions
- with pytest.raises(OperationalException):
- api_mock = MagicMock()
- api_mock.fetch_markets = MagicMock(side_effect=ccxt.BaseError)
- exchange = get_patched_exchange(mocker, default_conf, api_mock)
- exchange.get_markets()
-
- with pytest.raises(TemporaryError):
- api_mock = MagicMock()
- api_mock.fetch_markets = MagicMock(side_effect=ccxt.NetworkError)
- exchange = get_patched_exchange(mocker, default_conf, api_mock)
- exchange.get_markets()
- assert api_mock.fetch_markets.call_count == API_RETRY_COUNT + 1
+ ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+ 'get_markets', 'fetch_markets')
def test_get_fee(default_conf, mocker):
@@ -704,19 +686,8 @@ def test_get_fee(default_conf, mocker):
assert exchange.get_fee() == 0.025
- # test Exceptions
- with pytest.raises(OperationalException):
- api_mock = MagicMock()
- api_mock.calculate_fee = MagicMock(side_effect=ccxt.BaseError)
- exchange = get_patched_exchange(mocker, default_conf, api_mock)
- exchange.get_fee()
-
- with pytest.raises(TemporaryError):
- api_mock = MagicMock()
- api_mock.calculate_fee = MagicMock(side_effect=ccxt.NetworkError)
- exchange = get_patched_exchange(mocker, default_conf, api_mock)
- exchange.get_fee()
- assert api_mock.calculate_fee.call_count == API_RETRY_COUNT + 1
+ ccxt_exceptionhandlers(mocker, default_conf, api_mock,
+ 'get_fee', 'calculate_fee')
def test_get_amount_lots(default_conf, mocker):
diff --git a/freqtrade/tests/optimize/test_backtesting.py b/freqtrade/tests/optimize/test_backtesting.py
index c3d2ad572..cb225e465 100644
--- a/freqtrade/tests/optimize/test_backtesting.py
+++ b/freqtrade/tests/optimize/test_backtesting.py
@@ -3,19 +3,20 @@
import json
import math
import random
-import pytest
from copy import deepcopy
from typing import List
from unittest.mock import MagicMock
import numpy as np
import pandas as pd
+import pytest
from arrow import Arrow
-from freqtrade import optimize, constants, DependencyException
+from freqtrade import DependencyException, constants, optimize
from freqtrade.analyze import Analyze
from freqtrade.arguments import Arguments, TimeRange
-from freqtrade.optimize.backtesting import Backtesting, start, setup_configuration
+from freqtrade.optimize.backtesting import (Backtesting, setup_configuration,
+ start)
from freqtrade.tests.conftest import log_has, patch_exchange
@@ -627,9 +628,13 @@ def test_backtest_record(default_conf, fee, mocker):
Arrow(2017, 11, 14, 22, 10, 00).datetime,
Arrow(2017, 11, 14, 22, 43, 00).datetime,
Arrow(2017, 11, 14, 22, 58, 00).datetime],
+ "open_rate": [0.002543, 0.003003, 0.003089, 0.003214],
+ "close_rate": [0.002546, 0.003014, 0.003103, 0.003217],
"open_index": [1, 119, 153, 185],
"close_index": [118, 151, 184, 199],
- "trade_duration": [123, 34, 31, 14]})
+ "trade_duration": [123, 34, 31, 14],
+ "open_at_end": [False, False, False, True]
+ })
backtesting._store_backtest_result("backtest-result.json", results)
assert len(results) == 4
# Assert file_dump_json was only called once
@@ -640,12 +645,16 @@ def test_backtest_record(default_conf, fee, mocker):
# ('UNITTEST/BTC', 0.00331158, '1510684320', '1510691700', 0, 117)
# Below follows just a typecheck of the schema/type of trade-records
oix = None
- for (pair, profit, date_buy, date_sell, buy_index, dur) in records:
+ for (pair, profit, date_buy, date_sell, buy_index, dur,
+ openr, closer, open_at_end) in records:
assert pair == 'UNITTEST/BTC'
- isinstance(profit, float)
+ assert isinstance(profit, float)
# FIX: buy/sell should be converted to ints
- isinstance(date_buy, str)
- isinstance(date_sell, str)
+ assert isinstance(date_buy, float)
+ assert isinstance(date_sell, float)
+ assert isinstance(openr, float)
+ assert isinstance(closer, float)
+ assert isinstance(open_at_end, bool)
isinstance(buy_index, pd._libs.tslib.Timestamp)
if oix:
assert buy_index > oix
diff --git a/freqtrade/tests/optimize/test_hyperopt.py b/freqtrade/tests/optimize/test_hyperopt.py
index 8ad1932af..72a102c22 100644
--- a/freqtrade/tests/optimize/test_hyperopt.py
+++ b/freqtrade/tests/optimize/test_hyperopt.py
@@ -1,6 +1,5 @@
# pragma pylint: disable=missing-docstring,W0212,C0103
import os
-import signal
from copy import deepcopy
from unittest.mock import MagicMock
@@ -40,21 +39,11 @@ def create_trials(mocker) -> None:
mocker.patch('freqtrade.optimize.hyperopt.os.path.exists', return_value=False)
mocker.patch('freqtrade.optimize.hyperopt.os.path.getsize', return_value=1)
mocker.patch('freqtrade.optimize.hyperopt.os.remove', return_value=True)
- mocker.patch('freqtrade.optimize.hyperopt.pickle.dump', return_value=None)
+ mocker.patch('freqtrade.optimize.hyperopt.dump', return_value=None)
- return mocker.Mock(
- results=[
- {
- 'loss': 1,
- 'result': 'foo',
- 'status': 'ok'
- }
- ],
- best_trial={'misc': {'vals': {'adx': 999}}}
- )
+ return [{'loss': 1, 'result': 'foo', 'params': {}}]
-# Unit tests
def test_start(mocker, default_conf, caplog) -> None:
"""
Test start() function
@@ -148,155 +137,18 @@ def test_no_log_if_loss_does_not_improve(init_hyperopt, caplog) -> None:
assert caplog.record_tuples == []
-def test_fmin_best_results(mocker, init_hyperopt, default_conf, caplog) -> None:
- fmin_result = {
- "macd_below_zero": 0,
- "adx": 1,
- "adx-value": 15.0,
- "fastd": 1,
- "fastd-value": 40.0,
- "green_candle": 1,
- "mfi": 0,
- "over_sar": 0,
- "rsi": 1,
- "rsi-value": 37.0,
- "trigger": 2,
- "uptrend_long_ema": 1,
- "uptrend_short_ema": 0,
- "uptrend_sma": 0,
- "stoploss": -0.1,
- "roi_t1": 1,
- "roi_t2": 2,
- "roi_t3": 3,
- "roi_p1": 1,
- "roi_p2": 2,
- "roi_p3": 3,
- }
-
- conf = deepcopy(default_conf)
- conf.update({'config': 'config.json.example'})
- conf.update({'epochs': 1})
- conf.update({'timerange': None})
- conf.update({'spaces': 'all'})
-
- mocker.patch('freqtrade.optimize.hyperopt.load_data', MagicMock())
- mocker.patch('freqtrade.optimize.hyperopt.fmin', return_value=fmin_result)
- patch_exchange(mocker)
-
- StrategyResolver({'strategy': 'DefaultStrategy'})
- hyperopt = Hyperopt(conf)
- hyperopt.trials = create_trials(mocker)
- hyperopt.tickerdata_to_dataframe = MagicMock()
- hyperopt.start()
-
- exists = [
- 'Best parameters:',
- '"adx": {\n "enabled": true,\n "value": 15.0\n },',
- '"fastd": {\n "enabled": true,\n "value": 40.0\n },',
- '"green_candle": {\n "enabled": true\n },',
- '"macd_below_zero": {\n "enabled": false\n },',
- '"mfi": {\n "enabled": false\n },',
- '"over_sar": {\n "enabled": false\n },',
- '"roi_p1": 1.0,',
- '"roi_p2": 2.0,',
- '"roi_p3": 3.0,',
- '"roi_t1": 1.0,',
- '"roi_t2": 2.0,',
- '"roi_t3": 3.0,',
- '"rsi": {\n "enabled": true,\n "value": 37.0\n },',
- '"stoploss": -0.1,',
- '"trigger": {\n "type": "faststoch10"\n },',
- '"uptrend_long_ema": {\n "enabled": true\n },',
- '"uptrend_short_ema": {\n "enabled": false\n },',
- '"uptrend_sma": {\n "enabled": false\n }',
- 'ROI table:\n{0: 6.0, 3.0: 3.0, 5.0: 1.0, 6.0: 0}',
- 'Best Result:\nfoo'
- ]
- for line in exists:
- assert line in caplog.text
-
-
-def test_fmin_throw_value_error(mocker, init_hyperopt, default_conf, caplog) -> None:
- mocker.patch('freqtrade.optimize.hyperopt.load_data', MagicMock())
- mocker.patch('freqtrade.optimize.hyperopt.fmin', side_effect=ValueError())
-
- conf = deepcopy(default_conf)
- conf.update({'config': 'config.json.example'})
- conf.update({'epochs': 1})
- conf.update({'timerange': None})
- conf.update({'spaces': 'all'})
- patch_exchange(mocker)
-
- StrategyResolver({'strategy': 'DefaultStrategy'})
- hyperopt = Hyperopt(conf)
- hyperopt.trials = create_trials(mocker)
- hyperopt.tickerdata_to_dataframe = MagicMock()
-
- hyperopt.start()
-
- exists = [
- 'Best Result:',
- 'Sorry, Hyperopt was not able to find good parameters. Please try with more epochs '
- '(param: -e).',
- ]
-
- for line in exists:
- assert line in caplog.text
-
-
-def test_resuming_previous_hyperopt_results_succeeds(mocker, init_hyperopt, default_conf) -> None:
- trials = create_trials(mocker)
-
- conf = deepcopy(default_conf)
- conf.update({'config': 'config.json.example'})
- conf.update({'epochs': 1})
- conf.update({'timerange': None})
- conf.update({'spaces': 'all'})
-
- mocker.patch('freqtrade.optimize.hyperopt.os.path.exists', return_value=True)
- mocker.patch('freqtrade.optimize.hyperopt.len', return_value=len(trials.results))
- mock_read = mocker.patch(
- 'freqtrade.optimize.hyperopt.Hyperopt.read_trials',
- return_value=trials
- )
- mock_save = mocker.patch(
- 'freqtrade.optimize.hyperopt.Hyperopt.save_trials',
- return_value=None
- )
- mocker.patch('freqtrade.optimize.hyperopt.sorted', return_value=trials.results)
- mocker.patch('freqtrade.optimize.hyperopt.load_data', MagicMock())
- mocker.patch('freqtrade.optimize.hyperopt.fmin', return_value={})
- patch_exchange(mocker)
-
- StrategyResolver({'strategy': 'DefaultStrategy'})
- hyperopt = Hyperopt(conf)
- hyperopt.trials = trials
- hyperopt.tickerdata_to_dataframe = MagicMock()
-
- hyperopt.start()
-
- mock_read.assert_called_once()
- mock_save.assert_called_once()
-
- current_tries = hyperopt.current_tries
- total_tries = hyperopt.total_tries
-
- assert current_tries == len(trials.results)
- assert total_tries == (current_tries + len(trials.results))
-
-
def test_save_trials_saves_trials(mocker, init_hyperopt, caplog) -> None:
- create_trials(mocker)
- mock_dump = mocker.patch('freqtrade.optimize.hyperopt.pickle.dump', return_value=None)
+ trials = create_trials(mocker)
+ mock_dump = mocker.patch('freqtrade.optimize.hyperopt.dump', return_value=None)
hyperopt = _HYPEROPT
- mocker.patch('freqtrade.optimize.hyperopt.open', return_value=hyperopt.trials_file)
+ _HYPEROPT.trials = trials
hyperopt.save_trials()
trials_file = os.path.join('freqtrade', 'tests', 'optimize', 'ut_trials.pickle')
assert log_has(
- 'Saving Trials to \'{}\''.format(trials_file),
+ 'Saving 1 evaluations to \'{}\''.format(trials_file),
caplog.record_tuples
)
mock_dump.assert_called_once()
@@ -304,8 +156,7 @@ def test_save_trials_saves_trials(mocker, init_hyperopt, caplog) -> None:
def test_read_trials_returns_trials_file(mocker, init_hyperopt, caplog) -> None:
trials = create_trials(mocker)
- mock_load = mocker.patch('freqtrade.optimize.hyperopt.pickle.load', return_value=trials)
- mock_open = mocker.patch('freqtrade.optimize.hyperopt.open', return_value=mock_load)
+ mock_load = mocker.patch('freqtrade.optimize.hyperopt.load', return_value=trials)
hyperopt = _HYPEROPT
hyperopt_trial = hyperopt.read_trials()
@@ -315,7 +166,6 @@ def test_read_trials_returns_trials_file(mocker, init_hyperopt, caplog) -> None:
caplog.record_tuples
)
assert hyperopt_trial == trials
- mock_open.assert_called_once()
mock_load.assert_called_once()
@@ -333,12 +183,15 @@ def test_roi_table_generation(init_hyperopt) -> None:
assert hyperopt.generate_roi_table(params) == {0: 6, 15: 3, 25: 1, 30: 0}
-def test_start_calls_fmin(mocker, init_hyperopt, default_conf) -> None:
- trials = create_trials(mocker)
- mocker.patch('freqtrade.optimize.hyperopt.sorted', return_value=trials.results)
+def test_start_calls_optimizer(mocker, init_hyperopt, 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))
+ parallel = mocker.patch(
+ 'freqtrade.optimize.hyperopt.Hyperopt.run_optimizer_parallel',
+ MagicMock(return_value=[{'loss': 1, 'result': 'foo result', 'params': {}}])
+ )
patch_exchange(mocker)
- mock_fmin = mocker.patch('freqtrade.optimize.hyperopt.fmin', return_value={})
conf = deepcopy(default_conf)
conf.update({'config': 'config.json.example'})
@@ -347,11 +200,13 @@ def test_start_calls_fmin(mocker, init_hyperopt, default_conf) -> None:
conf.update({'spaces': 'all'})
hyperopt = Hyperopt(conf)
- hyperopt.trials = trials
hyperopt.tickerdata_to_dataframe = MagicMock()
hyperopt.start()
- mock_fmin.assert_called_once()
+ parallel.assert_called_once()
+
+ assert 'Best result:\nfoo result\nwith values:\n{}' in caplog.text
+ assert dumper.called
def test_format_results(init_hyperopt):
@@ -384,20 +239,6 @@ def test_format_results(init_hyperopt):
assert result.find('Total profit 1.00000000 EUR')
-def test_signal_handler(mocker, init_hyperopt):
- """
- Test Hyperopt.signal_handler()
- """
- m = MagicMock()
- mocker.patch('sys.exit', m)
- mocker.patch('freqtrade.optimize.hyperopt.Hyperopt.save_trials', m)
- mocker.patch('freqtrade.optimize.hyperopt.Hyperopt.log_trials_result', m)
-
- hyperopt = _HYPEROPT
- hyperopt.signal_handler(signal.SIGTERM, None)
- assert m.call_count == 3
-
-
def test_has_space(init_hyperopt):
"""
Test Hyperopt.has_space() method
@@ -422,8 +263,8 @@ def test_populate_indicators(init_hyperopt) -> None:
# Check if some indicators are generated. We will not test all of them
assert 'adx' in dataframe
- assert 'ao' in dataframe
- assert 'cci' in dataframe
+ assert 'mfi' in dataframe
+ assert 'rsi' in dataframe
def test_buy_strategy_generator(init_hyperopt) -> None:
@@ -437,44 +278,15 @@ def test_buy_strategy_generator(init_hyperopt) -> None:
populate_buy_trend = _HYPEROPT.buy_strategy_generator(
{
- 'uptrend_long_ema': {
- 'enabled': True
- },
- 'macd_below_zero': {
- 'enabled': True
- },
- 'uptrend_short_ema': {
- 'enabled': True
- },
- 'mfi': {
- 'enabled': True,
- 'value': 20
- },
- 'fastd': {
- 'enabled': True,
- 'value': 20
- },
- 'adx': {
- 'enabled': True,
- 'value': 20
- },
- 'rsi': {
- 'enabled': True,
- 'value': 20
- },
- 'over_sar': {
- 'enabled': True,
- },
- 'green_candle': {
- 'enabled': True,
- },
- 'uptrend_sma': {
- 'enabled': True,
- },
-
- 'trigger': {
- 'type': 'lower_bb'
- }
+ 'adx-value': 20,
+ 'fastd-value': 20,
+ 'mfi-value': 20,
+ 'rsi-value': 20,
+ 'adx-enabled': True,
+ 'fastd-enabled': True,
+ 'mfi-enabled': True,
+ 'rsi-enabled': True,
+ 'trigger': 'bb_lower'
}
)
result = populate_buy_trend(dataframe)
@@ -503,35 +315,34 @@ def test_generate_optimizer(mocker, init_hyperopt, default_conf) -> None:
MagicMock(return_value=backtest_result)
)
patch_exchange(mocker)
+ mocker.patch('freqtrade.optimize.hyperopt.load', MagicMock())
optimizer_param = {
- 'adx': {'enabled': False},
- 'fastd': {'enabled': True, 'value': 35.0},
- 'green_candle': {'enabled': True},
- 'macd_below_zero': {'enabled': True},
- 'mfi': {'enabled': False},
- 'over_sar': {'enabled': False},
- 'roi_p1': 0.01,
- 'roi_p2': 0.01,
- 'roi_p3': 0.1,
+ 'adx-value': 0,
+ 'fastd-value': 35,
+ 'mfi-value': 0,
+ 'rsi-value': 0,
+ 'adx-enabled': False,
+ 'fastd-enabled': True,
+ 'mfi-enabled': False,
+ 'rsi-enabled': False,
+ 'trigger': 'macd_cross_signal',
'roi_t1': 60.0,
'roi_t2': 30.0,
'roi_t3': 20.0,
- 'rsi': {'enabled': False},
+ 'roi_p1': 0.01,
+ 'roi_p2': 0.01,
+ 'roi_p3': 0.1,
'stoploss': -0.4,
- 'trigger': {'type': 'macd_cross_signal'},
- 'uptrend_long_ema': {'enabled': False},
- 'uptrend_short_ema': {'enabled': True},
- 'uptrend_sma': {'enabled': True}
}
response_expected = {
'loss': 1.9840569076926293,
'result': ' 1 trades. Avg profit 2.31%. Total profit 0.00023300 BTC '
'(0.0231Σ%). Avg duration 100.0 mins.',
- 'status': 'ok'
+ 'params': optimizer_param
}
hyperopt = Hyperopt(conf)
- generate_optimizer_value = hyperopt.generate_optimizer(optimizer_param)
+ generate_optimizer_value = hyperopt.generate_optimizer(list(optimizer_param.values()))
assert generate_optimizer_value == response_expected
diff --git a/freqtrade/tests/optimize/test_optimize.py b/freqtrade/tests/optimize/test_optimize.py
index 624f8ed77..4ab32343a 100644
--- a/freqtrade/tests/optimize/test_optimize.py
+++ b/freqtrade/tests/optimize/test_optimize.py
@@ -3,16 +3,19 @@
import json
import os
import uuid
-import arrow
from shutil import copyfile
+import arrow
+
from freqtrade import optimize
-from freqtrade.misc import file_dump_json
-from freqtrade.optimize.__init__ import make_testdata_path, download_pairs, \
- download_backtesting_testdata, load_tickerdata_file, trim_tickerlist, \
- load_cached_data_for_updating
from freqtrade.arguments import TimeRange
-from freqtrade.tests.conftest import log_has, get_patched_exchange
+from freqtrade.misc import file_dump_json
+from freqtrade.optimize.__init__ import (download_backtesting_testdata,
+ download_pairs,
+ load_cached_data_for_updating,
+ load_tickerdata_file,
+ make_testdata_path, trim_tickerlist)
+from freqtrade.tests.conftest import get_patched_exchange, log_has
# Change this if modifying UNITTEST/BTC testdatafile
_BTC_UNITTEST_LENGTH = 13681
diff --git a/freqtrade/tests/rpc/test_rpc.py b/freqtrade/tests/rpc/test_rpc.py
index 11db7ffb3..58514d1c0 100644
--- a/freqtrade/tests/rpc/test_rpc.py
+++ b/freqtrade/tests/rpc/test_rpc.py
@@ -13,7 +13,8 @@ from freqtrade.freqtradebot import FreqtradeBot
from freqtrade.persistence import Trade
from freqtrade.rpc.rpc import RPC, RPCException
from freqtrade.state import State
-from freqtrade.tests.test_freqtradebot import patch_get_signal, patch_coinmarketcap
+from freqtrade.tests.test_freqtradebot import (patch_coinmarketcap,
+ patch_get_signal)
# Functions for recurrent object patching
diff --git a/freqtrade/tests/rpc/test_rpc_manager.py b/freqtrade/tests/rpc/test_rpc_manager.py
index 805424d26..5aea98d48 100644
--- a/freqtrade/tests/rpc/test_rpc_manager.py
+++ b/freqtrade/tests/rpc/test_rpc_manager.py
@@ -7,7 +7,7 @@ from copy import deepcopy
from unittest.mock import MagicMock
from freqtrade.rpc.rpc_manager import RPCManager
-from freqtrade.tests.conftest import log_has, get_patched_freqtradebot
+from freqtrade.tests.conftest import get_patched_freqtradebot, log_has
def test_rpc_manager_object() -> None:
diff --git a/freqtrade/tests/rpc/test_rpc_telegram.py b/freqtrade/tests/rpc/test_rpc_telegram.py
index b2cca9b9a..2710328bd 100644
--- a/freqtrade/tests/rpc/test_rpc_telegram.py
+++ b/freqtrade/tests/rpc/test_rpc_telegram.py
@@ -11,17 +11,18 @@ from datetime import datetime
from random import randint
from unittest.mock import MagicMock
-from telegram import Update, Message, Chat
+from telegram import Chat, Message, Update
from telegram.error import NetworkError
from freqtrade import __version__
from freqtrade.freqtradebot import FreqtradeBot
from freqtrade.persistence import Trade
-from freqtrade.rpc.telegram import Telegram
-from freqtrade.rpc.telegram import authorized_only
+from freqtrade.rpc.telegram import Telegram, authorized_only
from freqtrade.state import State
-from freqtrade.tests.conftest import get_patched_freqtradebot, patch_exchange, log_has
-from freqtrade.tests.test_freqtradebot import patch_get_signal, patch_coinmarketcap
+from freqtrade.tests.conftest import (get_patched_freqtradebot, log_has,
+ patch_exchange)
+from freqtrade.tests.test_freqtradebot import (patch_coinmarketcap,
+ patch_get_signal)
class DummyCls(Telegram):
diff --git a/freqtrade/tests/test_acl_pair.py b/freqtrade/tests/test_acl_pair.py
index 608e6a4a1..094c166b8 100644
--- a/freqtrade/tests/test_acl_pair.py
+++ b/freqtrade/tests/test_acl_pair.py
@@ -1,8 +1,9 @@
# pragma pylint: disable=missing-docstring,C0103,protected-access
-import freqtrade.tests.conftest as tt # test tools
from unittest.mock import MagicMock
+import freqtrade.tests.conftest as tt # test tools
+
# whitelist, blacklist, filtering, all of that will
# eventually become some rules to run on a generic ACL engine
# perhaps try to anticipate that by using some python package
diff --git a/freqtrade/tests/test_analyze.py b/freqtrade/tests/test_analyze.py
index 89dac21c6..e6108e8f8 100644
--- a/freqtrade/tests/test_analyze.py
+++ b/freqtrade/tests/test_analyze.py
@@ -12,9 +12,9 @@ import arrow
from pandas import DataFrame
from freqtrade.analyze import Analyze, SignalType
-from freqtrade.optimize.__init__ import load_tickerdata_file
from freqtrade.arguments import TimeRange
-from freqtrade.tests.conftest import log_has, get_patched_exchange
+from freqtrade.optimize.__init__ import load_tickerdata_file
+from freqtrade.tests.conftest import get_patched_exchange, log_has
# Avoid to reinit the same object again and again
_ANALYZE = Analyze({'strategy': 'DefaultStrategy'})
@@ -42,6 +42,7 @@ def test_analyze_object() -> None:
assert hasattr(Analyze, 'get_signal')
assert hasattr(Analyze, 'should_sell')
assert hasattr(Analyze, 'min_roi_reached')
+ assert hasattr(Analyze, 'stop_loss_reached')
def test_dataframe_correct_length(result):
diff --git a/freqtrade/tests/test_configuration.py b/freqtrade/tests/test_configuration.py
index a4096cc01..e64e1b486 100644
--- a/freqtrade/tests/test_configuration.py
+++ b/freqtrade/tests/test_configuration.py
@@ -4,18 +4,18 @@
Unit test file for configuration.py
"""
import json
+from argparse import Namespace
from copy import deepcopy
from unittest.mock import MagicMock
-from argparse import Namespace
import pytest
from jsonschema import ValidationError
+from freqtrade import OperationalException
from freqtrade.arguments import Arguments
from freqtrade.configuration import Configuration
-from freqtrade.constants import DEFAULT_DB_PROD_URL, DEFAULT_DB_DRYRUN_URL
+from freqtrade.constants import DEFAULT_DB_DRYRUN_URL, DEFAULT_DB_PROD_URL
from freqtrade.tests.conftest import log_has
-from freqtrade import OperationalException
def test_configuration_object() -> None:
diff --git a/freqtrade/tests/test_fiat_convert.py b/freqtrade/tests/test_fiat_convert.py
index 2fb9219ca..5af85d268 100644
--- a/freqtrade/tests/test_fiat_convert.py
+++ b/freqtrade/tests/test_fiat_convert.py
@@ -5,7 +5,6 @@ import time
from unittest.mock import MagicMock
import pytest
-
from requests.exceptions import RequestException
from freqtrade.fiat_convert import CryptoFiat, CryptoToFiatConverter
diff --git a/freqtrade/tests/test_freqtradebot.py b/freqtrade/tests/test_freqtradebot.py
index 1cb2bfca2..17bd6aa7c 100644
--- a/freqtrade/tests/test_freqtradebot.py
+++ b/freqtrade/tests/test_freqtradebot.py
@@ -14,11 +14,13 @@ import arrow
import pytest
import requests
-from freqtrade import constants, DependencyException, OperationalException, TemporaryError
+from freqtrade import (DependencyException, OperationalException,
+ TemporaryError, constants)
from freqtrade.freqtradebot import FreqtradeBot
from freqtrade.persistence import Trade
from freqtrade.state import State
-from freqtrade.tests.conftest import log_has, patch_coinmarketcap, patch_exchange
+from freqtrade.tests.conftest import (log_has, patch_coinmarketcap,
+ patch_exchange)
# Functions for recurrent object patching
@@ -348,6 +350,34 @@ def test_get_min_pair_stake_amount(mocker, default_conf) -> None:
result = freqtrade._get_min_pair_stake_amount('ETH/BTC', 1)
assert result is None
+ # no cost Min
+ mocker.patch(
+ 'freqtrade.exchange.Exchange.get_markets',
+ MagicMock(return_value=[{
+ 'symbol': 'ETH/BTC',
+ 'limits': {
+ 'cost': {"min": None},
+ 'amount': {}
+ }
+ }])
+ )
+ result = freqtrade._get_min_pair_stake_amount('ETH/BTC', 1)
+ assert result is None
+
+ # no amount Min
+ mocker.patch(
+ 'freqtrade.exchange.Exchange.get_markets',
+ MagicMock(return_value=[{
+ 'symbol': 'ETH/BTC',
+ 'limits': {
+ 'cost': {},
+ 'amount': {"min": None}
+ }
+ }])
+ )
+ result = freqtrade._get_min_pair_stake_amount('ETH/BTC', 1)
+ assert result is None
+
# empty 'cost'/'amount' section
mocker.patch(
'freqtrade.exchange.Exchange.get_markets',
@@ -1124,7 +1154,7 @@ def test_check_handle_timedout_buy(default_conf, ticker, limit_buy_order_old, fe
Trade.session.add(trade_buy)
# check it does cancel buy orders over the time limit
- freqtrade.check_handle_timedout(600)
+ freqtrade.check_handle_timedout()
assert cancel_order_mock.call_count == 1
assert rpc_mock.call_count == 1
trades = Trade.query.filter(Trade.open_order_id.is_(trade_buy.open_order_id)).all()
@@ -1165,7 +1195,7 @@ def test_check_handle_timedout_sell(default_conf, ticker, limit_sell_order_old,
Trade.session.add(trade_sell)
# check it does cancel sell orders over the time limit
- freqtrade.check_handle_timedout(600)
+ freqtrade.check_handle_timedout()
assert cancel_order_mock.call_count == 1
assert rpc_mock.call_count == 1
assert trade_sell.is_open is True
@@ -1205,7 +1235,7 @@ def test_check_handle_timedout_partial(default_conf, ticker, limit_buy_order_old
# check it does cancel buy orders over the time limit
# note this is for a partially-complete buy order
- freqtrade.check_handle_timedout(600)
+ freqtrade.check_handle_timedout()
assert cancel_order_mock.call_count == 1
assert rpc_mock.call_count == 1
trades = Trade.query.filter(Trade.open_order_id.is_(trade_buy.open_order_id)).all()
@@ -1256,7 +1286,7 @@ def test_check_handle_timedout_exception(default_conf, ticker, mocker, caplog) -
'recent call last):\n.*'
)
- freqtrade.check_handle_timedout(600)
+ freqtrade.check_handle_timedout()
assert filter(regexp.match, caplog.record_tuples)
@@ -1599,6 +1629,7 @@ def test_sell_profit_only_disable_loss(default_conf, limit_buy_order, fee, marke
}),
buy=MagicMock(return_value={'id': limit_buy_order['id']}),
get_fee=fee,
+ get_markets=markets
)
conf = deepcopy(default_conf)
@@ -1616,7 +1647,7 @@ def test_sell_profit_only_disable_loss(default_conf, limit_buy_order, fee, marke
assert freqtrade.handle_trade(trade) is True
-def test_ignore_roi_if_buy_signal(default_conf, limit_buy_order, fee, mocker) -> None:
+def test_ignore_roi_if_buy_signal(default_conf, limit_buy_order, fee, markets, mocker) -> None:
"""
Test sell_profit_only feature when enabled and we have a loss
"""
@@ -1634,6 +1665,7 @@ def test_ignore_roi_if_buy_signal(default_conf, limit_buy_order, fee, mocker) ->
}),
buy=MagicMock(return_value={'id': limit_buy_order['id']}),
get_fee=fee,
+ get_markets=markets
)
conf = deepcopy(default_conf)
@@ -1654,6 +1686,103 @@ def test_ignore_roi_if_buy_signal(default_conf, limit_buy_order, fee, mocker) ->
assert freqtrade.handle_trade(trade) is True
+def test_trailing_stop_loss(default_conf, limit_buy_order, fee, caplog, mocker) -> None:
+ """
+ Test sell_profit_only feature when enabled and we have a loss
+ """
+ patch_get_signal(mocker)
+ patch_RPCManager(mocker)
+ patch_coinmarketcap(mocker)
+ mocker.patch('freqtrade.freqtradebot.Analyze.min_roi_reached', return_value=False)
+ mocker.patch.multiple(
+ 'freqtrade.exchange.Exchange',
+ validate_pairs=MagicMock(),
+ get_ticker=MagicMock(return_value={
+ 'bid': 0.00000102,
+ 'ask': 0.00000103,
+ 'last': 0.00000102
+ }),
+ buy=MagicMock(return_value={'id': limit_buy_order['id']}),
+ get_fee=fee,
+ )
+
+ conf = deepcopy(default_conf)
+ conf['trailing_stop'] = True
+ print(limit_buy_order)
+ freqtrade = FreqtradeBot(conf)
+ freqtrade.create_trade()
+
+ trade = Trade.query.first()
+ trade.update(limit_buy_order)
+ caplog.set_level(logging.DEBUG)
+ # Sell as trailing-stop is reached
+ assert freqtrade.handle_trade(trade) is True
+ assert log_has(
+ f'HIT STOP: current price at 0.000001, stop loss is {trade.stop_loss:.6f}, '
+ f'initial stop loss was at 0.000010, trade opened at 0.000011', caplog.record_tuples)
+
+
+def test_trailing_stop_loss_positive(default_conf, limit_buy_order, fee, caplog, mocker) -> None:
+ """
+ Test sell_profit_only feature when enabled and we have a loss
+ """
+ buy_price = limit_buy_order['price']
+ patch_get_signal(mocker)
+ patch_RPCManager(mocker)
+ patch_coinmarketcap(mocker)
+ mocker.patch('freqtrade.freqtradebot.Analyze.min_roi_reached', return_value=False)
+ mocker.patch.multiple(
+ 'freqtrade.exchange.Exchange',
+ validate_pairs=MagicMock(),
+ get_ticker=MagicMock(return_value={
+ 'bid': buy_price - 0.000001,
+ 'ask': buy_price - 0.000001,
+ 'last': buy_price - 0.000001
+ }),
+ buy=MagicMock(return_value={'id': limit_buy_order['id']}),
+ get_fee=fee,
+ )
+
+ conf = deepcopy(default_conf)
+ conf['trailing_stop'] = True
+ conf['trailing_stop_positive'] = 0.01
+ freqtrade = FreqtradeBot(conf)
+ freqtrade.create_trade()
+
+ trade = Trade.query.first()
+ trade.update(limit_buy_order)
+ caplog.set_level(logging.DEBUG)
+ # stop-loss not reached
+ assert freqtrade.handle_trade(trade) is False
+
+ # Raise ticker above buy price
+ mocker.patch('freqtrade.exchange.Exchange.get_ticker',
+ MagicMock(return_value={
+ 'bid': buy_price + 0.000003,
+ 'ask': buy_price + 0.000003,
+ 'last': buy_price + 0.000003
+ }))
+ # stop-loss not reached, adjusted stoploss
+ assert freqtrade.handle_trade(trade) is False
+ assert log_has(f'using positive stop loss mode: 0.01 since we have profit 0.26662643',
+ caplog.record_tuples)
+ assert log_has(f'adjusted stop loss', caplog.record_tuples)
+ assert trade.stop_loss == 0.0000138501
+
+ mocker.patch('freqtrade.exchange.Exchange.get_ticker',
+ MagicMock(return_value={
+ 'bid': buy_price + 0.000002,
+ 'ask': buy_price + 0.000002,
+ 'last': buy_price + 0.000002
+ }))
+ # Lower price again (but still positive)
+ assert freqtrade.handle_trade(trade) is True
+ assert log_has(
+ f'HIT STOP: current price at {buy_price + 0.000002:.6f}, '
+ f'stop loss is {trade.stop_loss:.6f}, '
+ f'initial stop loss was at 0.000010, trade opened at 0.000011', caplog.record_tuples)
+
+
def test_disable_ignore_roi_if_buy_signal(default_conf, limit_buy_order,
fee, markets, mocker) -> None:
"""
diff --git a/freqtrade/tests/test_indicator_helpers.py b/freqtrade/tests/test_indicator_helpers.py
index 87b085a0b..f3d34ec0b 100644
--- a/freqtrade/tests/test_indicator_helpers.py
+++ b/freqtrade/tests/test_indicator_helpers.py
@@ -1,6 +1,6 @@
import pandas as pd
-from freqtrade.indicator_helpers import went_up, went_down
+from freqtrade.indicator_helpers import went_down, went_up
def test_went_up():
diff --git a/freqtrade/tests/test_main.py b/freqtrade/tests/test_main.py
index 414dcdbe9..20a02eedc 100644
--- a/freqtrade/tests/test_main.py
+++ b/freqtrade/tests/test_main.py
@@ -11,7 +11,7 @@ import pytest
from freqtrade import OperationalException
from freqtrade.arguments import Arguments
from freqtrade.freqtradebot import FreqtradeBot
-from freqtrade.main import main, set_loggers, reconfigure
+from freqtrade.main import main, reconfigure, set_loggers
from freqtrade.state import State
from freqtrade.tests.conftest import log_has, patch_exchange
diff --git a/freqtrade/tests/test_misc.py b/freqtrade/tests/test_misc.py
index b57900428..e2ba40dee 100644
--- a/freqtrade/tests/test_misc.py
+++ b/freqtrade/tests/test_misc.py
@@ -8,8 +8,8 @@ import datetime
from unittest.mock import MagicMock
from freqtrade.analyze import Analyze
-from freqtrade.misc import (shorten_date, datesarray_to_datetimearray,
- common_datearray, file_dump_json, format_ms_time)
+from freqtrade.misc import (common_datearray, datesarray_to_datetimearray,
+ file_dump_json, format_ms_time, shorten_date)
from freqtrade.optimize.__init__ import load_tickerdata_file
diff --git a/freqtrade/tests/test_persistence.py b/freqtrade/tests/test_persistence.py
index 30ad239a1..b24f2dd6c 100644
--- a/freqtrade/tests/test_persistence.py
+++ b/freqtrade/tests/test_persistence.py
@@ -5,8 +5,9 @@ from unittest.mock import MagicMock
import pytest
from sqlalchemy import create_engine
-from freqtrade import constants, OperationalException
-from freqtrade.persistence import Trade, init, clean_dry_run_db
+from freqtrade import OperationalException, constants
+from freqtrade.persistence import Trade, clean_dry_run_db, init
+from freqtrade.tests.conftest import log_has
@pytest.fixture(scope='function')
@@ -400,9 +401,12 @@ def test_migrate_old(mocker, default_conf, fee):
assert trade.stake_amount == default_conf.get("stake_amount")
assert trade.pair == "ETC/BTC"
assert trade.exchange == "bittrex"
+ assert trade.max_rate == 0.0
+ assert trade.stop_loss == 0.0
+ assert trade.initial_stop_loss == 0.0
-def test_migrate_new(mocker, default_conf, fee):
+def test_migrate_new(mocker, default_conf, fee, caplog):
"""
Test Database migration (starting with new pairformat)
"""
@@ -439,6 +443,11 @@ def test_migrate_new(mocker, default_conf, fee):
# Create table using the old format
engine.execute(create_table_old)
engine.execute(insert_table_old)
+
+ # fake previous backup
+ engine.execute("create table trades_bak as select * from trades")
+
+ engine.execute("create table trades_bak1 as select * from trades")
# Run init to test migration
init(default_conf)
@@ -453,3 +462,54 @@ def test_migrate_new(mocker, default_conf, fee):
assert trade.stake_amount == default_conf.get("stake_amount")
assert trade.pair == "ETC/BTC"
assert trade.exchange == "binance"
+ assert trade.max_rate == 0.0
+ assert trade.stop_loss == 0.0
+ assert trade.initial_stop_loss == 0.0
+ assert log_has("trying trades_bak1", caplog.record_tuples)
+ assert log_has("trying trades_bak2", caplog.record_tuples)
+
+
+def test_adjust_stop_loss(limit_buy_order, limit_sell_order, fee):
+ trade = Trade(
+ pair='ETH/BTC',
+ stake_amount=0.001,
+ fee_open=fee.return_value,
+ fee_close=fee.return_value,
+ exchange='bittrex',
+ open_rate=1,
+ )
+
+ trade.adjust_stop_loss(trade.open_rate, 0.05, True)
+ assert trade.stop_loss == 0.95
+ assert trade.max_rate == 1
+ assert trade.initial_stop_loss == 0.95
+
+ # Get percent of profit with a lowre rate
+ trade.adjust_stop_loss(0.96, 0.05)
+ assert trade.stop_loss == 0.95
+ assert trade.max_rate == 1
+ assert trade.initial_stop_loss == 0.95
+
+ # Get percent of profit with a custom rate (Higher than open rate)
+ trade.adjust_stop_loss(1.3, -0.1)
+ assert round(trade.stop_loss, 8) == 1.17
+ assert trade.max_rate == 1.3
+ assert trade.initial_stop_loss == 0.95
+
+ # current rate lower again ... should not change
+ trade.adjust_stop_loss(1.2, 0.1)
+ assert round(trade.stop_loss, 8) == 1.17
+ assert trade.max_rate == 1.3
+ assert trade.initial_stop_loss == 0.95
+
+ # current rate higher... should raise stoploss
+ trade.adjust_stop_loss(1.4, 0.1)
+ assert round(trade.stop_loss, 8) == 1.26
+ assert trade.max_rate == 1.4
+ assert trade.initial_stop_loss == 0.95
+
+ # Initial is true but stop_loss set - so doesn't do anything
+ trade.adjust_stop_loss(1.7, 0.1, True)
+ assert round(trade.stop_loss, 8) == 1.26
+ assert trade.max_rate == 1.4
+ assert trade.initial_stop_loss == 0.95
diff --git a/requirements.txt b/requirements.txt
index 51312791e..f87241e32 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,5 +1,5 @@
-ccxt==1.14.256
-SQLAlchemy==1.2.8
+ccxt==1.15.13
+SQLAlchemy==1.2.9
python-telegram-bot==10.1.0
arrow==0.12.1
cachetools==2.1.0
@@ -12,14 +12,14 @@ scipy==1.1.0
jsonschema==2.6.0
numpy==1.14.5
TA-Lib==0.4.17
-pytest==3.6.2
+pytest==3.6.3
pytest-mock==1.10.0
pytest-cov==2.5.1
-hyperopt==0.1
-# do not upgrade networkx before this is fixed https://github.com/hyperopt/hyperopt/issues/325
-networkx==1.11 # pyup: ignore
tabulate==0.8.2
coinmarketcap==5.0.3
+# Required for hyperopt
+scikit-optimize==0.5.2
+
# Required for plotting data
#plotly==2.7.0
diff --git a/scripts/convert_backtestdata.py b/scripts/convert_backtestdata.py
index 698c1c829..96e0cbce8 100755
--- a/scripts/convert_backtestdata.py
+++ b/scripts/convert_backtestdata.py
@@ -143,15 +143,14 @@ def convert_main(args: Namespace) -> None:
interval = str_interval
break
# change order on pairs if old ticker interval found
+
filename_new = path.join(path.dirname(filename),
- "{}_{}-{}.json".format(currencies[1],
- currencies[0], interval))
+ f"{currencies[1]}_{currencies[0]}-{interval}.json")
elif ret_string:
interval = ret_string.group(0)
filename_new = path.join(path.dirname(filename),
- "{}_{}-{}.json".format(currencies[0],
- currencies[1], interval))
+ f"{currencies[0]}_{currencies[1]}-{interval}.json")
else:
logger.warning("file %s could not be converted, interval not found", filename)
diff --git a/scripts/download_backtest_data.py b/scripts/download_backtest_data.py
index 2f76c1232..686098f94 100755
--- a/scripts/download_backtest_data.py
+++ b/scripts/download_backtest_data.py
@@ -3,11 +3,14 @@
"""This script generate json data from bittrex"""
import json
import sys
-import os
+from pathlib import Path
import arrow
-from freqtrade import (arguments, misc)
+from freqtrade import arguments
+from freqtrade.arguments import TimeRange
from freqtrade.exchange import Exchange
+from freqtrade.optimize import download_backtesting_testdata
+
DEFAULT_DL_PATH = 'user_data/data'
@@ -17,25 +20,27 @@ args = arguments.parse_args()
timeframes = args.timeframes
-dl_path = os.path.join(DEFAULT_DL_PATH, args.exchange)
+dl_path = Path(DEFAULT_DL_PATH).joinpath(args.exchange)
if args.export:
- dl_path = args.export
+ dl_path = Path(args.export)
-if not os.path.isdir(dl_path):
+if not dl_path.is_dir():
sys.exit(f'Directory {dl_path} does not exist.')
-pairs_file = args.pairs_file if args.pairs_file else os.path.join(dl_path, 'pairs.json')
-if not os.path.isfile(pairs_file):
+pairs_file = Path(args.pairs_file) if args.pairs_file else dl_path.joinpath('pairs.json')
+if not pairs_file.exists():
sys.exit(f'No pairs file found with path {pairs_file}.')
-with open(pairs_file) as file:
+with pairs_file.open() as file:
PAIRS = list(set(json.load(file)))
PAIRS.sort()
-since_time = None
+
+timerange = TimeRange()
if args.days:
- since_time = arrow.utcnow().shift(days=-args.days).timestamp * 1000
+ time_since = arrow.utcnow().shift(days=-args.days).strftime("%Y%m%d")
+ timerange = arguments.parse_timerange(f'{time_since}-')
print(f'About to download pairs: {PAIRS} to {dl_path}')
@@ -59,21 +64,18 @@ for pair in PAIRS:
print(f"skipping pair {pair}")
continue
for tick_interval in timeframes:
- print(f'downloading pair {pair}, interval {tick_interval}')
-
- data = exchange.get_ticker_history(pair, tick_interval, since_ms=since_time)
- if not data:
- print('\tNo data was downloaded')
- break
-
- print('\tData was downloaded for period %s - %s' % (
- arrow.get(data[0][0] / 1000).format(),
- arrow.get(data[-1][0] / 1000).format()))
-
- # save data
pair_print = pair.replace('/', '_')
filename = f'{pair_print}-{tick_interval}.json'
- misc.file_dump_json(os.path.join(dl_path, filename), data)
+ dl_file = dl_path.joinpath(filename)
+ if args.erase and dl_file.exists():
+ print(f'Deleting existing data for pair {pair}, interval {tick_interval}')
+ dl_file.unlink()
+
+ print(f'downloading pair {pair}, interval {tick_interval}')
+ download_backtesting_testdata(str(dl_path), exchange=exchange,
+ pair=pair,
+ tick_interval=tick_interval,
+ timerange=timerange)
if pairs_not_available:
diff --git a/scripts/plot_dataframe.py b/scripts/plot_dataframe.py
index 7f9641222..1cc6b818a 100755
--- a/scripts/plot_dataframe.py
+++ b/scripts/plot_dataframe.py
@@ -25,11 +25,13 @@ Example of usage:
--indicators2 fastk,fastd
"""
import logging
-import os
import sys
+import json
+from pathlib import Path
from argparse import Namespace
from typing import Dict, List, Any
+import pandas as pd
import plotly.graph_objs as go
from plotly import tools
from plotly.offline import plot
@@ -37,7 +39,7 @@ from plotly.offline import plot
import freqtrade.optimize as optimize
from freqtrade import persistence
from freqtrade.analyze import Analyze
-from freqtrade.arguments import Arguments
+from freqtrade.arguments import Arguments, TimeRange
from freqtrade.exchange import Exchange
from freqtrade.optimize.backtesting import setup_configuration
from freqtrade.persistence import Trade
@@ -46,6 +48,45 @@ logger = logging.getLogger(__name__)
_CONF: Dict[str, Any] = {}
+def load_trades(args: Namespace, pair: str, timerange: TimeRange) -> pd.DataFrame:
+ trades: pd.DataFrame = pd.DataFrame()
+ if args.db_url:
+ persistence.init(_CONF)
+ columns = ["pair", "profit", "opents", "closets", "open_rate", "close_rate", "duration"]
+
+ trades = pd.DataFrame([(t.pair, t.calc_profit(),
+ t.open_date, t.close_date,
+ t.open_rate, t.close_rate,
+ t.close_date.timestamp() - t.open_date.timestamp())
+ for t in Trade.query.filter(Trade.pair.is_(pair)).all()],
+ columns=columns)
+
+ if args.exportfilename:
+ file = Path(args.exportfilename)
+ # must align with columns in backtest.py
+ columns = ["pair", "profit", "opents", "closets", "index", "duration",
+ "open_rate", "close_rate", "open_at_end"]
+ with file.open() as f:
+ data = json.load(f)
+ trades = pd.DataFrame(data, columns=columns)
+ trades = trades.loc[trades["pair"] == pair]
+ if timerange:
+ if timerange.starttype == 'date':
+ trades = trades.loc[trades["opents"] >= timerange.startts]
+ if timerange.stoptype == 'date':
+ trades = trades.loc[trades["opents"] <= timerange.stopts]
+
+ trades['opents'] = pd.to_datetime(trades['opents'],
+ unit='s',
+ utc=True,
+ infer_datetime_format=True)
+ trades['closets'] = pd.to_datetime(trades['closets'],
+ unit='s',
+ utc=True,
+ infer_datetime_format=True)
+ return trades
+
+
def plot_analyzed_dataframe(args: Namespace) -> None:
"""
Calls analyze() and plots the returned dataframe
@@ -102,31 +143,32 @@ def plot_analyzed_dataframe(args: Namespace) -> None:
if tickers == {}:
exit()
+ if args.db_url and args.exportfilename:
+ logger.critical("Can only specify --db-url or --export-filename")
# Get trades already made from the DB
- trades: List[Trade] = []
- if args.db_url:
- persistence.init(_CONF)
- trades = Trade.query.filter(Trade.pair.is_(pair)).all()
+ trades = load_trades(args, pair, timerange)
dataframes = analyze.tickerdata_to_dataframe(tickers)
dataframe = dataframes[pair]
dataframe = analyze.populate_buy_trend(dataframe)
dataframe = analyze.populate_sell_trend(dataframe)
- if len(dataframe.index) > 750:
- logger.warning('Ticker contained more than 750 candles, clipping.')
-
+ if len(dataframe.index) > args.plot_limit:
+ logger.warning('Ticker contained more than %s candles as defined '
+ 'with --plot-limit, clipping.', args.plot_limit)
+ dataframe = dataframe.tail(args.plot_limit)
+ trades = trades.loc[trades['opents'] >= dataframe.iloc[0]['date']]
fig = generate_graph(
pair=pair,
trades=trades,
- data=dataframe.tail(750),
+ data=dataframe,
args=args
)
- plot(fig, filename=os.path.join('user_data', 'freqtrade-plot.html'))
+ plot(fig, filename=str(Path('user_data').joinpath('freqtrade-plot.html')))
-def generate_graph(pair, trades, data, args) -> tools.make_subplots:
+def generate_graph(pair, trades: pd.DataFrame, data: pd.DataFrame, args) -> tools.make_subplots:
"""
Generate the graph from the data generated by Backtesting or from DB
:param pair: Pair to Display on the graph
@@ -187,8 +229,8 @@ def generate_graph(pair, trades, data, args) -> tools.make_subplots:
)
trade_buys = go.Scattergl(
- x=[t.open_date.isoformat() for t in trades],
- y=[t.open_rate for t in trades],
+ x=trades["opents"],
+ y=trades["open_rate"],
mode='markers',
name='trade_buy',
marker=dict(
@@ -199,8 +241,8 @@ def generate_graph(pair, trades, data, args) -> tools.make_subplots:
)
)
trade_sells = go.Scattergl(
- x=[t.close_date.isoformat() for t in trades],
- y=[t.close_rate for t in trades],
+ x=trades["closets"],
+ y=trades["close_rate"],
mode='markers',
name='trade_sell',
marker=dict(
@@ -299,11 +341,17 @@ def plot_parse_args(args: List[str]) -> Namespace:
default='macd',
dest='indicators2',
)
-
+ arguments.parser.add_argument(
+ '--plot-limit',
+ help='Specify tick limit for plotting - too high values cause huge files - '
+ 'Default: %(default)s',
+ dest='plot_limit',
+ default=750,
+ type=int,
+ )
arguments.common_args_parser()
arguments.optimizer_shared_options(arguments.parser)
arguments.backtesting_options(arguments.parser)
-
return arguments.parse_args()
diff --git a/setup.py b/setup.py
index ee6b7ae38..cd0574fa2 100644
--- a/setup.py
+++ b/setup.py
@@ -36,6 +36,7 @@ setup(name='freqtrade',
'tabulate',
'cachetools',
'coinmarketcap',
+ 'scikit-optimize',
],
include_package_data=True,
zip_safe=False,