Merge branch 'develop' into plot_profit

2018-01-26 10:07:48 +01:00
parent 19ef682250 4e9e97ddbb
commit fe2f779c47
37 changed files with 1551 additions and 473 deletions
--- a/freqtrade/init.py
+++ b/freqtrade/init.py
@@ -1,5 +1,5 @@
 """ FreqTrade bot """
-__version__ = '0.15.1'
+__version__ = '0.16.0'


 class DependencyException(BaseException):
--- a/freqtrade/analyze.py
+++ b/freqtrade/analyze.py
@@ -7,11 +7,10 @@ from enum import Enum
 from typing import Dict, List

 import arrow
-import talib.abstract as ta
 from pandas import DataFrame, to_datetime

-import freqtrade.vendor.qtpylib.indicators as qtpylib
 from freqtrade.exchange import get_ticker_history
+from freqtrade.strategy.strategy import Strategy

 logger = logging.getLogger(__name__)

@@ -30,8 +29,9 @@ def parse_ticker_dataframe(ticker: list) -> DataFrame:
    """
    columns = {'C': 'close', 'V': 'volume', 'O': 'open', 'H': 'high', 'L': 'low', 'T': 'date'}
    frame = DataFrame(ticker) \
-        .drop('BV', 1) \
        .rename(columns=columns)
+    if 'BV' in frame:
+        frame.drop('BV', 1, inplace=True)
    frame['date'] = to_datetime(frame['date'], utc=True, infer_datetime_format=True)
    frame.sort_values('date', inplace=True)
    return frame
@@ -45,182 +45,8 @@ def populate_indicators(dataframe: DataFrame) -> DataFrame:
    you are using. Let uncomment only the indicator you are using in your strategies
    or your hyperopt configuration, otherwise you will waste your memory and CPU usage.
    """
-
-    # Momentum Indicator
-    # ------------------------------------
-
-    # ADX
-    dataframe['adx'] = ta.ADX(dataframe)
-
-    # Awesome oscillator
-    dataframe['ao'] = qtpylib.awesome_oscillator(dataframe)
-    """
-    # Commodity Channel Index: values Oversold:<-100, Overbought:>100
-    dataframe['cci'] = ta.CCI(dataframe)
-    """
-    # MACD
-    macd = ta.MACD(dataframe)
-    dataframe['macd'] = macd['macd']
-    dataframe['macdsignal'] = macd['macdsignal']
-    dataframe['macdhist'] = macd['macdhist']
-
-    # MFI
-    dataframe['mfi'] = ta.MFI(dataframe)
-
-    # Minus Directional Indicator / Movement
-    dataframe['minus_dm'] = ta.MINUS_DM(dataframe)
-    dataframe['minus_di'] = ta.MINUS_DI(dataframe)
-
-    # Plus Directional Indicator / Movement
-    dataframe['plus_dm'] = ta.PLUS_DM(dataframe)
-    dataframe['plus_di'] = ta.PLUS_DI(dataframe)
-    dataframe['minus_di'] = ta.MINUS_DI(dataframe)
-
-    """
-    # ROC
-    dataframe['roc'] = ta.ROC(dataframe)
-    """
-    # RSI
-    dataframe['rsi'] = ta.RSI(dataframe)
-    """
-    # Inverse Fisher transform on RSI, values [-1.0, 1.0] (https://goo.gl/2JGGoy)
-    rsi = 0.1 * (dataframe['rsi'] - 50)
-    dataframe['fisher_rsi'] = (numpy.exp(2 * rsi) - 1) / (numpy.exp(2 * rsi) + 1)
-
-    # Inverse Fisher transform on RSI normalized, value [0.0, 100.0] (https://goo.gl/2JGGoy)
-    dataframe['fisher_rsi_norma'] = 50 * (dataframe['fisher_rsi'] + 1)
-
-    # Stoch
-    stoch = ta.STOCH(dataframe)
-    dataframe['slowd'] = stoch['slowd']
-    dataframe['slowk'] = stoch['slowk']
-    """
-    # Stoch fast
-    stoch_fast = ta.STOCHF(dataframe)
-    dataframe['fastd'] = stoch_fast['fastd']
-    dataframe['fastk'] = stoch_fast['fastk']
-    """
-    # Stoch RSI
-    stoch_rsi = ta.STOCHRSI(dataframe)
-    dataframe['fastd_rsi'] = stoch_rsi['fastd']
-    dataframe['fastk_rsi'] = stoch_rsi['fastk']
-    """
-
-    # Overlap Studies
-    # ------------------------------------
-
-    # Previous Bollinger bands
-    # Because ta.BBANDS implementation is broken with small numbers, it actually
-    # returns middle band for all the three bands. Switch to qtpylib.bollinger_bands
-    # and use middle band instead.
-    dataframe['blower'] = ta.BBANDS(dataframe, nbdevup=2, nbdevdn=2)['lowerband']
-    """
-    # Bollinger bands
-    """
-    bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2)
-    dataframe['bb_lowerband'] = bollinger['lower']
-    dataframe['bb_middleband'] = bollinger['mid']
-    dataframe['bb_upperband'] = bollinger['upper']
-
-    # EMA - Exponential Moving Average
-    dataframe['ema3'] = ta.EMA(dataframe, timeperiod=3)
-    dataframe['ema5'] = ta.EMA(dataframe, timeperiod=5)
-    dataframe['ema10'] = ta.EMA(dataframe, timeperiod=10)
-    dataframe['ema50'] = ta.EMA(dataframe, timeperiod=50)
-    dataframe['ema100'] = ta.EMA(dataframe, timeperiod=100)
-
-    # SAR Parabol
-    dataframe['sar'] = ta.SAR(dataframe)
-
-    # SMA - Simple Moving Average
-    dataframe['sma'] = ta.SMA(dataframe, timeperiod=40)
-
-    # TEMA - Triple Exponential Moving Average
-    dataframe['tema'] = ta.TEMA(dataframe, timeperiod=9)
-
-    # Cycle Indicator
-    # ------------------------------------
-    # Hilbert Transform Indicator - SineWave
-    hilbert = ta.HT_SINE(dataframe)
-    dataframe['htsine'] = hilbert['sine']
-    dataframe['htleadsine'] = hilbert['leadsine']
-
-    # Pattern Recognition - Bullish candlestick patterns
-    # ------------------------------------
-    """
-    # Hammer: values [0, 100]
-    dataframe['CDLHAMMER'] = ta.CDLHAMMER(dataframe)
-
-    # Inverted Hammer: values [0, 100]
-    dataframe['CDLINVERTEDHAMMER'] = ta.CDLINVERTEDHAMMER(dataframe)
-
-    # Dragonfly Doji: values [0, 100]
-    dataframe['CDLDRAGONFLYDOJI'] = ta.CDLDRAGONFLYDOJI(dataframe)
-
-    # Piercing Line: values [0, 100]
-    dataframe['CDLPIERCING'] = ta.CDLPIERCING(dataframe) # values [0, 100]
-
-    # Morningstar: values [0, 100]
-    dataframe['CDLMORNINGSTAR'] = ta.CDLMORNINGSTAR(dataframe) # values [0, 100]
-
-    # Three White Soldiers: values [0, 100]
-    dataframe['CDL3WHITESOLDIERS'] = ta.CDL3WHITESOLDIERS(dataframe) # values [0, 100]
-    """
-
-    # Pattern Recognition - Bearish candlestick patterns
-    # ------------------------------------
-    """
-    # Hanging Man: values [0, 100]
-    dataframe['CDLHANGINGMAN'] = ta.CDLHANGINGMAN(dataframe)
-
-    # Shooting Star: values [0, 100]
-    dataframe['CDLSHOOTINGSTAR'] = ta.CDLSHOOTINGSTAR(dataframe)
-
-    # Gravestone Doji: values [0, 100]
-    dataframe['CDLGRAVESTONEDOJI'] = ta.CDLGRAVESTONEDOJI(dataframe)
-
-    # Dark Cloud Cover: values [0, 100]
-    dataframe['CDLDARKCLOUDCOVER'] = ta.CDLDARKCLOUDCOVER(dataframe)
-
-    # Evening Doji Star: values [0, 100]
-    dataframe['CDLEVENINGDOJISTAR'] = ta.CDLEVENINGDOJISTAR(dataframe)
-
-    # Evening Star: values [0, 100]
-    dataframe['CDLEVENINGSTAR'] = ta.CDLEVENINGSTAR(dataframe)
-    """
-
-    # Pattern Recognition - Bullish/Bearish candlestick patterns
-    # ------------------------------------
-    """
-    # Three Line Strike: values [0, -100, 100]
-    dataframe['CDL3LINESTRIKE'] = ta.CDL3LINESTRIKE(dataframe)
-
-    # Spinning Top: values [0, -100, 100]
-    dataframe['CDLSPINNINGTOP'] = ta.CDLSPINNINGTOP(dataframe) # values [0, -100, 100]
-
-    # Engulfing: values [0, -100, 100]
-    dataframe['CDLENGULFING'] = ta.CDLENGULFING(dataframe) # values [0, -100, 100]
-
-    # Harami: values [0, -100, 100]
-    dataframe['CDLHARAMI'] = ta.CDLHARAMI(dataframe) # values [0, -100, 100]
-
-    # Three Outside Up/Down: values [0, -100, 100]
-    dataframe['CDL3OUTSIDE'] = ta.CDL3OUTSIDE(dataframe) # values [0, -100, 100]
-
-    # Three Inside Up/Down: values [0, -100, 100]
-    dataframe['CDL3INSIDE'] = ta.CDL3INSIDE(dataframe) # values [0, -100, 100]
-    """
-
-    # Chart type
-    # ------------------------------------
-    # Heikinashi stategy
-    heikinashi = qtpylib.heikinashi(dataframe)
-    dataframe['ha_open'] = heikinashi['open']
-    dataframe['ha_close'] = heikinashi['close']
-    dataframe['ha_high'] = heikinashi['high']
-    dataframe['ha_low'] = heikinashi['low']
-
-    return dataframe
+    strategy = Strategy()
+    return strategy.populate_indicators(dataframe=dataframe)


 def populate_buy_trend(dataframe: DataFrame) -> DataFrame:
@@ -229,20 +55,8 @@ def populate_buy_trend(dataframe: DataFrame) -> DataFrame:
    :param dataframe: DataFrame
    :return: DataFrame with buy column
    """
-    dataframe.loc[
-        (
-            (dataframe['rsi'] < 35) &
-            (dataframe['fastd'] < 35) &
-            (dataframe['adx'] > 30) &
-            (dataframe['plus_di'] > 0.5)
-        ) |
-        (
-            (dataframe['adx'] > 65) &
-            (dataframe['plus_di'] > 0.5)
-        ),
-        'buy'] = 1
-
-    return dataframe
+    strategy = Strategy()
+    return strategy.populate_buy_trend(dataframe=dataframe)


 def populate_sell_trend(dataframe: DataFrame) -> DataFrame:
@@ -251,21 +65,8 @@ def populate_sell_trend(dataframe: DataFrame) -> DataFrame:
    :param dataframe: DataFrame
    :return: DataFrame with buy column
    """
-    dataframe.loc[
-        (
-            (
-                (qtpylib.crossed_above(dataframe['rsi'], 70)) |
-                (qtpylib.crossed_above(dataframe['fastd'], 70))
-            ) &
-            (dataframe['adx'] > 10) &
-            (dataframe['minus_di'] > 0)
-        ) |
-        (
-            (dataframe['adx'] > 70) &
-            (dataframe['minus_di'] > 0.5)
-        ),
-        'sell'] = 1
-    return dataframe
+    strategy = Strategy()
+    return strategy.populate_sell_trend(dataframe=dataframe)


 def analyze_ticker(ticker_history: List[Dict]) -> DataFrame:
--- a/freqtrade/fiat_convert.py
+++ b/freqtrade/fiat_convert.py
@@ -48,7 +48,10 @@ class CryptoFiat():
        return self._expiration - time.time() <= 0


-class CryptoToFiatConverter():
+class CryptoToFiatConverter(object):
+    __instance = None
+    _coinmarketcap = None
+
    # Constants
    SUPPORTED_FIAT = [
        "AUD", "BRL", "CAD", "CHF", "CLP", "CNY", "CZK", "DKK",
@@ -57,12 +60,16 @@ class CryptoToFiatConverter():
        "RUB", "SEK", "SGD", "THB", "TRY", "TWD", "ZAR", "USD"
    ]

-    def __init__(self) -> None:
-        try:
-            self._coinmarketcap = Pymarketcap()
-        except BaseException:
-            self._coinmarketcap = None
+    def __new__(cls):
+        if CryptoToFiatConverter.__instance is None:
+            CryptoToFiatConverter.__instance = object.__new__(cls)
+            try:
+                CryptoToFiatConverter._coinmarketcap = Pymarketcap()
+            except BaseException:
+                CryptoToFiatConverter._coinmarketcap = None
+        return CryptoToFiatConverter.__instance

+    def __init__(self) -> None:
        self._pairs = []

    def convert_amount(self, crypto_amount: float, crypto_symbol: str, fiat_symbol: str) -> float:
--- a/freqtrade/main.py
+++ b/freqtrade/main.py
@@ -19,6 +19,7 @@ from freqtrade.fiat_convert import CryptoToFiatConverter
 from freqtrade.misc import (State, get_state, load_config, parse_args,
                            throttle, update_state)
 from freqtrade.persistence import Trade
+from freqtrade.strategy.strategy import Strategy

 logger = logging.getLogger('freqtrade')

@@ -191,12 +192,25 @@ def execute_sell(trade: Trade, limit: float) -> None:

    fmt_exp_profit = round(trade.calc_profit_percent(rate=limit) * 100, 2)
    profit_trade = trade.calc_profit(rate=limit)
+    current_rate = exchange.get_ticker(trade.pair, False)['bid']
+    profit = trade.calc_profit_percent(current_rate)

-    message = '*{exchange}:* Selling [{pair}]({pair_url}) with limit `{limit:.8f}`'.format(
+    message = """*{exchange}:* Selling
+*Current Pair:* [{pair}]({pair_url})
+*Limit:* `{limit}`
+*Amount:* `{amount}`
+*Open Rate:* `{open_rate:.8f}`
+*Current Rate:* `{current_rate:.8f}`
+*Profit:* `{profit:.2f}%`
+    """.format(
        exchange=trade.exchange,
-        pair=trade.pair.replace('_', '/'),
+        pair=trade.pair,
        pair_url=exchange.get_pair_detail_url(trade.pair),
-        limit=limit
+        limit=limit,
+        open_rate=trade.open_rate,
+        current_rate=current_rate,
+        amount=round(trade.amount, 8),
+        profit=round(profit * 100, 2),
    )

    # For regular case, when the configuration exists
@@ -235,14 +249,16 @@ def min_roi_reached(trade: Trade, current_rate: float, current_time: datetime) -
    Based an earlier trade and current price and ROI configuration, decides whether bot should sell
    :return True if bot should sell at current rate
    """
+    strategy = Strategy()
+
    current_profit = trade.calc_profit_percent(current_rate)
-    if 'stoploss' in _CONF and current_profit < float(_CONF['stoploss']):
+    if strategy.stoploss is not None and current_profit < float(strategy.stoploss):
        logger.debug('Stop loss hit.')
        return True

    # Check if time matches and current rate is above threshold
    time_diff = (current_time - trade.open_date).total_seconds() / 60
-    for duration, threshold in sorted(_CONF['minimal_roi'].items()):
+    for duration, threshold in sorted(strategy.minimal_roi.items()):
        if time_diff > float(duration) and current_profit > threshold:
            return True

@@ -378,6 +394,9 @@ def init(config: dict, db_url: Optional[str] = None) -> None:
    persistence.init(config, db_url)
    exchange.init(config)

+    strategy = Strategy()
+    strategy.init(config)
+
    # Set initial application state
    initial_state = config.get('initial_state')
    if initial_state:
@@ -445,6 +464,9 @@ def main(sysargv=sys.argv[1:]) -> None:
    # Load and validate configuration
    _CONF = load_config(args.config)

+    # Add the strategy file to use
+    _CONF.update({'strategy': args.strategy})
+
    # Initialize all modules and start main loop
    if args.dynamic_whitelist:
        logger.info('Using dynamically generated whitelist. (--dynamic-whitelist detected)')
@@ -462,6 +484,7 @@ def main(sysargv=sys.argv[1:]) -> None:
    try:
        init(_CONF)
        old_state = None
+
        while True:
            new_state = get_state()
            # Log state transition
@@ -476,7 +499,7 @@ def main(sysargv=sys.argv[1:]) -> None:
                    _process,
                    min_secs=_CONF['internals'].get('process_throttle_secs', 10),
                    nb_assets=args.dynamic_whitelist,
-                    interval=int(_CONF.get('ticker_interval', "5"))
+                    interval=int(_CONF.get('ticker_interval', 5))
                )
            old_state = new_state
    except KeyboardInterrupt:
--- a/freqtrade/misc.py
+++ b/freqtrade/misc.py
@@ -159,6 +159,14 @@ def common_args_parser(description: str):
        type=str,
        metavar='PATH',
    )
+    parser.add_argument(
+        '-s', '--strategy',
+        help='specify strategy file (default: freqtrade/strategy/default_strategy.py)',
+        dest='strategy',
+        default='.default_strategy',
+        type=str,
+        metavar='PATH',
+    )
    return parser


@@ -328,7 +336,7 @@ CONF_SCHEMA = {
    'type': 'object',
    'properties': {
        'max_open_trades': {'type': 'integer', 'minimum': 1},
-        'ticker_interval': {'type': 'string', 'enum': ['1', '5', '30', '60', '1440']},
+        'ticker_interval': {'type': 'integer', 'enum': [1, 5, 30, 60, 1440]},
        'stake_currency': {'type': 'string', 'enum': ['BTC', 'ETH', 'USDT']},
        'stake_amount': {'type': 'number', 'minimum': 0.0005},
        'fiat_display_currency': {'type': 'string', 'enum': ['AUD', 'BRL', 'CAD', 'CHF',
@@ -419,12 +427,10 @@ CONF_SCHEMA = {
    ],
    'required': [
        'max_open_trades',
-        'ticker_interval',
        'stake_currency',
        'stake_amount',
        'fiat_display_currency',
        'dry_run',
-        'minimal_roi',
        'bid_strategy',
        'telegram'
    ]
--- a/freqtrade/optimize/init.py
+++ b/freqtrade/optimize/init.py
@@ -6,9 +6,10 @@ import os
 from typing import Optional, List, Dict
 from pandas import DataFrame
 from freqtrade.exchange import get_ticker_history
-from freqtrade.optimize.hyperopt_conf import hyperopt_optimize_conf
 from freqtrade.analyze import populate_indicators, parse_ticker_dataframe
+
 from freqtrade import misc
+from user_data.hyperopt_conf import hyperopt_optimize_conf

 logger = logging.getLogger(__name__)

@@ -127,7 +128,6 @@ def download_backtesting_testdata(datadir: str, pair: str, interval: int = 5) ->
        pair=filepair,
        interval=interval,
    ))
-    filename = filename.replace('USDT_BTC', 'BTC_FAKEBULL')

    if os.path.isfile(filename):
        with open(filename, "rt") as fp:
--- a/freqtrade/optimize/backtesting.py
+++ b/freqtrade/optimize/backtesting.py
@@ -14,6 +14,7 @@ from freqtrade.analyze import populate_buy_trend, populate_sell_trend
 from freqtrade.exchange import Bittrex
 from freqtrade.main import min_roi_reached
 from freqtrade.persistence import Trade
+from freqtrade.strategy.strategy import Strategy

 logger = logging.getLogger(__name__)

@@ -199,6 +200,11 @@ def start(args):
        logger.info('Using max_open_trades: %s ...', config['max_open_trades'])
        max_open_trades = config['max_open_trades']

+    # init the strategy to use
+    config.update({'strategy': args.strategy})
+    strategy = Strategy()
+    strategy.init(config)
+
    # Monkey patch config
    from freqtrade import main
    main._CONF = config
@@ -216,7 +222,7 @@ def start(args):
                        'realistic': args.realistic_simulation,
                        'sell_profit_only': sell_profit_only,
                        'use_sell_signal': use_sell_signal,
-                        'stoploss': config.get('stoploss'),
+                        'stoploss': strategy.stoploss,
                        'record': args.export
                        })
    logger.info(
--- a/freqtrade/optimize/hyperopt.py
+++ b/freqtrade/optimize/hyperopt.py
@@ -3,25 +3,31 @@

 import json
 import logging
-import sys
+import os
 import pickle
 import signal
-import os
+import sys
 from functools import reduce
 from math import exp
 from operator import itemgetter
+from typing import Dict, List

+import numpy
+import talib.abstract as ta
 from hyperopt import STATUS_FAIL, STATUS_OK, Trials, fmin, hp, space_eval, tpe
 from hyperopt.mongoexp import MongoTrials
 from pandas import DataFrame

-from freqtrade import main, misc  # noqa
-from freqtrade import exchange, optimize
+import freqtrade.vendor.qtpylib.indicators as qtpylib
+# Monkey patch config
+from freqtrade import main  # noqa; noqa
+from freqtrade import exchange, misc, optimize
 from freqtrade.exchange import Bittrex
 from freqtrade.misc import load_config
+from freqtrade.optimize import backtesting
 from freqtrade.optimize.backtesting import backtest
-from freqtrade.optimize.hyperopt_conf import hyperopt_optimize_conf
-from freqtrade.vendor.qtpylib.indicators import crossed_above
+from freqtrade.strategy.strategy import Strategy
+from user_data.hyperopt_conf import hyperopt_optimize_conf

 # Remove noisy log messages
 logging.getLogger('hyperopt.mongoexp').setLevel(logging.WARNING)
@@ -49,69 +55,130 @@ PROCESSED = None  # optimize.preprocess(optimize.load_data())
 OPTIMIZE_CONFIG = hyperopt_optimize_conf()

 # Hyperopt Trials
-TRIALS_FILE = os.path.join('freqtrade', 'optimize', 'hyperopt_trials.pickle')
+TRIALS_FILE = os.path.join('user_data', 'hyperopt_trials.pickle')
 TRIALS = Trials()

-# Monkey patch config
-from freqtrade import main  # noqa
 main._CONF = OPTIMIZE_CONFIG


-SPACE = {
-    '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', 5, 25, 1)}
-    ]),
-    'fastd': hp.choice('fastd', [
-        {'enabled': False},
-        {'enabled': True, 'value': hp.quniform('fastd-value', 10, 50, 1)}
-    ]),
-    'adx': hp.choice('adx', [
-        {'enabled': False},
-        {'enabled': True, 'value': hp.quniform('adx-value', 15, 50, 1)}
-    ]),
-    'rsi': hp.choice('rsi', [
-        {'enabled': False},
-        {'enabled': True, 'value': hp.quniform('rsi-value', 20, 40, 1)}
-    ]),
-    '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'},
-    ]),
-    'stoploss': hp.uniform('stoploss', -0.5, -0.02),
-}
+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']
+    # 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


 def save_trials(trials, trials_path=TRIALS_FILE):
@@ -158,10 +225,145 @@ def calculate_loss(total_profit: float, trade_count: int, trade_duration: float)
    return trade_loss + profit_loss + duration_loss


+def hyperopt_space() -> List[Dict]:
+    """
+    Define your Hyperopt space for searching strategy parameters
+    """
+    space = {
+        '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', 5, 25, 1)}
+        ]),
+        'fastd': hp.choice('fastd', [
+            {'enabled': False},
+            {'enabled': True, 'value': hp.quniform('fastd-value', 10, 50, 1)}
+        ]),
+        'adx': hp.choice('adx', [
+            {'enabled': False},
+            {'enabled': True, 'value': hp.quniform('adx-value', 15, 50, 1)}
+        ]),
+        'rsi': hp.choice('rsi', [
+            {'enabled': False},
+            {'enabled': True, 'value': hp.quniform('rsi-value', 20, 40, 1)}
+        ]),
+        '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'},
+        ]),
+        'stoploss': hp.uniform('stoploss', -0.5, -0.02),
+    }
+    return space
+
+
+def buy_strategy_generator(params) -> None:
+    """
+    Define the buy strategy parameters to be used by hyperopt
+    """
+    def populate_buy_trend(dataframe: DataFrame) -> DataFrame:
+        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)
+
+        # 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(
+                dataframe['macd'], dataframe['macdsignal']
+            )),
+            'sar_reversal': (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),
+            'buy'] = 1
+
+        return dataframe
+
+    return populate_buy_trend
+
+
 def optimizer(params):
    global _CURRENT_TRIES

-    from freqtrade.optimize import backtesting
    backtesting.populate_buy_trend = buy_strategy_generator(params)

    results = backtest({'stake_amount': OPTIMIZE_CONFIG['stake_amount'],
@@ -209,58 +411,8 @@ def format_results(results: DataFrame):
            )


-def buy_strategy_generator(params):
-    def populate_buy_trend(dataframe: DataFrame) -> DataFrame:
-        conditions = []
-        # GUARDS AND TRENDS
-        if params['uptrend_long_ema']['enabled']:
-            conditions.append(dataframe['ema50'] > dataframe['ema100'])
-        if params['macd_below_zero']['enabled']:
-            conditions.append(dataframe['macd'] < 0)
-        if params['uptrend_short_ema']['enabled']:
-            conditions.append(dataframe['ema5'] > dataframe['ema10'])
-        if params['mfi']['enabled']:
-            conditions.append(dataframe['mfi'] < params['mfi']['value'])
-        if params['fastd']['enabled']:
-            conditions.append(dataframe['fastd'] < params['fastd']['value'])
-        if params['adx']['enabled']:
-            conditions.append(dataframe['adx'] > params['adx']['value'])
-        if params['rsi']['enabled']:
-            conditions.append(dataframe['rsi'] < params['rsi']['value'])
-        if params['over_sar']['enabled']:
-            conditions.append(dataframe['close'] > dataframe['sar'])
-        if params['green_candle']['enabled']:
-            conditions.append(dataframe['close'] > dataframe['open'])
-        if params['uptrend_sma']['enabled']:
-            prevsma = dataframe['sma'].shift(1)
-            conditions.append(dataframe['sma'] > prevsma)
-
-        # TRIGGERS
-        triggers = {
-            'lower_bb': (dataframe['close'] < dataframe['bb_lowerband']),
-            'lower_bb_tema': (dataframe['tema'] < dataframe['bb_lowerband']),
-            'faststoch10': (crossed_above(dataframe['fastd'], 10.0)),
-            'ao_cross_zero': (crossed_above(dataframe['ao'], 0.0)),
-            'ema3_cross_ema10': (crossed_above(dataframe['ema3'], dataframe['ema10'])),
-            'macd_cross_signal': (crossed_above(dataframe['macd'], dataframe['macdsignal'])),
-            'sar_reversal': (crossed_above(dataframe['close'], dataframe['sar'])),
-            'ht_sine': (crossed_above(dataframe['htleadsine'], dataframe['htsine'])),
-            'heiken_reversal_bull': (crossed_above(dataframe['ha_close'], dataframe['ha_open'])) &
-                                    (dataframe['ha_low'] == dataframe['ha_open']),
-            'di_cross': (crossed_above(dataframe['plus_di'], dataframe['minus_di'])),
-        }
-        conditions.append(triggers.get(params['trigger']['type']))
-
-        dataframe.loc[
-            reduce(lambda x, y: x & y, conditions),
-            'buy'] = 1
-
-        return dataframe
-    return populate_buy_trend
-
-
 def start(args):
-    global TOTAL_TRIES, PROCESSED, SPACE, TRIALS, _CURRENT_TRIES
+    global TOTAL_TRIES, PROCESSED, TRIALS, _CURRENT_TRIES

    TOTAL_TRIES = args.epochs

@@ -275,10 +427,17 @@ def start(args):
    logger.info('Using config: %s ...', args.config)
    config = load_config(args.config)
    pairs = config['exchange']['pair_whitelist']
+
+    # init the strategy to use
+    config.update({'strategy': args.strategy})
+    strategy = Strategy()
+    strategy.init(config)
+
    timerange = misc.parse_timerange(args.timerange)
    data = optimize.load_data(args.datadir, pairs=pairs,
                              ticker_interval=args.ticker_interval,
                              timerange=timerange)
+    optimize.populate_indicators = populate_indicators
    PROCESSED = optimize.tickerdata_to_dataframe(data)

    if args.mongodb:
@@ -303,7 +462,7 @@ def start(args):
    try:
        best_parameters = fmin(
            fn=optimizer,
-            space=SPACE,
+            space=hyperopt_space(),
            algo=tpe.suggest,
            max_evals=TOTAL_TRIES,
            trials=TRIALS
@@ -319,7 +478,10 @@ def start(args):

    # Improve best parameter logging display
    if best_parameters:
-        best_parameters = space_eval(SPACE, best_parameters)
+        best_parameters = space_eval(
+            hyperopt_space(),
+            best_parameters
+        )

    logger.info('Best parameters:\n%s', json.dumps(best_parameters, indent=4))
    logger.info('Best Result:\n%s', best_result)
--- a/freqtrade/optimize/hyperopt_conf.py
+++ b/freqtrade/optimize/hyperopt_conf.py
@@ -1,41 +0,0 @@
-"""
-File that contains the configuration for Hyperopt
-"""
-
-
-def hyperopt_optimize_conf() -> dict:
-    """
-    This function is used to define which parameters Hyperopt must used.
-    The "pair_whitelist" is only used is your are using Hyperopt with MongoDB,
-    without MongoDB, Hyperopt will use the pair your have set in your config file.
-    :return:
-    """
-    return {
-        'max_open_trades': 3,
-        'stake_currency': 'BTC',
-        'stake_amount': 0.01,
-        "minimal_roi": {
-            '40': 0.0,
-            '30': 0.01,
-            '20': 0.02,
-            '0': 0.04,
-        },
-        'stoploss': -0.10,
-        "bid_strategy": {
-            "ask_last_balance": 0.0
-        },
-        "exchange": {
-            "pair_whitelist": [
-                "BTC_ETH",
-                "BTC_LTC",
-                "BTC_ETC",
-                "BTC_DASH",
-                "BTC_ZEC",
-                "BTC_XLM",
-                "BTC_NXT",
-                "BTC_POWR",
-                "BTC_ADA",
-                "BTC_XMR"
-            ]
-        }
-    }
--- a/freqtrade/persistence.py
+++ b/freqtrade/persistence.py
@@ -47,6 +47,10 @@ def init(config: dict, engine: Optional[Engine] = None) -> None:
    Trade.query = session.query_property()
    _DECL_BASE.metadata.create_all(engine)

+    # Clean dry_run DB
+    if _CONF.get('dry_run', False) and _CONF.get('dry_run_db', False):
+        clean_dry_run_db()
+

 def cleanup() -> None:
    """
@@ -56,6 +60,17 @@ def cleanup() -> None:
    Trade.session.flush()


+def clean_dry_run_db() -> None:
+    """
+    Remove open_order_id from a Dry_run DB
+    :return: None
+    """
+    for trade in Trade.query.filter(Trade.open_order_id.isnot(None)).all():
+        # Check we are updating only a dry_run order not a prod one
+        if 'dry_run' in trade.open_order_id:
+            trade.open_order_id = None
+
+
 class Trade(_DECL_BASE):
    __tablename__ = 'trades'

--- a/freqtrade/rpc/telegram.py
+++ b/freqtrade/rpc/telegram.py
@@ -147,7 +147,7 @@ def _status(bot: Bot, update: Update) -> None:
            ) if trade.close_profit else None
            message = """
 *Trade ID:* `{trade_id}`
-*Current Pair:* [{pair}]({market_url})
+*Current Pair:* [{pair}]({pair_url})
 *Open Since:* `{date}`
 *Amount:* `{amount}`
 *Open Rate:* `{open_rate:.8f}`
@@ -156,10 +156,11 @@ def _status(bot: Bot, update: Update) -> None:
 *Close Profit:* `{close_profit}`
 *Current Profit:* `{current_profit:.2f}%`
 *Open Order:* `{open_order}`
+*Total Open Trades:* `{total_trades}`
            """.format(
                trade_id=trade.id,
                pair=trade.pair,
-                market_url=exchange.get_pair_detail_url(trade.pair),
+                pair_url=exchange.get_pair_detail_url(trade.pair),
                date=arrow.get(trade.open_date).humanize(),
                open_rate=trade.open_rate,
                close_rate=trade.close_rate,
@@ -170,6 +171,7 @@ def _status(bot: Bot, update: Update) -> None:
                open_order='({} rem={:.8f})'.format(
                    order['type'], order['remaining']
                ) if order else None,
+                total_trades=len(trades)
            )
            send_msg(message, bot=bot)

--- a/freqtrade/strategy/init.py
+++ b/freqtrade/strategy/init.py
--- a/freqtrade/strategy/default_strategy.py
+++ b/freqtrade/strategy/default_strategy.py
@@ -0,0 +1,238 @@
+import talib.abstract as ta
+import freqtrade.vendor.qtpylib.indicators as qtpylib
+from freqtrade.strategy.interface import IStrategy
+from pandas import DataFrame
+
+
+class_name = 'DefaultStrategy'
+
+
+class DefaultStrategy(IStrategy):
+    """
+    Default Strategy provided by freqtrade bot.
+    You can override it with your own strategy
+    """
+
+    # Minimal ROI designed for the strategy
+    minimal_roi = {
+        "40":  0.0,
+        "30":  0.01,
+        "20":  0.02,
+        "0":  0.04
+    }
+
+    # Optimal stoploss designed for the strategy
+    stoploss = -0.10
+
+    # Optimal ticker interval for the strategy
+    ticker_interval = 5
+
+    def populate_indicators(self, dataframe: DataFrame) -> DataFrame:
+        """
+        Adds several different TA indicators to the given DataFrame
+
+        Performance Note: For the best performance be frugal on the number of indicators
+        you are using. Let uncomment only the indicator you are using in your strategies
+        or your hyperopt configuration, otherwise you will waste your memory and CPU usage.
+        """
+
+        # Momentum Indicator
+        # ------------------------------------
+
+        # ADX
+        dataframe['adx'] = ta.ADX(dataframe)
+
+        # Awesome oscillator
+        dataframe['ao'] = qtpylib.awesome_oscillator(dataframe)
+        """
+        # Commodity Channel Index: values Oversold:<-100, Overbought:>100
+        dataframe['cci'] = ta.CCI(dataframe)
+        """
+        # MACD
+        macd = ta.MACD(dataframe)
+        dataframe['macd'] = macd['macd']
+        dataframe['macdsignal'] = macd['macdsignal']
+        dataframe['macdhist'] = macd['macdhist']
+
+        # MFI
+        dataframe['mfi'] = ta.MFI(dataframe)
+
+        # Minus Directional Indicator / Movement
+        dataframe['minus_dm'] = ta.MINUS_DM(dataframe)
+        dataframe['minus_di'] = ta.MINUS_DI(dataframe)
+
+        # Plus Directional Indicator / Movement
+        dataframe['plus_dm'] = ta.PLUS_DM(dataframe)
+        dataframe['plus_di'] = ta.PLUS_DI(dataframe)
+        dataframe['minus_di'] = ta.MINUS_DI(dataframe)
+
+        """
+        # ROC
+        dataframe['roc'] = ta.ROC(dataframe)
+        """
+        # RSI
+        dataframe['rsi'] = ta.RSI(dataframe)
+        """
+        # Inverse Fisher transform on RSI, values [-1.0, 1.0] (https://goo.gl/2JGGoy)
+        rsi = 0.1 * (dataframe['rsi'] - 50)
+        dataframe['fisher_rsi'] = (numpy.exp(2 * rsi) - 1) / (numpy.exp(2 * rsi) + 1)
+        # Inverse Fisher transform on RSI normalized, value [0.0, 100.0] (https://goo.gl/2JGGoy)
+        dataframe['fisher_rsi_norma'] = 50 * (dataframe['fisher_rsi'] + 1)
+        # Stoch
+        stoch = ta.STOCH(dataframe)
+        dataframe['slowd'] = stoch['slowd']
+        dataframe['slowk'] = stoch['slowk']
+        """
+        # Stoch fast
+        stoch_fast = ta.STOCHF(dataframe)
+        dataframe['fastd'] = stoch_fast['fastd']
+        dataframe['fastk'] = stoch_fast['fastk']
+        """
+        # Stoch RSI
+        stoch_rsi = ta.STOCHRSI(dataframe)
+        dataframe['fastd_rsi'] = stoch_rsi['fastd']
+        dataframe['fastk_rsi'] = stoch_rsi['fastk']
+        """
+
+        # Overlap Studies
+        # ------------------------------------
+
+        # Previous Bollinger bands
+        # Because ta.BBANDS implementation is broken with small numbers, it actually
+        # returns middle band for all the three bands. Switch to qtpylib.bollinger_bands
+        # and use middle band instead.
+        dataframe['blower'] = ta.BBANDS(dataframe, nbdevup=2, nbdevdn=2)['lowerband']
+
+        # Bollinger bands
+        bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2)
+        dataframe['bb_lowerband'] = bollinger['lower']
+        dataframe['bb_middleband'] = bollinger['mid']
+        dataframe['bb_upperband'] = bollinger['upper']
+
+        # EMA - Exponential Moving Average
+        dataframe['ema3'] = ta.EMA(dataframe, timeperiod=3)
+        dataframe['ema5'] = ta.EMA(dataframe, timeperiod=5)
+        dataframe['ema10'] = ta.EMA(dataframe, timeperiod=10)
+        dataframe['ema50'] = ta.EMA(dataframe, timeperiod=50)
+        dataframe['ema100'] = ta.EMA(dataframe, timeperiod=100)
+
+        # SAR Parabol
+        dataframe['sar'] = ta.SAR(dataframe)
+
+        # SMA - Simple Moving Average
+        dataframe['sma'] = ta.SMA(dataframe, timeperiod=40)
+
+        # TEMA - Triple Exponential Moving Average
+        dataframe['tema'] = ta.TEMA(dataframe, timeperiod=9)
+
+        # Cycle Indicator
+        # ------------------------------------
+        # Hilbert Transform Indicator - SineWave
+        hilbert = ta.HT_SINE(dataframe)
+        dataframe['htsine'] = hilbert['sine']
+        dataframe['htleadsine'] = hilbert['leadsine']
+
+        # Pattern Recognition - Bullish candlestick patterns
+        # ------------------------------------
+        """
+        # Hammer: values [0, 100]
+        dataframe['CDLHAMMER'] = ta.CDLHAMMER(dataframe)
+        # Inverted Hammer: values [0, 100]
+        dataframe['CDLINVERTEDHAMMER'] = ta.CDLINVERTEDHAMMER(dataframe)
+        # Dragonfly Doji: values [0, 100]
+        dataframe['CDLDRAGONFLYDOJI'] = ta.CDLDRAGONFLYDOJI(dataframe)
+        # Piercing Line: values [0, 100]
+        dataframe['CDLPIERCING'] = ta.CDLPIERCING(dataframe) # values [0, 100]
+        # Morningstar: values [0, 100]
+        dataframe['CDLMORNINGSTAR'] = ta.CDLMORNINGSTAR(dataframe) # values [0, 100]
+        # Three White Soldiers: values [0, 100]
+        dataframe['CDL3WHITESOLDIERS'] = ta.CDL3WHITESOLDIERS(dataframe) # values [0, 100]
+        """
+
+        # Pattern Recognition - Bearish candlestick patterns
+        # ------------------------------------
+        """
+        # Hanging Man: values [0, 100]
+        dataframe['CDLHANGINGMAN'] = ta.CDLHANGINGMAN(dataframe)
+        # Shooting Star: values [0, 100]
+        dataframe['CDLSHOOTINGSTAR'] = ta.CDLSHOOTINGSTAR(dataframe)
+        # Gravestone Doji: values [0, 100]
+        dataframe['CDLGRAVESTONEDOJI'] = ta.CDLGRAVESTONEDOJI(dataframe)
+        # Dark Cloud Cover: values [0, 100]
+        dataframe['CDLDARKCLOUDCOVER'] = ta.CDLDARKCLOUDCOVER(dataframe)
+        # Evening Doji Star: values [0, 100]
+        dataframe['CDLEVENINGDOJISTAR'] = ta.CDLEVENINGDOJISTAR(dataframe)
+        # Evening Star: values [0, 100]
+        dataframe['CDLEVENINGSTAR'] = ta.CDLEVENINGSTAR(dataframe)
+        """
+
+        # Pattern Recognition - Bullish/Bearish candlestick patterns
+        # ------------------------------------
+        """
+        # Three Line Strike: values [0, -100, 100]
+        dataframe['CDL3LINESTRIKE'] = ta.CDL3LINESTRIKE(dataframe)
+        # Spinning Top: values [0, -100, 100]
+        dataframe['CDLSPINNINGTOP'] = ta.CDLSPINNINGTOP(dataframe) # values [0, -100, 100]
+        # Engulfing: values [0, -100, 100]
+        dataframe['CDLENGULFING'] = ta.CDLENGULFING(dataframe) # values [0, -100, 100]
+        # Harami: values [0, -100, 100]
+        dataframe['CDLHARAMI'] = ta.CDLHARAMI(dataframe) # values [0, -100, 100]
+        # Three Outside Up/Down: values [0, -100, 100]
+        dataframe['CDL3OUTSIDE'] = ta.CDL3OUTSIDE(dataframe) # values [0, -100, 100]
+        # Three Inside Up/Down: values [0, -100, 100]
+        dataframe['CDL3INSIDE'] = ta.CDL3INSIDE(dataframe) # values [0, -100, 100]
+        """
+
+        # Chart type
+        # ------------------------------------
+        # Heikinashi stategy
+        heikinashi = qtpylib.heikinashi(dataframe)
+        dataframe['ha_open'] = heikinashi['open']
+        dataframe['ha_close'] = heikinashi['close']
+        dataframe['ha_high'] = heikinashi['high']
+        dataframe['ha_low'] = heikinashi['low']
+
+        return dataframe
+
+    def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
+        """
+        Based on TA indicators, populates the buy signal for the given dataframe
+        :param dataframe: DataFrame
+        :return: DataFrame with buy column
+        """
+        dataframe.loc[
+            (
+                (dataframe['rsi'] < 35) &
+                (dataframe['fastd'] < 35) &
+                (dataframe['adx'] > 30) &
+                (dataframe['plus_di'] > 0.5)
+            ) |
+            (
+                (dataframe['adx'] > 65) &
+                (dataframe['plus_di'] > 0.5)
+            ),
+            'buy'] = 1
+
+        return dataframe
+
+    def populate_sell_trend(self, dataframe: DataFrame) -> DataFrame:
+        """
+        Based on TA indicators, populates the sell signal for the given dataframe
+        :param dataframe: DataFrame
+        :return: DataFrame with buy column
+        """
+        dataframe.loc[
+            (
+                (
+                    (qtpylib.crossed_above(dataframe['rsi'], 70)) |
+                    (qtpylib.crossed_above(dataframe['fastd'], 70))
+                ) &
+                (dataframe['adx'] > 10) &
+                (dataframe['minus_di'] > 0)
+            ) |
+            (
+                (dataframe['adx'] > 70) &
+                (dataframe['minus_di'] > 0.5)
+            ),
+            'sell'] = 1
+        return dataframe
--- a/freqtrade/strategy/interface.py
+++ b/freqtrade/strategy/interface.py
@@ -0,0 +1,44 @@
+from abc import ABC, abstractmethod
+from pandas import DataFrame
+
+
+class IStrategy(ABC):
+    @property
+    def name(self) -> str:
+        """
+        Name of the strategy.
+        :return: str representation of the class name
+        """
+        return self.__class__.__name__
+
+    """
+    Attributes you can use:
+        minimal_roi -> Dict: Minimal ROI designed for the strategy
+        stoploss -> float: optimal stoploss designed for the strategy
+        ticker_interval -> int: value of the ticker interval to use for the strategy
+    """
+
+    @abstractmethod
+    def populate_indicators(self, dataframe: DataFrame) -> DataFrame:
+        """
+        Populate indicators that will be used in the Buy and Sell strategy
+        :param dataframe: Raw data from the exchange and parsed by parse_ticker_dataframe()
+        :return: a Dataframe with all mandatory indicators for the strategies
+        """
+
+    @abstractmethod
+    def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
+        """
+        Based on TA indicators, populates the buy signal for the given dataframe
+        :param dataframe: DataFrame
+        :return: DataFrame with buy column
+        :return:
+        """
+
+    @abstractmethod
+    def populate_sell_trend(self, dataframe: DataFrame) -> DataFrame:
+        """
+        Based on TA indicators, populates the sell signal for the given dataframe
+        :param dataframe: DataFrame
+        :return: DataFrame with buy column
+        """
--- a/freqtrade/strategy/strategy.py
+++ b/freqtrade/strategy/strategy.py
@@ -0,0 +1,166 @@
+import os
+import sys
+import logging
+import importlib
+
+from pandas import DataFrame
+from typing import Dict
+from freqtrade.strategy.interface import IStrategy
+
+
+sys.path.insert(0, r'../../user_data/strategies')
+
+
+class Strategy(object):
+    __instance = None
+
+    DEFAULT_STRATEGY = 'default_strategy'
+
+    def __new__(cls):
+        if Strategy.__instance is None:
+            Strategy.__instance = object.__new__(cls)
+        return Strategy.__instance
+
+    def init(self, config):
+        self.logger = logging.getLogger(__name__)
+
+        # Verify the strategy is in the configuration, otherwise fallback to the default strategy
+        if 'strategy' in config:
+            strategy = config['strategy']
+        else:
+            strategy = self.DEFAULT_STRATEGY
+
+        # Load the strategy
+        self._load_strategy(strategy)
+
+        # Set attributes
+        # Check if we need to override configuration
+        if 'minimal_roi' in config:
+            self.custom_strategy.minimal_roi = config['minimal_roi']
+            self.logger.info("Override strategy \'minimal_roi\' with value in config file.")
+
+        if 'stoploss' in config:
+            self.custom_strategy.stoploss = config['stoploss']
+            self.logger.info(
+                "Override strategy \'stoploss\' with value in config file: {}.".format(
+                    config['stoploss']
+                )
+            )
+
+        if 'ticker_interval' in config:
+            self.custom_strategy.ticker_interval = config['ticker_interval']
+            self.logger.info(
+                "Override strategy \'ticker_interval\' with value in config file: {}.".format(
+                    config['ticker_interval']
+                )
+            )
+
+        self.minimal_roi = self.custom_strategy.minimal_roi
+        self.stoploss = self.custom_strategy.stoploss
+        self.ticker_interval = self.custom_strategy.ticker_interval
+
+    def _load_strategy(self, strategy_name: str) -> None:
+        """
+        Search and load the custom strategy. If no strategy found, fallback on the default strategy
+        Set the object into self.custom_strategy
+        :param strategy_name: name of the module to import
+        :return: None
+        """
+
+        try:
+            # Start by sanitizing the file name (remove any extensions)
+            strategy_name = self._sanitize_module_name(filename=strategy_name)
+
+            # Search where can be the strategy file
+            path = self._search_strategy(filename=strategy_name)
+
+            # Load the strategy
+            self.custom_strategy = self._load_class(path + strategy_name)
+
+        # Fallback to the default strategy
+        except (ImportError, TypeError):
+            self.custom_strategy = self._load_class('.' + self.DEFAULT_STRATEGY)
+
+    def _load_class(self, filename: str) -> IStrategy:
+        """
+        Import a strategy as a module
+        :param filename: path to the strategy (path from freqtrade/strategy/)
+        :return: return the strategy class
+        """
+        module = importlib.import_module(filename, __package__)
+        custom_strategy = getattr(module, module.class_name)
+
+        self.logger.info("Load strategy class: {} ({}.py)".format(module.class_name, filename))
+        return custom_strategy()
+
+    @staticmethod
+    def _sanitize_module_name(filename: str) -> str:
+        """
+        Remove any extension from filename
+        :param filename: filename to sanatize
+        :return: return the filename without extensions
+        """
+        filename = os.path.basename(filename)
+        filename = os.path.splitext(filename)[0]
+        return filename
+
+    @staticmethod
+    def _search_strategy(filename: str) -> str:
+        """
+        Search for the Strategy file in different folder
+        1. search into the user_data/strategies folder
+        2. search into the freqtrade/strategy folder
+        3. if nothing found, return None
+        :param strategy_name: module name to search
+        :return: module path where is the strategy
+        """
+        pwd = os.path.dirname(os.path.realpath(__file__)) + '/'
+        user_data = os.path.join(pwd, '..', '..', 'user_data', 'strategies', filename + '.py')
+        strategy_folder = os.path.join(pwd, filename + '.py')
+
+        path = None
+        if os.path.isfile(user_data):
+            path = 'user_data.strategies.'
+        elif os.path.isfile(strategy_folder):
+            path = '.'
+
+        return path
+
+    def minimal_roi(self) -> Dict:
+        """
+        Minimal ROI designed for the strategy
+        :return: Dict: Value for the Minimal ROI
+        """
+        return
+
+    def stoploss(self) -> float:
+        """
+        Optimal stoploss designed for the strategy
+        :return: float | return None to disable it
+        """
+        return self.custom_strategy.stoploss
+
+    def populate_indicators(self, dataframe: DataFrame) -> DataFrame:
+        """
+        Populate indicators that will be used in the Buy and Sell strategy
+        :param dataframe: Raw data from the exchange and parsed by parse_ticker_dataframe()
+        :return: a Dataframe with all mandatory indicators for the strategies
+        """
+        return self.custom_strategy.populate_indicators(dataframe)
+
+    def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
+        """
+        Based on TA indicators, populates the buy signal for the given dataframe
+        :param dataframe: DataFrame
+        :return: DataFrame with buy column
+        :return:
+        """
+        return self.custom_strategy.populate_buy_trend(dataframe)
+
+    def populate_sell_trend(self, dataframe: DataFrame) -> DataFrame:
+        """
+        Based on TA indicators, populates the sell signal for the given dataframe
+        :param dataframe: DataFrame
+        :return: DataFrame with buy column
+        """
+        return self.custom_strategy.populate_sell_trend(dataframe)
--- a/freqtrade/tests/conftest.py
+++ b/freqtrade/tests/conftest.py
@@ -18,7 +18,7 @@ def default_conf():
        "stake_currency": "BTC",
        "stake_amount": 0.001,
        "fiat_display_currency": "USD",
-        "ticker_interval": "5",
+        "ticker_interval": 5,
        "dry_run": True,
        "minimal_roi": {
            "40": 0.0,
@@ -217,3 +217,33 @@ def ticker_history():
            "BV": 0.7039405
        }
    ]
+
+
+@pytest.fixture
+def ticker_history_without_bv():
+    return [
+        {
+            "O": 8.794e-05,
+            "H": 8.948e-05,
+            "L": 8.794e-05,
+            "C": 8.88e-05,
+            "V": 991.09056638,
+            "T": "2017-11-26T08:50:00"
+        },
+        {
+            "O": 8.88e-05,
+            "H": 8.942e-05,
+            "L": 8.88e-05,
+            "C": 8.893e-05,
+            "V": 658.77935965,
+            "T": "2017-11-26T08:55:00"
+        },
+        {
+            "O": 8.891e-05,
+            "H": 8.893e-05,
+            "L": 8.875e-05,
+            "C": 8.877e-05,
+            "V": 7920.73570705,
+            "T": "2017-11-26T09:00:00"
+        }
+    ]
--- a/freqtrade/tests/optimize/test_backtesting.py
+++ b/freqtrade/tests/optimize/test_backtesting.py
@@ -3,12 +3,21 @@
 import logging
 import math
 import pandas as pd
+import pytest
 from unittest.mock import MagicMock
 from freqtrade import exchange, optimize
 from freqtrade.exchange import Bittrex
 from freqtrade.optimize import preprocess
 from freqtrade.optimize.backtesting import backtest, generate_text_table, get_timeframe
 import freqtrade.optimize.backtesting as backtesting
+from freqtrade.strategy.strategy import Strategy
+
+
+@pytest.fixture
+def default_strategy():
+    strategy = Strategy()
+    strategy.init({'strategy': 'default_strategy'})
+    return strategy


 def trim_dictlist(dl, num):
@@ -37,7 +46,7 @@ def test_generate_text_table():
        'TOTAL              2           15.00          0.60000000           100.0         2       0')  # noqa


-def test_get_timeframe():
+def test_get_timeframe(default_strategy):
    data = preprocess(optimize.load_data(
        None, ticker_interval=1, pairs=['BTC_UNITEST']))
    min_date, max_date = get_timeframe(data)
@@ -45,7 +54,7 @@ def test_get_timeframe():
    assert max_date.isoformat() == '2017-11-14T22:59:00+00:00'


-def test_backtest(default_conf, mocker):
+def test_backtest(default_strategy, default_conf, mocker):
    mocker.patch.dict('freqtrade.main._CONF', default_conf)
    exchange._API = Bittrex({'key': '', 'secret': ''})

@@ -58,7 +67,7 @@ def test_backtest(default_conf, mocker):
    assert not results.empty


-def test_backtest_1min_ticker_interval(default_conf, mocker):
+def test_backtest_1min_ticker_interval(default_strategy, default_conf, mocker):
    mocker.patch.dict('freqtrade.main._CONF', default_conf)
    exchange._API = Bittrex({'key': '', 'secret': ''})

@@ -131,7 +140,7 @@ def simple_backtest(config, contour, num_results):
 # loaded by freqdata/optimize/__init__.py::load_data()


-def test_backtest2(default_conf, mocker):
+def test_backtest2(default_conf, mocker, default_strategy):
    mocker.patch.dict('freqtrade.main._CONF', default_conf)
    data = optimize.load_data(None, ticker_interval=5, pairs=['BTC_ETH'])
    data = trim_dictlist(data, -200)
@@ -142,7 +151,7 @@ def test_backtest2(default_conf, mocker):
    assert not results.empty


-def test_processed(default_conf, mocker):
+def test_processed(default_conf, mocker, default_strategy):
    mocker.patch.dict('freqtrade.main._CONF', default_conf)
    dict_of_tickerrows = load_data_test('raise')
    dataframes = optimize.preprocess(dict_of_tickerrows)
@@ -154,7 +163,7 @@ def test_processed(default_conf, mocker):
        assert col in cols


-def test_backtest_pricecontours(default_conf, mocker):
+def test_backtest_pricecontours(default_conf, mocker, default_strategy):
    mocker.patch.dict('freqtrade.main._CONF', default_conf)
    tests = [['raise', 17], ['lower', 0], ['sine', 17]]
    for [contour, numres] in tests:
--- a/freqtrade/tests/optimize/test_hyperopt_config.py
+++ b/freqtrade/tests/optimize/test_hyperopt_config.py
@@ -1,6 +1,6 @@
 # pragma pylint: disable=missing-docstring,W0212

-from freqtrade.optimize.hyperopt_conf import hyperopt_optimize_conf
+from user_data.hyperopt_conf import hyperopt_optimize_conf


 def test_hyperopt_optimize_conf():
--- a/freqtrade/tests/rpc/test_rpc_telegram.py
+++ b/freqtrade/tests/rpc/test_rpc_telegram.py
@@ -219,9 +219,7 @@ def test_forcesell_handle(default_conf, update, ticker, ticker_sell_up, mocker):
    mocker.patch.multiple('freqtrade.main.exchange',
                          validate_pairs=MagicMock(),
                          get_ticker=ticker)
-    mocker.patch.multiple('freqtrade.fiat_convert.Pymarketcap',
-                          ticker=MagicMock(return_value={'price_usd': 15000.0}),
-                          _cache_symbols=MagicMock(return_value={'BTC': 1}))
+    mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
    init(default_conf, create_engine('sqlite://'))

    # Create some test data
@@ -239,7 +237,9 @@ def test_forcesell_handle(default_conf, update, ticker, ticker_sell_up, mocker):
    _forcesell(bot=MagicMock(), update=update)

    assert rpc_mock.call_count == 2
-    assert 'Selling [BTC/ETH]' in rpc_mock.call_args_list[-1][0][0]
+    assert 'Selling' in rpc_mock.call_args_list[-1][0][0]
+    assert '[BTC_ETH]' in rpc_mock.call_args_list[-1][0][0]
+    assert 'Amount' in rpc_mock.call_args_list[-1][0][0]
    assert '0.00001172' in rpc_mock.call_args_list[-1][0][0]
    assert 'profit: 6.11%, 0.00006126' in rpc_mock.call_args_list[-1][0][0]
    assert '0.919 USD' in rpc_mock.call_args_list[-1][0][0]
@@ -256,9 +256,7 @@ def test_forcesell_down_handle(default_conf, update, ticker, ticker_sell_down, m
    mocker.patch.multiple('freqtrade.main.exchange',
                          validate_pairs=MagicMock(),
                          get_ticker=ticker)
-    mocker.patch.multiple('freqtrade.fiat_convert.Pymarketcap',
-                          ticker=MagicMock(return_value={'price_usd': 15000.0}),
-                          _cache_symbols=MagicMock(return_value={'BTC': 1}))
+    mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
    init(default_conf, create_engine('sqlite://'))

    # Create some test data
@@ -276,7 +274,9 @@ def test_forcesell_down_handle(default_conf, update, ticker, ticker_sell_down, m
    _forcesell(bot=MagicMock(), update=update)

    assert rpc_mock.call_count == 2
-    assert 'Selling [BTC/ETH]' in rpc_mock.call_args_list[-1][0][0]
+    assert 'Selling' in rpc_mock.call_args_list[-1][0][0]
+    assert '[BTC_ETH]' in rpc_mock.call_args_list[-1][0][0]
+    assert 'Amount' in rpc_mock.call_args_list[-1][0][0]
    assert '0.00001044' in rpc_mock.call_args_list[-1][0][0]
    assert 'loss: -5.48%, -0.00005492' in rpc_mock.call_args_list[-1][0][0]
    assert '-0.824 USD' in rpc_mock.call_args_list[-1][0][0]
@@ -317,9 +317,7 @@ def test_forcesell_all_handle(default_conf, update, ticker, mocker):
    mocker.patch.multiple('freqtrade.main.exchange',
                          validate_pairs=MagicMock(),
                          get_ticker=ticker)
-    mocker.patch.multiple('freqtrade.fiat_convert.Pymarketcap',
-                          ticker=MagicMock(return_value={'price_usd': 15000.0}),
-                          _cache_symbols=MagicMock(return_value={'BTC': 1}))
+    mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
    init(default_conf, create_engine('sqlite://'))

    # Create some test data
--- a/freqtrade/tests/strategy/test_default_strategy.py
+++ b/freqtrade/tests/strategy/test_default_strategy.py
@@ -0,0 +1,36 @@
+import json
+import pytest
+from pandas import DataFrame
+from freqtrade.strategy.default_strategy import DefaultStrategy, class_name
+from freqtrade.analyze import parse_ticker_dataframe
+
+
+@pytest.fixture
+def result():
+    with open('freqtrade/tests/testdata/BTC_ETH-1.json') as data_file:
+        return parse_ticker_dataframe(json.load(data_file))
+
+
+def test_default_strategy_class_name():
+    assert class_name == DefaultStrategy.__name__
+
+
+def test_default_strategy_structure():
+    assert hasattr(DefaultStrategy, 'minimal_roi')
+    assert hasattr(DefaultStrategy, 'stoploss')
+    assert hasattr(DefaultStrategy, 'ticker_interval')
+    assert hasattr(DefaultStrategy, 'populate_indicators')
+    assert hasattr(DefaultStrategy, 'populate_buy_trend')
+    assert hasattr(DefaultStrategy, 'populate_sell_trend')
+
+
+def test_default_strategy(result):
+    strategy = DefaultStrategy()
+
+    assert type(strategy.minimal_roi) is dict
+    assert type(strategy.stoploss) is float
+    assert type(strategy.ticker_interval) is int
+    indicators = strategy.populate_indicators(result)
+    assert type(indicators) is DataFrame
+    assert type(strategy.populate_buy_trend(indicators)) is DataFrame
+    assert type(strategy.populate_sell_trend(indicators)) is DataFrame
--- a/freqtrade/tests/strategy/test_strategy.py
+++ b/freqtrade/tests/strategy/test_strategy.py
@@ -0,0 +1,141 @@
+import json
+import logging
+import pytest
+from freqtrade.strategy.strategy import Strategy
+from freqtrade.analyze import parse_ticker_dataframe
+
+
+@pytest.fixture
+def result():
+    with open('freqtrade/tests/testdata/BTC_ETH-1.json') as data_file:
+        return parse_ticker_dataframe(json.load(data_file))
+
+
+def test_sanitize_module_name():
+    assert Strategy._sanitize_module_name('default_strategy') == 'default_strategy'
+    assert Strategy._sanitize_module_name('default_strategy.py') == 'default_strategy'
+    assert Strategy._sanitize_module_name('../default_strategy.py') == 'default_strategy'
+    assert Strategy._sanitize_module_name('../default_strategy') == 'default_strategy'
+    assert Strategy._sanitize_module_name('.default_strategy') == '.default_strategy'
+    assert Strategy._sanitize_module_name('foo-bar') == 'foo-bar'
+    assert Strategy._sanitize_module_name('foo/bar') == 'bar'
+
+
+def test_search_strategy():
+    assert Strategy._search_strategy('default_strategy') == '.'
+    assert Strategy._search_strategy('super_duper') is None
+
+
+def test_strategy_structure():
+    assert hasattr(Strategy, 'init')
+    assert hasattr(Strategy, 'minimal_roi')
+    assert hasattr(Strategy, 'stoploss')
+    assert hasattr(Strategy, 'populate_indicators')
+    assert hasattr(Strategy, 'populate_buy_trend')
+    assert hasattr(Strategy, 'populate_sell_trend')
+
+
+def test_load_strategy(result):
+    strategy = Strategy()
+    strategy.logger = logging.getLogger(__name__)
+
+    assert not hasattr(Strategy, 'custom_strategy')
+    strategy._load_strategy('default_strategy')
+
+    assert not hasattr(Strategy, 'custom_strategy')
+
+    assert hasattr(strategy.custom_strategy, 'populate_indicators')
+    assert 'adx' in strategy.populate_indicators(result)
+
+
+def test_strategy(result):
+    strategy = Strategy()
+    strategy.init({'strategy': 'default_strategy'})
+
+    assert hasattr(strategy.custom_strategy, 'minimal_roi')
+    assert strategy.minimal_roi['0'] == 0.04
+
+    assert hasattr(strategy.custom_strategy, 'stoploss')
+    assert strategy.stoploss == -0.10
+
+    assert hasattr(strategy.custom_strategy, 'populate_indicators')
+    assert 'adx' in strategy.populate_indicators(result)
+
+    assert hasattr(strategy.custom_strategy, 'populate_buy_trend')
+    dataframe = strategy.populate_buy_trend(strategy.populate_indicators(result))
+    assert 'buy' in dataframe.columns
+
+    assert hasattr(strategy.custom_strategy, 'populate_sell_trend')
+    dataframe = strategy.populate_sell_trend(strategy.populate_indicators(result))
+    assert 'sell' in dataframe.columns
+
+
+def test_strategy_override_minimal_roi(caplog):
+    config = {
+        'strategy': 'default_strategy',
+        'minimal_roi': {
+            "0": 0.5
+        }
+    }
+    strategy = Strategy()
+    strategy.init(config)
+
+    assert hasattr(strategy.custom_strategy, 'minimal_roi')
+    assert strategy.minimal_roi['0'] == 0.5
+    assert ('freqtrade.strategy.strategy',
+            logging.INFO,
+            'Override strategy \'minimal_roi\' with value in config file.'
+            ) in caplog.record_tuples
+
+
+def test_strategy_override_stoploss(caplog):
+    config = {
+        'strategy': 'default_strategy',
+        'stoploss': -0.5
+    }
+    strategy = Strategy()
+    strategy.init(config)
+
+    assert hasattr(strategy.custom_strategy, 'stoploss')
+    assert strategy.stoploss == -0.5
+    assert ('freqtrade.strategy.strategy',
+            logging.INFO,
+            'Override strategy \'stoploss\' with value in config file: -0.5.'
+            ) in caplog.record_tuples
+
+
+def test_strategy_override_ticker_interval(caplog):
+    config = {
+        'strategy': 'default_strategy',
+        'ticker_interval': 60
+    }
+    strategy = Strategy()
+    strategy.init(config)
+
+    assert hasattr(strategy.custom_strategy, 'ticker_interval')
+    assert strategy.ticker_interval == 60
+    assert ('freqtrade.strategy.strategy',
+            logging.INFO,
+            'Override strategy \'ticker_interval\' with value in config file: 60.'
+            ) in caplog.record_tuples
+
+
+def test_strategy_fallback_default_strategy():
+    strategy = Strategy()
+    strategy.logger = logging.getLogger(__name__)
+
+    assert not hasattr(Strategy, 'custom_strategy')
+    strategy._load_strategy('../../super_duper')
+    assert not hasattr(Strategy, 'custom_strategy')
+
+
+def test_strategy_singleton():
+    strategy1 = Strategy()
+    strategy1.init({'strategy': 'default_strategy'})
+
+    assert hasattr(strategy1.custom_strategy, 'minimal_roi')
+    assert strategy1.minimal_roi['0'] == 0.04
+
+    strategy2 = Strategy()
+    assert hasattr(strategy2.custom_strategy, 'minimal_roi')
+    assert strategy2.minimal_roi['0'] == 0.04
--- a/freqtrade/tests/test_analyze.py
+++ b/freqtrade/tests/test_analyze.py
@@ -9,6 +9,7 @@ from pandas import DataFrame
 from freqtrade.analyze import (get_signal, parse_ticker_dataframe,
                               populate_buy_trend, populate_indicators,
                               populate_sell_trend)
+from freqtrade.strategy.strategy import Strategy


@pytest.fixture
@@ -27,11 +28,17 @@ def test_dataframe_correct_length(result):


 def test_populates_buy_trend(result):
+    # Load the default strategy for the unit test, because this logic is done in main.py
+    Strategy().init({'strategy': 'default_strategy'})
+
    dataframe = populate_buy_trend(populate_indicators(result))
    assert 'buy' in dataframe.columns


 def test_populates_sell_trend(result):
+    # Load the default strategy for the unit test, because this logic is done in main.py
+    Strategy().init({'strategy': 'default_strategy'})
+
    dataframe = populate_sell_trend(populate_indicators(result))
    assert 'sell' in dataframe.columns

@@ -72,3 +79,16 @@ def test_get_signal_handles_exceptions(mocker):
                 side_effect=Exception('invalid ticker history '))

    assert get_signal('BTC-ETH', 5) == (False, False)
+
+
+def test_parse_ticker_dataframe(ticker_history, ticker_history_without_bv):
+
+    columns = ['close', 'high', 'low', 'open', 'date', 'volume']
+
+    # Test file with BV data
+    dataframe = parse_ticker_dataframe(ticker_history)
+    assert dataframe.columns.tolist() == columns
+
+    # Test file without BV data
+    dataframe = parse_ticker_dataframe(ticker_history_without_bv)
+    assert dataframe.columns.tolist() == columns
--- a/freqtrade/tests/test_fiat_convert.py
+++ b/freqtrade/tests/test_fiat_convert.py
@@ -116,9 +116,9 @@ def test_fiat_convert_get_price(mocker):
    assert fiat_convert._pairs[0]._expiration is not expiration


-def test_fiat_convert_without_network(mocker):
-    pymarketcap = MagicMock(side_effect=ImportError('Oh boy, you have no network!'))
-    mocker.patch('freqtrade.fiat_convert.Pymarketcap', pymarketcap)
+def test_fiat_convert_without_network():
+    # Because CryptoToFiatConverter is a Singleton we reset the value of _coinmarketcap
+    CryptoToFiatConverter._coinmarketcap = None

    fiat_convert = CryptoToFiatConverter()
    assert fiat_convert._coinmarketcap is None
--- a/freqtrade/tests/test_main.py
+++ b/freqtrade/tests/test_main.py
@@ -525,9 +525,7 @@ def test_execute_sell_up(default_conf, ticker, ticker_sell_up, mocker):
    mocker.patch.multiple('freqtrade.main.exchange',
                          validate_pairs=MagicMock(),
                          get_ticker=ticker)
-    mocker.patch.multiple('freqtrade.fiat_convert.Pymarketcap',
-                          ticker=MagicMock(return_value={'price_usd': 15000.0}),
-                          _cache_symbols=MagicMock(return_value={'BTC': 1}))
+    mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
    init(default_conf, create_engine('sqlite://'))

    # Create some test data
@@ -544,7 +542,10 @@ def test_execute_sell_up(default_conf, ticker, ticker_sell_up, mocker):
    execute_sell(trade=trade, limit=ticker_sell_up()['bid'])

    assert rpc_mock.call_count == 2
-    assert 'Selling [BTC/ETH]' in rpc_mock.call_args_list[-1][0][0]
+    assert 'Selling' in rpc_mock.call_args_list[-1][0][0]
+    assert '[BTC_ETH]' in rpc_mock.call_args_list[-1][0][0]
+    assert 'Amount' in rpc_mock.call_args_list[-1][0][0]
+    assert 'Profit' in rpc_mock.call_args_list[-1][0][0]
    assert '0.00001172' in rpc_mock.call_args_list[-1][0][0]
    assert 'profit: 6.11%, 0.00006126' in rpc_mock.call_args_list[-1][0][0]
    assert '0.919 USD' in rpc_mock.call_args_list[-1][0][0]
@@ -562,9 +563,7 @@ def test_execute_sell_down(default_conf, ticker, ticker_sell_down, mocker):
    mocker.patch.multiple('freqtrade.main.exchange',
                          validate_pairs=MagicMock(),
                          get_ticker=ticker)
-    mocker.patch.multiple('freqtrade.fiat_convert.Pymarketcap',
-                          ticker=MagicMock(return_value={'price_usd': 15000.0}),
-                          _cache_symbols=MagicMock(return_value={'BTC': 1}))
+    mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._find_price', return_value=15000.0)
    init(default_conf, create_engine('sqlite://'))

    # Create some test data
@@ -581,7 +580,9 @@ def test_execute_sell_down(default_conf, ticker, ticker_sell_down, mocker):
    execute_sell(trade=trade, limit=ticker_sell_down()['bid'])

    assert rpc_mock.call_count == 2
-    assert 'Selling [BTC/ETH]' in rpc_mock.call_args_list[-1][0][0]
+    assert 'Selling' in rpc_mock.call_args_list[-1][0][0]
+    assert '[BTC_ETH]' in rpc_mock.call_args_list[-1][0][0]
+    assert 'Amount' in rpc_mock.call_args_list[-1][0][0]
    assert '0.00001044' in rpc_mock.call_args_list[-1][0][0]
    assert 'loss: -5.48%, -0.00005492' in rpc_mock.call_args_list[-1][0][0]
    assert '-0.824 USD' in rpc_mock.call_args_list[-1][0][0]
@@ -611,10 +612,9 @@ def test_execute_sell_without_conf_sell_down(default_conf, ticker, ticker_sell_d

    execute_sell(trade=trade, limit=ticker_sell_down()['bid'])

-    print(rpc_mock.call_args_list[-1][0][0])
-
    assert rpc_mock.call_count == 2
-    assert 'Selling [BTC/ETH]' in rpc_mock.call_args_list[-1][0][0]
+    assert 'Selling' in rpc_mock.call_args_list[-1][0][0]
+    assert '[BTC_ETH]' in rpc_mock.call_args_list[-1][0][0]
    assert '0.00001044' in rpc_mock.call_args_list[-1][0][0]
    assert 'loss: -5.48%, -0.00005492' in rpc_mock.call_args_list[-1][0][0]

@@ -644,7 +644,9 @@ def test_execute_sell_without_conf_sell_up(default_conf, ticker, ticker_sell_up,
    execute_sell(trade=trade, limit=ticker_sell_up()['bid'])

    assert rpc_mock.call_count == 2
-    assert 'Selling [BTC/ETH]' in rpc_mock.call_args_list[-1][0][0]
+    assert 'Selling' in rpc_mock.call_args_list[-1][0][0]
+    assert '[BTC_ETH]' in rpc_mock.call_args_list[-1][0][0]
+    assert 'Amount' in rpc_mock.call_args_list[-1][0][0]
    assert '0.00001172' in rpc_mock.call_args_list[-1][0][0]
    assert '(profit: 6.11%, 0.00006126)' in rpc_mock.call_args_list[-1][0][0]
    assert 'USD' not in rpc_mock.call_args_list[-1][0][0]
--- a/freqtrade/tests/test_persistence.py
+++ b/freqtrade/tests/test_persistence.py
@@ -4,7 +4,7 @@ import os
 import pytest

 from freqtrade.exchange import Exchanges
-from freqtrade.persistence import Trade, init
+from freqtrade.persistence import Trade, init, clean_dry_run_db


 def test_init_create_session(default_conf, mocker):
@@ -310,3 +310,50 @@ def test_calc_profit_percent(limit_buy_order, limit_sell_order):

    # Test with a custom fee rate on the close trade
    assert trade.calc_profit_percent(fee=0.003) == 0.0614782
+
+
+def test_clean_dry_run_db(default_conf, mocker):
+    init(default_conf)
+
+    # Simulate dry_run entries
+    trade = Trade(
+        pair='BTC_ETH',
+        stake_amount=0.001,
+        amount=123.0,
+        fee=0.0025,
+        open_rate=0.123,
+        exchange='BITTREX',
+        open_order_id='dry_run_buy_12345'
+    )
+    Trade.session.add(trade)
+
+    trade = Trade(
+        pair='BTC_ETC',
+        stake_amount=0.001,
+        amount=123.0,
+        fee=0.0025,
+        open_rate=0.123,
+        exchange='BITTREX',
+        open_order_id='dry_run_sell_12345'
+    )
+    Trade.session.add(trade)
+
+    # Simulate prod entry
+    trade = Trade(
+        pair='BTC_ETC',
+        stake_amount=0.001,
+        amount=123.0,
+        fee=0.0025,
+        open_rate=0.123,
+        exchange='BITTREX',
+        open_order_id='prod_buy_12345'
+    )
+    Trade.session.add(trade)
+
+    # We have 3 entries: 2 dry_run, 1 prod
+    assert len(Trade.query.filter(Trade.open_order_id.isnot(None)).all()) == 3
+
+    clean_dry_run_db()
+
+    # We have now only the prod
+    assert len(Trade.query.filter(Trade.open_order_id.isnot(None)).all()) == 1