Merge branch 'release/0.14.2'

Refreshs the whitelist in each iteration based on the wallet health,
disabled wallets will be removed from the whitelist automatically.

.coveragerc

@@ -1,2 +1,5 @@
 [run]
-omit = freqtrade/tests/*
+omit =
+    scripts/*
+    freqtrade/tests/*
+    freqtrade/vendor/*

.pylintrc

@@ -1,2 +1,3 @@
 [BASIC]
 good-names=logger
+ignore=vendor

.travis.yml

@@ -4,6 +4,9 @@ os:
 language: python
 python:
 - 3.6
+env:
+  - BACKTEST=
+  - BACKTEST=true
 addons:
   apt:
     packages:

MANIFEST.in

@@ -1,7 +1,5 @@
 include LICENSE
 include README.md
 include config.json.example
-include freqtrade/exchange/*.py
-include freqtrade/rpc/*.py
-include freqtrade/tests/*.py
+recursive-include freqtrade *.py
 include freqtrade/tests/testdata/*.json

README.md

@@ -16,15 +16,19 @@ and enter the telegram `token` and your `chat_id` in `config.json`
 
 Persistence is achieved through sqlite.
 
-#### Telegram RPC commands:
+### Telegram RPC commands:
 * /start: Starts the trader
 * /stop: Stops the trader
-* /status: Lists all open trades
+* /status [table]: Lists all open trades
+* /count: Displays number of open trades
 * /profit: Lists cumulative profit from all finished trades
-* /forcesell <trade_id>: Instantly sells the given trade (Ignoring `minimum_roi`).
+* /forcesell <trade_id>|all: Instantly sells the given trade (Ignoring `minimum_roi`).
 * /performance: Show performance of each finished trade grouped by pair
+* /balance: Show account balance per currency
+* /help: Show help message
+* /version: Show version
 
-#### Config
+### Config
 `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:
@@ -53,12 +57,18 @@ end up paying more then would probably have been necessary.
 The other values should be self-explanatory,
 if not feel free to raise a github issue.
 
-#### Prerequisites
+### Prerequisites
 * python3.6
 * sqlite
 * [TA-lib](https://github.com/mrjbq7/ta-lib#dependencies) binaries
 
-#### Install
+### Install
+
+#### Arch Linux
+
+Use your favorite AUR helper and install `python-freqtrade-git`.
+
+#### Manually
 
 `master` branch contains the latest stable release.
 
@@ -75,18 +85,9 @@ $ pip install -e .
 $ ./freqtrade/main.py
 ```
 
-There is also an [article](https://www.sales4k.com/blockchain/high-frequency-trading-bot-tutorial/) about how to setup the bot (thanks [@gurghet](https://github.com/gurghet)).
+There is also an [article](https://www.sales4k.com/blockchain/high-frequency-trading-bot-tutorial/) about how to setup the bot (thanks [@gurghet](https://github.com/gurghet)).*
 
-#### Execute tests
-
-```
-$ pytest
-```
-This will by default skip the slow running backtest set. To run backtest set:
-
-```
-$ BACKTEST=true pytest -s freqtrade/tests/test_backtesting.py
-```
+\* *Note:* that article was written for an earlier version, so it may be outdated
 
 #### Docker
 
@@ -114,14 +115,14 @@ filesystem):
 
 ```
 $ cd ~/.freq
-$ touch tradesv2.sqlite
+$ touch tradesv3.sqlite
 $ docker run -d \
   --name freqtrade \
   -v ~/.freq/config.json:/freqtrade/config.json \
-  -v ~/.freq/tradesv2.sqlite:/freqtrade/tradesv2.sqlite \
+  -v ~/.freq/tradesv3.sqlite:/freqtrade/tradesv3.sqlite \
   freqtrade
 ```
-If you are using `dry_run=True` you need to bind `tradesv2.dry_run.sqlite` instead of `tradesv2.sqlite`.
+If you are using `dry_run=True` it's not necessary to mount `tradesv3.sqlite`.
 
 You can then use the following commands to monitor and manage your container:
 
@@ -136,7 +137,18 @@ $ docker start freqtrade
 You do not need to rebuild the image for configuration
 changes, it will suffice to edit `config.json` and restart the container.
 
-#### Contributing
+### Execute tests
+
+```
+$ pytest
+```
+This will by default skip the slow running backtest set. To run backtest set:
+
+```
+$ BACKTEST=true pytest -s freqtrade/tests/test_backtesting.py
+```
+
+### Contributing
 
 Feel like our bot is missing a feature? We welcome your pull requests! Few pointers for contributions:
 

bin/freqtrade

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 from freqtrade.main import main
 main()

config.json.example

@@ -34,5 +34,8 @@
         "token": "token",
         "chat_id": "chat_id"
     },
-    "initial_state": "running"
+    "initial_state": "running",
+    "internals": {
+        "process_throttle_secs": 5
+    }
 }

freqtrade/__init__.py

@@ -1,3 +1,3 @@
-__version__ = '0.12.0'
+__version__ = '0.14.2'
 
 from . import main

freqtrade/analyze.py

@@ -1,30 +1,29 @@
 import logging
-import time
 from datetime import timedelta
 
 import arrow
 import talib.abstract as ta
-from pandas import DataFrame
+from pandas import DataFrame, to_datetime
 
-from freqtrade import exchange
-from freqtrade.exchange import Bittrex, get_ticker_history
+from freqtrade.exchange import get_ticker_history
+from freqtrade.vendor.qtpylib.indicators import awesome_oscillator
 
-logging.basicConfig(level=logging.DEBUG,
-                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
 
-def parse_ticker_dataframe(ticker: list, minimum_date: arrow.Arrow) -> DataFrame:
+def parse_ticker_dataframe(ticker: list) -> DataFrame:
     """
-    Analyses the trend for the given pair
-    :param pair: pair as str in format BTC_ETH or BTC-ETH
+    Analyses the trend for the given ticker history
+    :param ticker: See exchange.get_ticker_history
     :return: DataFrame
     """
-    df = DataFrame(ticker) \
+    columns = {'C': 'close', 'V': 'volume', 'O': 'open', 'H': 'high', 'L': 'low', 'T': 'date'}
+    frame = DataFrame(ticker) \
         .drop('BV', 1) \
-        .rename(columns={'C':'close', 'V':'volume', 'O':'open', 'H':'high', 'L':'low', 'T':'date'}) \
-        .sort_values('date')
-    return df
+        .rename(columns=columns)
+    frame['date'] = to_datetime(frame['date'], utc=True, infer_datetime_format=True)
+    frame.sort_values('date', inplace=True)
+    return frame
 
 
 def populate_indicators(dataframe: DataFrame) -> DataFrame:
@@ -40,7 +39,19 @@ def populate_indicators(dataframe: DataFrame) -> DataFrame:
     dataframe['sma'] = ta.SMA(dataframe, timeperiod=40)
     dataframe['tema'] = ta.TEMA(dataframe, timeperiod=9)
     dataframe['mfi'] = ta.MFI(dataframe)
-    dataframe['cci'] = ta.CCI(dataframe)
+    dataframe['rsi'] = ta.RSI(dataframe)
+    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)
+    dataframe['ao'] = awesome_oscillator(dataframe)
+    macd = ta.MACD(dataframe)
+    dataframe['macd'] = macd['macd']
+    dataframe['macdsignal'] = macd['macdsignal']
+    dataframe['macdhist'] = macd['macdhist']
+    hilbert = ta.HT_SINE(dataframe)
+    dataframe['htsine'] = hilbert['sine']
+    dataframe['htleadsine'] = hilbert['leadsine']
     return dataframe
 
 
@@ -50,14 +61,14 @@ def populate_buy_trend(dataframe: DataFrame) -> DataFrame:
     :param dataframe: DataFrame
     :return: DataFrame with buy column
     """
-    dataframe.loc[
+    dataframe.ix[
         (dataframe['close'] < dataframe['sma']) &
         (dataframe['tema'] <= dataframe['blower']) &
         (dataframe['mfi'] < 25) &
         (dataframe['fastd'] < 25) &
         (dataframe['adx'] > 30),
         'buy'] = 1
-    dataframe.loc[dataframe['buy'] == 1, 'buy_price'] = dataframe['close']
+    dataframe.ix[dataframe['buy'] == 1, 'buy_price'] = dataframe['close']
 
     return dataframe
 
@@ -68,14 +79,12 @@ def analyze_ticker(pair: str) -> DataFrame:
     add several TA indicators and buy signal to it
     :return DataFrame with ticker data and indicator data
     """
-    minimum_date = arrow.utcnow().shift(hours=-24)
-    data = get_ticker_history(pair, minimum_date)
-    dataframe = parse_ticker_dataframe(data['result'], minimum_date)
-
-    if dataframe.empty:
-        logger.warning('Empty dataframe for pair %s', pair)
-        return dataframe
+    ticker_hist = get_ticker_history(pair)
+    if not ticker_hist:
+        logger.warning('Empty ticker history for pair %s', pair)
+        return DataFrame()
 
+    dataframe = parse_ticker_dataframe(ticker_hist)
     dataframe = populate_indicators(dataframe)
     dataframe = populate_buy_trend(dataframe)
     return dataframe
@@ -88,7 +97,6 @@ def get_buy_signal(pair: str) -> bool:
     :return: True if pair is good for buying, False otherwise
     """
     dataframe = analyze_ticker(pair)
-
     if dataframe.empty:
         return False
 
@@ -102,55 +110,3 @@ def get_buy_signal(pair: str) -> bool:
     signal = latest['buy'] == 1
     logger.debug('buy_trigger: %s (pair=%s, signal=%s)', latest['date'], pair, signal)
     return signal
-
-
-def plot_dataframe(dataframe: DataFrame, pair: str) -> None:
-    """
-    Plots the given dataframe
-    :param dataframe: DataFrame
-    :param pair: pair as str
-    :return: None
-    """
-
-    import matplotlib
-
-    matplotlib.use("Qt5Agg")
-    import matplotlib.pyplot as plt
-
-    # Two subplots sharing x axis
-    fig, (ax1, ax2, ax3) = plt.subplots(3, sharex=True)
-    fig.suptitle(pair, fontsize=14, fontweight='bold')
-    ax1.plot(dataframe.index.values, dataframe['close'], label='close')
-    # ax1.plot(dataframe.index.values, dataframe['sell'], 'ro', label='sell')
-    ax1.plot(dataframe.index.values, dataframe['sma'], '--', label='SMA')
-    ax1.plot(dataframe.index.values, dataframe['tema'], ':', label='TEMA')
-    ax1.plot(dataframe.index.values, dataframe['blower'], '-.', label='BB low')
-    ax1.plot(dataframe.index.values, dataframe['buy_price'], 'bo', label='buy')
-    ax1.legend()
-
-    ax2.plot(dataframe.index.values, dataframe['adx'], label='ADX')
-    ax2.plot(dataframe.index.values, dataframe['mfi'], label='MFI')
-    # ax2.plot(dataframe.index.values, [25] * len(dataframe.index.values))
-    ax2.legend()
-
-    ax3.plot(dataframe.index.values, dataframe['fastk'], label='k')
-    ax3.plot(dataframe.index.values, dataframe['fastd'], label='d')
-    ax3.plot(dataframe.index.values, [20] * len(dataframe.index.values))
-    ax3.legend()
-
-    # Fine-tune figure; make subplots close to each other and hide x ticks for
-    # all but bottom plot.
-    fig.subplots_adjust(hspace=0)
-    plt.setp([a.get_xticklabels() for a in fig.axes[:-1]], visible=False)
-    plt.show()
-
-
-if __name__ == '__main__':
-    # Install PYQT5==5.9 manually if you want to test this helper function
-    while True:
-        exchange.EXCHANGE = Bittrex({'key': '', 'secret': ''})
-        test_pair = 'BTC_ETH'
-        # for pair in ['BTC_ANT', 'BTC_ETH', 'BTC_GNT', 'BTC_ETC']:
-        #     get_buy_signal(pair)
-        plot_dataframe(analyze_ticker(test_pair), test_pair)
-        time.sleep(60)

freqtrade/exchange/__init__.py

@@ -1,8 +1,10 @@
 import enum
 import logging
-from typing import List
+from random import randint
+from typing import List, Dict, Any, Optional
 
 import arrow
+from cachetools import cached, TTLCache
 
 from freqtrade.exchange.bittrex import Bittrex
 from freqtrade.exchange.interface import Exchange
@@ -10,9 +12,12 @@ from freqtrade.exchange.interface import Exchange
 logger = logging.getLogger(__name__)
 
 # Current selected exchange
-EXCHANGE: Exchange = None
+_API: Exchange = None
 _CONF: dict = {}
 
+# Holds all open sell orders for dry_run
+_DRY_RUN_OPEN_ORDERS: Dict[str, Any] = {}
+
 
 class Exchanges(enum.Enum):
     """
@@ -29,7 +34,7 @@ def init(config: dict) -> None:
     :param config: config to use
     :return: None
     """
-    global _CONF, EXCHANGE
+    global _CONF, _API
 
     _CONF.update(config)
 
@@ -45,7 +50,7 @@ def init(config: dict) -> None:
     except KeyError:
         raise RuntimeError('Exchange {} is not supported'.format(name))
 
-    EXCHANGE = exchange_class(exchange_config)
+    _API = exchange_class(exchange_config)
 
     # Check if all pairs are available
     validate_pairs(config['exchange']['pair_whitelist'])
@@ -58,58 +63,113 @@ def validate_pairs(pairs: List[str]) -> None:
     :param pairs: list of pairs
     :return: None
     """
-    markets = EXCHANGE.get_markets()
+    markets = _API.get_markets()
+    stake_cur = _CONF['stake_currency']
     for pair in pairs:
+        if not pair.startswith(stake_cur):
+            raise RuntimeError(
+                'Pair {} not compatible with stake_currency: {}'.format(pair, stake_cur)
+            )
         if pair not in markets:
-            raise RuntimeError('Pair {} is not available at {}'.format(pair, EXCHANGE.name.lower()))
+            raise RuntimeError('Pair {} is not available at {}'.format(pair, _API.name.lower()))
 
 
 def buy(pair: str, rate: float, amount: float) -> str:
     if _CONF['dry_run']:
-        return 'dry_run'
+        global _DRY_RUN_OPEN_ORDERS
+        order_id = 'dry_run_buy_{}'.format(randint(0, 1e6))
+        _DRY_RUN_OPEN_ORDERS[order_id] = {
+            'pair': pair,
+            'rate': rate,
+            'amount': amount,
+            'type': 'LIMIT_BUY',
+            'remaining': 0.0,
+            'opened': arrow.utcnow().datetime,
+            'closed': arrow.utcnow().datetime,
+        }
+        return order_id
 
-    return EXCHANGE.buy(pair, rate, amount)
+    return _API.buy(pair, rate, amount)
 
 
 def sell(pair: str, rate: float, amount: float) -> str:
     if _CONF['dry_run']:
-        return 'dry_run'
+        global _DRY_RUN_OPEN_ORDERS
+        order_id = 'dry_run_sell_{}'.format(randint(0, 1e6))
+        _DRY_RUN_OPEN_ORDERS[order_id] = {
+            'pair': pair,
+            'rate': rate,
+            'amount': amount,
+            'type': 'LIMIT_SELL',
+            'remaining': 0.0,
+            'opened': arrow.utcnow().datetime,
+            'closed': arrow.utcnow().datetime,
+        }
+        return order_id
 
-    return EXCHANGE.sell(pair, rate, amount)
+    return _API.sell(pair, rate, amount)
 
 
 def get_balance(currency: str) -> float:
     if _CONF['dry_run']:
         return 999.9
 
-    return EXCHANGE.get_balance(currency)
+    return _API.get_balance(currency)
+
+
+def get_balances():
+    if _CONF['dry_run']:
+        return []
+
+    return _API.get_balances()
 
 
 def get_ticker(pair: str) -> dict:
-    return EXCHANGE.get_ticker(pair)
+    return _API.get_ticker(pair)
 
 
-def get_ticker_history(pair: str, minimum_date: arrow.Arrow):
-    return EXCHANGE.get_ticker_history(pair, minimum_date)
+@cached(TTLCache(maxsize=100, ttl=30))
+def get_ticker_history(pair: str, tick_interval: Optional[int] = 5) -> List[Dict]:
+    return _API.get_ticker_history(pair, tick_interval)
 
 
 def cancel_order(order_id: str) -> None:
     if _CONF['dry_run']:
         return
 
-    return EXCHANGE.cancel_order(order_id)
+    return _API.cancel_order(order_id)
 
 
-def get_open_orders(pair: str) -> List[dict]:
+def get_order(order_id: str) -> Dict:
     if _CONF['dry_run']:
-        return []
+        order = _DRY_RUN_OPEN_ORDERS[order_id]
+        order.update({
+            'id': order_id
+        })
+        return order
 
-    return EXCHANGE.get_open_orders(pair)
+    return _API.get_order(order_id)
 
 
 def get_pair_detail_url(pair: str) -> str:
-    return EXCHANGE.get_pair_detail_url(pair)
+    return _API.get_pair_detail_url(pair)
 
 
 def get_markets() -> List[str]:
-    return EXCHANGE.get_markets()
+    return _API.get_markets()
+
+
+def get_market_summaries() -> List[Dict]:
+    return _API.get_market_summaries()
+
+
+def get_name() -> str:
+    return _API.name
+
+
+def get_fee() -> float:
+    return _API.fee
+
+
+def get_wallet_health() -> List[Dict]:
+    return _API.get_wallet_health()

freqtrade/exchange/bittrex.py

@@ -1,15 +1,14 @@
 import logging
-from typing import List, Optional
+from typing import List, Dict
 
-import arrow
-import requests
-from bittrex.bittrex import Bittrex as _Bittrex
+from bittrex.bittrex import Bittrex as _Bittrex, API_V2_0, API_V1_1
 
 from freqtrade.exchange.interface import Exchange
 
 logger = logging.getLogger(__name__)
 
 _API: _Bittrex = None
+_API_V2: _Bittrex = None
 _EXCHANGE_CONF: dict = {}
 
 
@@ -19,85 +18,131 @@ class Bittrex(Exchange):
     """
     # Base URL and API endpoints
     BASE_URL: str = 'https://www.bittrex.com'
-    TICKER_METHOD: str = BASE_URL + '/Api/v2.0/pub/market/GetTicks'
     PAIR_DETAIL_METHOD: str = BASE_URL + '/Market/Index'
-    # Ticker inveral
-    TICKER_INTERVAL: str = 'fiveMin'
-    # Sleep time to avoid rate limits, used in the main loop
-    SLEEP_TIME: float = 25
-
-    @property
-    def sleep_time(self) -> float:
-        return self.SLEEP_TIME
 
     def __init__(self, config: dict) -> None:
-        global _API, _EXCHANGE_CONF
+        global _API, _API_V2, _EXCHANGE_CONF
 
         _EXCHANGE_CONF.update(config)
-        _API = _Bittrex(api_key=_EXCHANGE_CONF['key'], api_secret=_EXCHANGE_CONF['secret'])
+        _API = _Bittrex(
+            api_key=_EXCHANGE_CONF['key'],
+            api_secret=_EXCHANGE_CONF['secret'],
+            calls_per_second=1,
+            api_version=API_V1_1,
+        )
+        _API_V2 = _Bittrex(
+            api_key=_EXCHANGE_CONF['key'],
+            api_secret=_EXCHANGE_CONF['secret'],
+            calls_per_second=1,
+            api_version=API_V2_0,
+        )
+
+    @property
+    def fee(self) -> float:
+        # See https://bittrex.com/fees
+        return 0.0025
 
     def buy(self, pair: str, rate: float, amount: float) -> str:
         data = _API.buy_limit(pair.replace('_', '-'), amount, rate)
         if not data['success']:
-            raise RuntimeError('{}: {}'.format(self.name.upper(), data['message']))
+            raise RuntimeError('{message} params=({pair}, {rate}, {amount})'.format(
+                message=data['message'],
+                pair=pair,
+                rate=rate,
+                amount=amount))
         return data['result']['uuid']
 
     def sell(self, pair: str, rate: float, amount: float) -> str:
         data = _API.sell_limit(pair.replace('_', '-'), amount, rate)
         if not data['success']:
-            raise RuntimeError('{}: {}'.format(self.name.upper(), data['message']))
+            raise RuntimeError('{message} params=({pair}, {rate}, {amount})'.format(
+                message=data['message'],
+                pair=pair,
+                rate=rate,
+                amount=amount))
         return data['result']['uuid']
 
     def get_balance(self, currency: str) -> float:
         data = _API.get_balance(currency)
         if not data['success']:
-            raise RuntimeError('{}: {}'.format(self.name.upper(), data['message']))
+            raise RuntimeError('{message} params=({currency})'.format(
+                message=data['message'],
+                currency=currency))
         return float(data['result']['Balance'] or 0.0)
 
+    def get_balances(self):
+        data = _API.get_balances()
+        if not data['success']:
+            raise RuntimeError('{message}'.format(message=data['message']))
+        return data['result']
+
     def get_ticker(self, pair: str) -> dict:
         data = _API.get_ticker(pair.replace('_', '-'))
         if not data['success']:
-            raise RuntimeError('{}: {}'.format(self.name.upper(), data['message']))
+            raise RuntimeError('{message} params=({pair})'.format(
+                message=data['message'],
+                pair=pair))
+        if not data['result']['Bid'] or not data['result']['Ask'] or not data['result']['Last']:
+            raise RuntimeError('{message} params=({pair})'.format(
+                message=data['message'],
+                pair=pair))
         return {
             'bid': float(data['result']['Bid']),
             'ask': float(data['result']['Ask']),
             'last': float(data['result']['Last']),
         }
 
-    def get_ticker_history(self, pair: str, minimum_date: Optional[arrow.Arrow] = None):
-        url = self.TICKER_METHOD
-        headers = {
-            # TODO: Set as global setting
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.100 Safari/537.36'
-        }
-        params = {
-            'marketName': pair.replace('_', '-'),
-            'tickInterval': self.TICKER_INTERVAL,
-            # TODO: Timestamp has no effect on API response
-            '_': minimum_date.timestamp * 1000
-        }
-        data = requests.get(url, params=params, headers=headers).json()
+    def get_ticker_history(self, pair: str, tick_interval: int) -> List[Dict]:
+        if tick_interval == 1:
+            interval = 'oneMin'
+        elif tick_interval == 5:
+            interval = 'fiveMin'
+        else:
+            raise ValueError('Cannot parse tick_interval: {}'.format(tick_interval))
+
+        data = _API_V2.get_candles(pair.replace('_', '-'), interval)
+
+        # These sanity check are necessary because bittrex cannot keep their API stable.
+        if not data.get('result'):
+            return []
+
+        for prop in ['C', 'V', 'O', 'H', 'L', 'T']:
+            for tick in data['result']:
+                if prop not in tick.keys():
+                    logger.warning('Required property %s not present in response', prop)
+                    return []
+
         if not data['success']:
-            raise RuntimeError('{}: {}'.format(self.name.upper(), data['message']))
-        return data
+            raise RuntimeError('{message} params=({pair})'.format(
+                message=data['message'],
+                pair=pair))
+
+        return data['result']
+
+    def get_order(self, order_id: str) -> Dict:
+        data = _API.get_order(order_id)
+        if not data['success']:
+            raise RuntimeError('{message} params=({order_id})'.format(
+                message=data['message'],
+                order_id=order_id))
+        data = data['result']
+        return {
+            'id': data['OrderUuid'],
+            'type': data['Type'],
+            'pair': data['Exchange'].replace('-', '_'),
+            'opened': data['Opened'],
+            'rate': data['PricePerUnit'],
+            'amount': data['Quantity'],
+            'remaining': data['QuantityRemaining'],
+            'closed': data['Closed'],
+        }
 
     def cancel_order(self, order_id: str) -> None:
         data = _API.cancel(order_id)
         if not data['success']:
-            raise RuntimeError('{}: {}'.format(self.name.upper(), data['message']))
-
-    def get_open_orders(self, pair: str) -> List[dict]:
-        data = _API.get_open_orders(pair.replace('_', '-'))
-        if not data['success']:
-            raise RuntimeError('{}: {}'.format(self.name.upper(), data['message']))
-        return [{
-            'id': entry['OrderUuid'],
-            'type': entry['OrderType'],
-            'opened': entry['Opened'],
-            'rate': entry['PricePerUnit'],
-            'amount': entry['Quantity'],
-            'remaining': entry['QuantityRemaining'],
-        } for entry in data['result']]
+            raise RuntimeError('{message} params=({order_id})'.format(
+                message=data['message'],
+                order_id=order_id))
 
     def get_pair_detail_url(self, pair: str) -> str:
         return self.PAIR_DETAIL_METHOD + '?MarketName={}'.format(pair.replace('_', '-'))
@@ -105,5 +150,22 @@ class Bittrex(Exchange):
     def get_markets(self) -> List[str]:
         data = _API.get_markets()
         if not data['success']:
-            raise RuntimeError('{}: {}'.format(self.name.upper(), data['message']))
+            raise RuntimeError('{message}'.format(message=data['message']))
         return [m['MarketName'].replace('-', '_') for m in data['result']]
+
+    def get_market_summaries(self) -> List[Dict]:
+        data = _API.get_market_summaries()
+        if not data['success']:
+            raise RuntimeError('{message}'.format(message=data['message']))
+        return data['result']
+
+    def get_wallet_health(self) -> List[Dict]:
+        data = _API_V2.get_wallet_health()
+        if not data['success']:
+            raise RuntimeError('{message}'.format(message=data['message']))
+        return [{
+            'Currency': entry['Health']['Currency'],
+            'IsActive': entry['Health']['IsActive'],
+            'LastChecked': entry['Health']['LastChecked'],
+            'Notice': entry['Currency'].get('Notice'),
+        } for entry in data['result']]

freqtrade/exchange/interface.py

@@ -1,7 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import List, Optional
-
-import arrow
+from typing import List, Dict
 
 
 class Exchange(ABC):
@@ -14,11 +12,10 @@ class Exchange(ABC):
         return self.__class__.__name__
 
     @property
-    @abstractmethod
-    def sleep_time(self) -> float:
+    def fee(self) -> float:
         """
-        Sleep time in seconds for the main loop to avoid API rate limits.
-        :return: float
+        Fee for placing an order
+        :return: percentage in float
         """
 
     @abstractmethod
@@ -49,6 +46,21 @@ class Exchange(ABC):
         :return: float
         """
 
+    @abstractmethod
+    def get_balances(self) -> List[dict]:
+        """
+        Gets account balances across currencies
+        :return: List of dicts, format: [
+          {
+            'Currency': str,
+            'Balance': float,
+            'Available': float,
+            'Pending': float,
+          }
+          ...
+        ]
+        """
+
     @abstractmethod
     def get_ticker(self, pair: str) -> dict:
         """
@@ -62,26 +74,38 @@ class Exchange(ABC):
         """
 
     @abstractmethod
-    def get_ticker_history(self, pair: str, minimum_date: Optional[arrow.Arrow] = None) -> dict:
+    def get_ticker_history(self, pair: str, tick_interval: int) -> List[Dict]:
         """
         Gets ticker history for given pair.
         :param pair: Pair as str, format: BTC_ETC
-        :param minimum_date: Minimum date (optional)
+        :param tick_interval: ticker interval in minutes
+        :return: list, format: [
+            {
+                'O': float,       (Open)
+                'H': float,       (High)
+                'L': float,       (Low)
+                'C': float,       (Close)
+                'V': float,       (Volume)
+                'T': datetime,    (Time)
+                'BV': float,      (Base Volume)
+            },
+            ...
+        ]
+        """
+
+    def get_order(self, order_id: str) -> Dict:
+        """
+        Get order details for the given order_id.
+        :param order_id: ID as str
         :return: dict, format: {
-            'success': bool,
-            'message': str,
-            'result': [
-                {
-                    'O': float,       (Open)
-                    'H': float,       (High)
-                    'L': float,       (Low)
-                    'C': float,       (Close)
-                    'V': float,       (Volume)
-                    'T': datetime,    (Time)
-                    'BV': float,      (Base Volume)
-                },
-                ...
-            ]
+            'id': str,
+            'type': str,
+            'pair': str,
+            'opened': str ISO 8601 datetime,
+            'closed': str ISO 8601 datetime,
+            'rate': float,
+            'amount': float,
+            'remaining': int
         }
         """
 
@@ -93,24 +117,6 @@ class Exchange(ABC):
         :return: None
         """
 
-    @abstractmethod
-    def get_open_orders(self, pair: str) -> List[dict]:
-        """
-        Gets all open orders for given pair.
-        :param pair: Pair as str, format: BTC_ETC
-        :return: List of dicts, format: [
-            {
-                'id': str,
-                'type': str,
-                'opened': datetime,
-                'rate': float,
-                'amount': float,
-                'remaining': int,
-            },
-            ...
-        ]
-        """
-
     @abstractmethod
     def get_pair_detail_url(self, pair: str) -> str:
         """
@@ -125,3 +131,41 @@ class Exchange(ABC):
         Returns all available markets.
         :return: List of all available pairs
         """
+
+    @abstractmethod
+    def get_market_summaries(self) -> List[Dict]:
+        """
+        Returns a 24h market summary for all available markets
+        :return: list, format: [
+            {
+                'MarketName': str,
+                'High': float,
+                'Low': float,
+                'Volume': float,
+                'Last': float,
+                'TimeStamp': datetime,
+                'BaseVolume': float,
+                'Bid': float,
+                'Ask': float,
+                'OpenBuyOrders': int,
+                'OpenSellOrders': int,
+                'PrevDay': float,
+                'Created': datetime
+            },
+            ...
+        ]
+        """
+
+    @abstractmethod
+    def get_wallet_health(self) -> List[Dict]:
+        """
+        Returns a list of all wallet health information
+        :return: list, format: [
+            {
+                'Currency': str,
+                'IsActive': bool,
+                'LastChecked': str,
+                'Notice': str
+            },
+            ...
+        """

freqtrade/main.py

@@ -1,34 +1,67 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 import copy
 import json
 import logging
 import time
 import traceback
 from datetime import datetime
-from typing import Dict, Optional
+from signal import signal, SIGINT, SIGABRT, SIGTERM
+from typing import Dict, Optional, List
 
+import requests
+from cachetools import cached, TTLCache
 from jsonschema import validate
 
 from freqtrade import __version__, exchange, persistence
 from freqtrade.analyze import get_buy_signal
-from freqtrade.misc import CONF_SCHEMA, State, get_state, update_state
+from freqtrade.misc import CONF_SCHEMA, State, get_state, update_state, build_arg_parser, throttle
 from freqtrade.persistence import Trade
 from freqtrade.rpc import telegram
 
-logging.basicConfig(level=logging.DEBUG,
-                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
+logger = logging.getLogger('freqtrade')
 
 _CONF = {}
 
 
-def _process() -> None:
+def refresh_whitelist(whitelist: Optional[List[str]] = None) -> None:
+    """
+    Check wallet health and remove pair from whitelist if necessary
+    :param whitelist: a new whitelist (optional)
+    :return: None
+    """
+    whitelist = whitelist or _CONF['exchange']['pair_whitelist']
+
+    sanitized_whitelist = []
+    health = exchange.get_wallet_health()
+    for status in health:
+        pair = '{}_{}'.format(_CONF['stake_currency'], status['Currency'])
+        if pair not in whitelist:
+            continue
+        if status['IsActive']:
+            sanitized_whitelist.append(pair)
+        else:
+            logger.info(
+                'Ignoring %s from whitelist (reason: %s).',
+                pair, status.get('Notice') or 'wallet is not active'
+            )
+    if _CONF['exchange']['pair_whitelist'] != sanitized_whitelist:
+        logger.debug('Using refreshed pair whitelist: %s ...', sanitized_whitelist)
+        _CONF['exchange']['pair_whitelist'] = sanitized_whitelist
+
+
+def _process(dynamic_whitelist: Optional[bool] = False) -> bool:
     """
     Queries the persistence layer for open trades and handles them,
     otherwise a new trade is created.
-    :return: None
+    :param: dynamic_whitelist: True is a dynamic whitelist should be generated (optional)
+    :return: True if a trade has been created or closed, False otherwise
     """
+    state_changed = False
     try:
+        # Refresh whitelist based on wallet maintenance
+        refresh_whitelist(
+            gen_pair_whitelist(_CONF['stake_currency']) if dynamic_whitelist else None
+        )
         # Query trades from persistence layer
         trades = Trade.query.filter(Trade.is_open.is_(True)).all()
         if len(trades) < _CONF['max_open_trades']:
@@ -37,28 +70,39 @@ def _process() -> None:
                 trade = create_trade(float(_CONF['stake_amount']))
                 if trade:
                     Trade.session.add(trade)
+                    state_changed = True
                 else:
-                    logging.info('Got no buy signal...')
+                    logger.info(
+                        'Checked all whitelisted currencies. '
+                        'Found no suitable entry positions for buying. Will keep looking ...'
+                    )
             except ValueError:
                 logger.exception('Unable to create trade')
 
         for trade in trades:
-            # Check if there is already an open order for this trade
-            orders = exchange.get_open_orders(trade.pair)
-            orders = [o for o in orders if o['id'] == trade.open_order_id]
-            if orders:
-                logger.info('There is an open order for: %s', orders[0])
-            else:
-                # Update state
-                trade.open_order_id = None
-                # Check if this trade can be closed
-                if not close_trade_if_fulfilled(trade):
-                    # Check if we can sell our current pair
-                    handle_trade(trade)
-        Trade.session.flush()
-    except (ConnectionError, json.JSONDecodeError) as error:
-        msg = 'Got {} in _process()'.format(error.__class__.__name__)
+            # Get order details for actual price per unit
+            if trade.open_order_id:
+                # Update trade with order values
+                logger.info('Got open order for %s', trade)
+                trade.update(exchange.get_order(trade.open_order_id))
+
+            if not close_trade_if_fulfilled(trade):
+                # Check if we can sell our current pair
+                state_changed = handle_trade(trade) or state_changed
+
+            Trade.session.flush()
+    except (requests.exceptions.RequestException, json.JSONDecodeError) as error:
+        msg = 'Got {} in _process(), retrying in 30 seconds...'.format(error.__class__.__name__)
         logger.exception(msg)
+        time.sleep(30)
+    except RuntimeError:
+        telegram.send_msg('*Status:* Got RuntimeError:\n```\n{traceback}```{hint}'.format(
+            traceback=traceback.format_exc(),
+            hint='Issue `/start` if you think it is safe to restart.'
+        ))
+        logger.exception('Got RuntimeError. Stopping trader ...')
+        update_state(State.STOPPED)
+    return state_changed
 
 
 def close_trade_if_fulfilled(trade: Trade) -> bool:
@@ -74,28 +118,32 @@ def close_trade_if_fulfilled(trade: Trade) -> bool:
             and trade.close_rate is not None \
             and trade.open_order_id is None:
         trade.is_open = False
-        logger.info('No open orders found and trade is fulfilled. Marking %s as closed ...', trade)
+        logger.info(
+            'Marking %s as closed as the trade is fulfilled and found no open orders for it.',
+            trade
+        )
         return True
     return False
 
 
-def execute_sell(trade: Trade, current_rate: float) -> None:
+def execute_sell(trade: Trade, limit: float) -> None:
     """
-    Executes a sell for the given trade and current rate
+    Executes a limit sell for the given trade and limit
     :param trade: Trade instance
-    :param current_rate: current rate
+    :param limit: limit rate for the sell order
     :return: None
     """
-    # Get available balance
-    currency = trade.pair.split('_')[1]
-    balance = exchange.get_balance(currency)
-    profit = trade.exec_sell_order(current_rate, balance)
-    message = '*{}:* Selling [{}]({}) at rate `{:f} (profit: {}%)`'.format(
+    # Execute sell and update trade record
+    order_id = exchange.sell(str(trade.pair), limit, trade.amount)
+    trade.open_order_id = order_id
+
+    fmt_exp_profit = round(trade.calc_profit(limit) * 100, 2)
+    message = '*{}:* Selling [{}]({}) with limit `{:.8f} (profit: ~{:.2f}%)`'.format(
         trade.exchange,
         trade.pair.replace('_', '/'),
         exchange.get_pair_detail_url(trade.pair),
-        trade.close_rate,
-        round(profit, 2)
+        limit,
+        fmt_exp_profit
     )
     logger.info(message)
     telegram.send_msg(message)
@@ -106,41 +154,35 @@ def should_sell(trade: Trade, current_rate: float, current_time: datetime) -> bo
     Based an earlier trade and current price and configuration, decides whether bot should sell
     :return True if bot should sell at current rate
     """
-    current_profit = (current_rate - trade.open_rate) / trade.open_rate
-
+    current_profit = trade.calc_profit(current_rate)
     if 'stoploss' in _CONF and current_profit < float(_CONF['stoploss']):
         logger.debug('Stop loss hit.')
         return True
 
     for duration, threshold in sorted(_CONF['minimal_roi'].items()):
-        duration, threshold = float(duration), float(threshold)
         # Check if time matches and current rate is above threshold
         time_diff = (current_time - trade.open_date).total_seconds() / 60
-        if time_diff > duration and current_profit > threshold:
+        if time_diff > float(duration) and current_profit > threshold:
             return True
 
     logger.debug('Threshold not reached. (cur_profit: %1.2f%%)', current_profit * 100.0)
     return False
 
 
-def handle_trade(trade: Trade) -> None:
+def handle_trade(trade: Trade) -> bool:
     """
     Sells the current pair if the threshold is reached and updates the trade record.
-    :return: None
+    :return: True if trade has been sold, False otherwise
     """
-    try:
-        if not trade.is_open:
-            raise ValueError('attempt to handle closed trade: {}'.format(trade))
+    if not trade.is_open:
+        raise ValueError('attempt to handle closed trade: {}'.format(trade))
 
-        logger.debug('Handling open trade %s ...', trade)
-
-        current_rate = exchange.get_ticker(trade.pair)['bid']
-        if should_sell(trade, current_rate, datetime.utcnow()):
-            execute_sell(trade, current_rate)
-            return
-
-    except ValueError:
-        logger.exception('Unable to handle open order')
+    logger.debug('Handling %s ...', trade)
+    current_rate = exchange.get_ticker(trade.pair)['bid']
+    if should_sell(trade, current_rate, datetime.utcnow()):
+        execute_sell(trade, current_rate)
+        return True
+    return False
 
 
 def get_target_bid(ticker: Dict[str, float]) -> float:
@@ -157,12 +199,15 @@ def create_trade(stake_amount: float) -> Optional[Trade]:
     if one pair triggers the buy_signal a new trade record gets created
     :param stake_amount: amount of btc to spend
     """
-    logger.info('Creating new trade with stake_amount: %f ...', stake_amount)
+    logger.info(
+        'Checking buy signals to create a new trade with stake_amount: %f ...',
+        stake_amount
+    )
     whitelist = copy.deepcopy(_CONF['exchange']['pair_whitelist'])
     # Check if stake_amount is fulfilled
     if exchange.get_balance(_CONF['stake_currency']) < stake_amount:
         raise ValueError(
-            'stake amount is not fulfilled (currency={}'.format(_CONF['stake_currency'])
+            'stake amount is not fulfilled (currency={})'.format(_CONF['stake_currency'])
         )
 
     # Remove currently opened and latest pairs from whitelist
@@ -181,27 +226,30 @@ def create_trade(stake_amount: float) -> Optional[Trade]:
     else:
         return None
 
-    open_rate = get_target_bid(exchange.get_ticker(pair))
-    amount = stake_amount / open_rate
-    order_id = exchange.buy(pair, open_rate, amount)
+    # Calculate amount and subtract fee
+    fee = exchange.get_fee()
+    buy_limit = get_target_bid(exchange.get_ticker(pair))
+    amount = (1 - fee) * stake_amount / buy_limit
 
+    order_id = exchange.buy(pair, buy_limit, amount)
     # Create trade entity and return
-    message = '*{}:* Buying [{}]({}) at rate `{:f}`'.format(
-        exchange.EXCHANGE.name.upper(),
+    message = '*{}:* Buying [{}]({}) with limit `{:.8f}`'.format(
+        exchange.get_name().upper(),
         pair.replace('_', '/'),
         exchange.get_pair_detail_url(pair),
-        open_rate
+        buy_limit
     )
     logger.info(message)
     telegram.send_msg(message)
+    # Fee is applied twice because we make a LIMIT_BUY and LIMIT_SELL
     return Trade(pair=pair,
                  stake_amount=stake_amount,
-                 open_rate=open_rate,
-                 open_date=datetime.utcnow(),
                  amount=amount,
-                 exchange=exchange.EXCHANGE.name.upper(),
-                 open_order_id=order_id,
-                 is_open=True)
+                 fee=fee * 2,
+                 open_rate=buy_limit,
+                 open_date=datetime.utcnow(),
+                 exchange=exchange.get_name().upper(),
+                 open_order_id=order_id)
 
 
 def init(config: dict, db_url: Optional[str] = None) -> None:
@@ -223,50 +271,90 @@ def init(config: dict, db_url: Optional[str] = None) -> None:
     else:
         update_state(State.STOPPED)
 
+    # Register signal handlers
+    for sig in (SIGINT, SIGTERM, SIGABRT):
+        signal(sig, cleanup)
 
-def app(config: dict) -> None:
+
+@cached(TTLCache(maxsize=1, ttl=1800))
+def gen_pair_whitelist(base_currency: str, topn: int = 20, key: str = 'BaseVolume') -> List[str]:
     """
-    Main loop which handles the application state
-    :param config: config as dict
+    Updates the whitelist with with a dynamically generated list
+    :param base_currency: base currency as str
+    :param topn: maximum number of returned results
+    :param key: sort key (defaults to 'BaseVolume')
+    :return: List of pairs
+    """
+    summaries = sorted(
+        (s for s in exchange.get_market_summaries() if s['MarketName'].startswith(base_currency)),
+        key=lambda s: s.get(key) or 0.0,
+        reverse=True
+    )
+    return [s['MarketName'].replace('-', '_') for s in summaries[:topn]]
+
+
+def cleanup(*args, **kwargs) -> None:
+    """
+    Cleanup the application state und finish all pending tasks
     :return: None
     """
-    logger.info('Starting freqtrade %s', __version__)
-    init(config)
-    try:
-        old_state = get_state()
-        logger.info('Initial State: %s', old_state)
-        telegram.send_msg('*Status:* `{}`'.format(old_state.name.lower()))
-        while True:
-            new_state = get_state()
-            # Log state transition
-            if new_state != old_state:
-                telegram.send_msg('*Status:* `{}`'.format(new_state.name.lower()))
-                logging.info('Changing state to: %s', new_state.name)
-
-            if new_state == State.STOPPED:
-                time.sleep(1)
-            elif new_state == State.RUNNING:
-                _process()
-                # We need to sleep here because otherwise we would run into bittrex rate limit
-                time.sleep(exchange.EXCHANGE.sleep_time)
-            old_state = new_state
-    except RuntimeError:
-        telegram.send_msg('*Status:* Got RuntimeError: ```\n{}\n```'.format(traceback.format_exc()))
-        logger.exception('RuntimeError. Trader stopped!')
-    finally:
-        telegram.send_msg('*Status:* `Trader has stopped`')
+    telegram.send_msg('*Status:* `Stopping trader...`')
+    logger.info('Stopping trader and cleaning up modules...')
+    update_state(State.STOPPED)
+    persistence.cleanup()
+    telegram.cleanup()
+    exit(0)
 
 
 def main():
     """
-    Loads and validates the config and starts the main loop
+    Loads and validates the config and handles the main loop
     :return: None
     """
     global _CONF
-    with open('config.json') as file:
+    args = build_arg_parser().parse_args()
+
+    # Initialize logger
+    logging.basicConfig(
+        level=args.loglevel,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    )
+
+    logger.info(
+        'Starting freqtrade %s (loglevel=%s)',
+        __version__,
+        logging.getLevelName(args.loglevel)
+    )
+
+    # Load and validate configuration
+    with open(args.config) as file:
         _CONF = json.load(file)
-        validate(_CONF, CONF_SCHEMA)
-        app(_CONF)
+    if 'internals' not in _CONF:
+        _CONF['internals'] = {}
+    logger.info('Validating configuration ...')
+    validate(_CONF, CONF_SCHEMA)
+
+    # Initialize all modules and start main loop
+    if args.dynamic_whitelist:
+        logger.info('Using dynamically generated whitelist. (--dynamic-whitelist detected)')
+    init(_CONF)
+    old_state = None
+    while True:
+        new_state = get_state()
+        # Log state transition
+        if new_state != old_state:
+            telegram.send_msg('*Status:* `{}`'.format(new_state.name.lower()))
+            logger.info('Changing state to: %s', new_state.name)
+
+        if new_state == State.STOPPED:
+            time.sleep(1)
+        elif new_state == State.RUNNING:
+            throttle(
+                _process,
+                min_secs=_CONF['internals'].get('process_throttle_secs', 10),
+                dynamic_whitelist=args.dynamic_whitelist,
+            )
+        old_state = new_state
 
 
 if __name__ == '__main__':

freqtrade/misc.py

@@ -1,7 +1,15 @@
+import argparse
 import enum
+import logging
+from typing import Any, Callable
 
+import time
 from wrapt import synchronized
 
+from freqtrade import __version__
+
+logger = logging.getLogger(__name__)
+
 
 class State(enum.Enum):
     RUNNING = 0
@@ -32,6 +40,57 @@ def get_state() -> State:
     return _STATE
 
 
+def throttle(func: Callable[..., Any], min_secs: float, *args, **kwargs) -> Any:
+    """
+    Throttles the given callable that it
+    takes at least `min_secs` to finish execution.
+    :param func: Any callable
+    :param min_secs: minimum execution time in seconds
+    :return: Any
+    """
+    start = time.time()
+    result = func(*args, **kwargs)
+    end = time.time()
+    duration = max(min_secs - (end - start), 0.0)
+    logger.debug('Throttling %s for %.2f seconds', func.__name__, duration)
+    time.sleep(duration)
+    return result
+
+
+def build_arg_parser() -> argparse.ArgumentParser:
+    """ Builds and returns an ArgumentParser instance """
+    parser = argparse.ArgumentParser(
+        description='Simple High Frequency Trading Bot for crypto currencies'
+    )
+    parser.add_argument(
+        '-c', '--config',
+        help='specify configuration file (default: config.json)',
+        dest='config',
+        default='config.json',
+        type=str,
+        metavar='PATH',
+    )
+    parser.add_argument(
+        '-v', '--verbose',
+        help='be verbose',
+        action='store_const',
+        dest='loglevel',
+        const=logging.DEBUG,
+        default=logging.INFO,
+    )
+    parser.add_argument(
+        '--version',
+        action='version',
+        version='%(prog)s {}'.format(__version__),
+    )
+    parser.add_argument(
+        '--dynamic-whitelist',
+        help='dynamically generate and update whitelist based on 24h BaseVolume',
+        action='store_true',
+    )
+    return parser
+
+
 # Required json-schema for user specified config
 CONF_SCHEMA = {
     'type': 'object',
@@ -71,6 +130,12 @@ CONF_SCHEMA = {
             'required': ['enabled', 'token', 'chat_id']
         },
         'initial_state': {'type': 'string', 'enum': ['running', 'stopped']},
+        'internals': {
+            'type': 'object',
+            'properties': {
+                'process_throttle_secs': {'type': 'number'}
+            }
+        }
     },
     'definitions': {
         'exchange': {

freqtrade/persistence.py

@@ -1,87 +1,112 @@
+import logging
 from datetime import datetime
-from typing import Optional
+from decimal import Decimal, getcontext
+from typing import Optional, Dict
 
+import arrow
 from sqlalchemy import Boolean, Column, DateTime, Float, Integer, String, create_engine
+from sqlalchemy.engine import Engine
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm.scoping import scoped_session
 from sqlalchemy.orm.session import sessionmaker
-from sqlalchemy.types import Enum
+from sqlalchemy.pool import StaticPool
 
-from freqtrade import exchange
+logger = logging.getLogger(__name__)
 
 _CONF = {}
-
-Base = declarative_base()
+_DECL_BASE = declarative_base()
 
 
-def init(config: dict, db_url: Optional[str] = None) -> None:
+def init(config: dict, engine: Optional[Engine] = None) -> None:
     """
     Initializes this module with the given config,
     registers all known command handlers
     and starts polling for message updates
     :param config: config to use
-    :param db_url: database connector string for sqlalchemy (Optional)
+    :param engine: database engine for sqlalchemy (Optional)
     :return: None
     """
     _CONF.update(config)
-    if not db_url:
+    if not engine:
         if _CONF.get('dry_run', False):
-            db_url = 'sqlite:///tradesv2.dry_run.sqlite'
+            engine = create_engine('sqlite://',
+                                   connect_args={'check_same_thread': False},
+                                   poolclass=StaticPool,
+                                   echo=False)
         else:
-            db_url = 'sqlite:///tradesv2.sqlite'
+            engine = create_engine('sqlite:///tradesv3.sqlite')
 
-    engine = create_engine(db_url, echo=False)
     session = scoped_session(sessionmaker(bind=engine, autoflush=True, autocommit=True))
     Trade.session = session()
     Trade.query = session.query_property()
-    Base.metadata.create_all(engine)
+    _DECL_BASE.metadata.create_all(engine)
 
 
-class Trade(Base):
+def cleanup() -> None:
+    """
+    Flushes all pending operations to disk.
+    :return: None
+    """
+    Trade.session.flush()
+
+
+class Trade(_DECL_BASE):
     __tablename__ = 'trades'
 
     id = Column(Integer, primary_key=True)
     exchange = Column(String, nullable=False)
     pair = Column(String, nullable=False)
     is_open = Column(Boolean, nullable=False, default=True)
-    open_rate = Column(Float, nullable=False)
+    fee = Column(Float, nullable=False, default=0.0)
+    open_rate = Column(Float)
     close_rate = Column(Float)
     close_profit = Column(Float)
-    stake_amount = Column(Float, name='btc_amount', nullable=False)
-    amount = Column(Float, nullable=False)
+    stake_amount = Column(Float, nullable=False)
+    amount = Column(Float)
     open_date = Column(DateTime, nullable=False, default=datetime.utcnow)
     close_date = Column(DateTime)
     open_order_id = Column(String)
 
     def __repr__(self):
-        if self.is_open:
-            open_since = 'closed'
-        else:
-            open_since = round((datetime.utcnow() - self.open_date).total_seconds() / 60, 2)
         return 'Trade(id={}, pair={}, amount={}, open_rate={}, open_since={})'.format(
             self.id,
             self.pair,
             self.amount,
             self.open_rate,
-            open_since
+            arrow.get(self.open_date).humanize() if self.is_open else 'closed'
         )
 
-    def exec_sell_order(self, rate: float, amount: float) -> float:
+    def update(self, order: Dict) -> None:
         """
-        Executes a sell for the given trade and updated the entity.
-        :param rate: rate to sell for
-        :param amount: amount to sell
-        :return: current profit as percentage
+        Updates this entity with amount and actual open/close rates.
+        :param order: order retrieved by exchange.get_order()
+        :return: None
         """
-        profit = 100 * ((rate - self.open_rate) / self.open_rate)
+        if not order['closed']:
+            return
 
-        # Execute sell and update trade record
-        order_id = exchange.sell(str(self.pair), rate, amount)
-        self.close_rate = rate
-        self.close_profit = profit
-        self.close_date = datetime.utcnow()
-        self.open_order_id = order_id
+        logger.debug('Updating trade (id=%d) ...', self.id)
+        if order['type'] == 'LIMIT_BUY':
+            # Update open rate and actual amount
+            self.open_rate = order['rate']
+            self.amount = order['amount']
+        elif order['type'] == 'LIMIT_SELL':
+            # Set close rate and set actual profit
+            self.close_rate = order['rate']
+            self.close_profit = self.calc_profit()
+            self.close_date = datetime.utcnow()
+        else:
+            raise ValueError('Unknown order type: {}'.format(order['type']))
 
-        # Flush changes
-        Trade.session.flush()
-        return profit
+        self.open_order_id = None
+
+    def calc_profit(self, rate: Optional[float] = None) -> float:
+        """
+        Calculates the profit in percentage (including fee).
+        :param rate: rate to compare with (optional).
+        If rate is not set self.close_rate will be used
+        :return: profit in percentage as float
+        """
+        getcontext().prec = 8
+        return float((Decimal(rate or self.close_rate) - Decimal(self.open_rate))
+                     / Decimal(self.open_rate) - Decimal(self.fee))

freqtrade/rpc/telegram.py

@@ -1,6 +1,9 @@
 import logging
+import re
 from datetime import timedelta
 from typing import Callable, Any
+from pandas import DataFrame
+from tabulate import tabulate
 
 import arrow
 from sqlalchemy import and_, func, text
@@ -8,7 +11,7 @@ from telegram import ParseMode, Bot, Update
 from telegram.error import NetworkError
 from telegram.ext import CommandHandler, Updater
 
-from freqtrade import exchange
+from freqtrade import exchange, __version__
 from freqtrade.misc import get_state, State, update_state
 from freqtrade.persistence import Trade
 
@@ -17,7 +20,7 @@ logging.getLogger('requests.packages.urllib3').setLevel(logging.INFO)
 logging.getLogger('telegram').setLevel(logging.INFO)
 logger = logging.getLogger(__name__)
 
-_updater = None
+_UPDATER: Updater = None
 _CONF = {}
 
 
@@ -29,27 +32,30 @@ def init(config: dict) -> None:
     :param config: config to use
     :return: None
     """
-    global _updater
+    global _UPDATER
 
     _CONF.update(config)
-    if not _CONF['telegram']['enabled']:
+    if not is_enabled():
         return
 
-    _updater = Updater(token=config['telegram']['token'], workers=0)
+    _UPDATER = Updater(token=config['telegram']['token'], workers=0)
 
     # Register command handler and start telegram message polling
     handles = [
         CommandHandler('status', _status),
         CommandHandler('profit', _profit),
+        CommandHandler('balance', _balance),
         CommandHandler('start', _start),
         CommandHandler('stop', _stop),
         CommandHandler('forcesell', _forcesell),
         CommandHandler('performance', _performance),
+        CommandHandler('count', _count),
         CommandHandler('help', _help),
+        CommandHandler('version', _version),
     ]
     for handle in handles:
-        _updater.dispatcher.add_handler(handle)
-    _updater.start_polling(
+        _UPDATER.dispatcher.add_handler(handle)
+    _UPDATER.start_polling(
         clean=True,
         bootstrap_retries=3,
         timeout=30,
@@ -61,6 +67,23 @@ def init(config: dict) -> None:
     )
 
 
+def cleanup() -> None:
+    """
+    Stops all running telegram threads.
+    :return: None
+    """
+    if not is_enabled():
+        return
+    _UPDATER.stop()
+
+
+def is_enabled() -> bool:
+    """
+    Returns True if the telegram module is activated, False otherwise
+    """
+    return bool(_CONF['telegram'].get('enabled', False))
+
+
 def authorized_only(command_handler: Callable[[Bot, Update], None]) -> Callable[..., Any]:
     """
     Decorator to check if the message comes from the correct chat_id
@@ -70,15 +93,17 @@ def authorized_only(command_handler: Callable[[Bot, Update], None]) -> Callable[
     def wrapper(*args, **kwargs):
         bot, update = kwargs.get('bot') or args[0], kwargs.get('update') or args[1]
 
-        if not isinstance(bot, Bot) or not isinstance(update, Update):
-            raise ValueError('Received invalid Arguments: {}'.format(*args))
-
+        # Reject unauthorized messages
         chat_id = int(_CONF['telegram']['chat_id'])
-        if int(update.message.chat_id) == chat_id:
-            logger.info('Executing handler: %s for chat_id: %s', command_handler.__name__, chat_id)
-            return command_handler(*args, **kwargs)
-        else:
+        if int(update.message.chat_id) != chat_id:
             logger.info('Rejected unauthorized message from: %s', update.message.chat_id)
+            return wrapper
+
+        logger.info('Executing handler: %s for chat_id: %s', command_handler.__name__, chat_id)
+        try:
+            return command_handler(*args, **kwargs)
+        except BaseException:
+            logger.exception('Exception occurred within Telegram module')
     return wrapper
 
 
@@ -91,32 +116,39 @@ def _status(bot: Bot, update: Update) -> None:
     :param update: message update
     :return: None
     """
+
+    # Check if additional parameters are passed
+    params = update.message.text.replace('/status', '').split(' ') \
+        if update.message.text else []
+    if 'table' in params:
+        _status_table(bot, update)
+        return
+
     # Fetch open trade
     trades = Trade.query.filter(Trade.is_open.is_(True)).all()
     if get_state() != State.RUNNING:
         send_msg('*Status:* `trader is not running`', bot=bot)
     elif not trades:
-        send_msg('*Status:* `no active order`', bot=bot)
+        send_msg('*Status:* `no active trade`', bot=bot)
     else:
         for trade in trades:
+            order = None
+            if trade.open_order_id:
+                order = exchange.get_order(trade.open_order_id)
             # calculate profit and send message to user
             current_rate = exchange.get_ticker(trade.pair)['bid']
-            current_profit = 100 * ((current_rate - trade.open_rate) / trade.open_rate)
-            orders = exchange.get_open_orders(trade.pair)
-            orders = [o for o in orders if o['id'] == trade.open_order_id]
-            order = orders[0] if orders else None
-
+            current_profit = trade.calc_profit(current_rate)
             fmt_close_profit = '{:.2f}%'.format(
-                round(trade.close_profit, 2)
+                round(trade.close_profit * 100, 2)
             ) if trade.close_profit else None
             message = """
 *Trade ID:* `{trade_id}`
 *Current Pair:* [{pair}]({market_url})
 *Open Since:* `{date}`
 *Amount:* `{amount}`
-*Open Rate:* `{open_rate}`
+*Open Rate:* `{open_rate:.8f}`
 *Close Rate:* `{close_rate}`
-*Current Rate:* `{current_rate}`
+*Current Rate:* `{current_rate:.8f}`
 *Close Profit:* `{close_profit}`
 *Current Profit:* `{current_profit:.2f}%`
 *Open Order:* `{open_order}`
@@ -130,12 +162,51 @@ def _status(bot: Bot, update: Update) -> None:
                 current_rate=current_rate,
                 amount=round(trade.amount, 8),
                 close_profit=fmt_close_profit,
-                current_profit=round(current_profit, 2),
-                open_order='{} ({})'.format(order['remaining'], order['type']) if order else None,
+                current_profit=round(current_profit * 100, 2),
+                open_order='{} ({})'.format(
+                    order['remaining'], order['type']
+                ) if order else None,
             )
             send_msg(message, bot=bot)
 
 
+@authorized_only
+def _status_table(bot: Bot, update: Update) -> None:
+    """
+    Handler for /status table.
+    Returns the current TradeThread status in table format
+    :param bot: telegram bot
+    :param update: message update
+    :return: None
+    """
+    # Fetch open trade
+    trades = Trade.query.filter(Trade.is_open.is_(True)).all()
+    if get_state() != State.RUNNING:
+        send_msg('*Status:* `trader is not running`', bot=bot)
+    elif not trades:
+        send_msg('*Status:* `no active order`', bot=bot)
+    else:
+        trades_list = []
+        for trade in trades:
+            # calculate profit and send message to user
+            current_rate = exchange.get_ticker(trade.pair)['bid']
+            trades_list.append([
+                trade.id,
+                trade.pair,
+                shorten_date(arrow.get(trade.open_date).humanize(only_distance=True)),
+                '{:.2f}'.format(100 * trade.calc_profit(current_rate))
+            ])
+
+        columns = ['ID', 'Pair', 'Since', 'Profit']
+        df_statuses = DataFrame.from_records(trades_list, columns=columns)
+        df_statuses = df_statuses.set_index(columns[0])
+
+        message = tabulate(df_statuses, headers='keys', tablefmt='simple')
+        message = "<pre>{}</pre>".format(message)
+
+        send_msg(message, parse_mode=ParseMode.HTML)
+
+
 @authorized_only
 def _profit(bot: Bot, update: Update) -> None:
     """
@@ -151,6 +222,8 @@ def _profit(bot: Bot, update: Update) -> None:
     profits = []
     durations = []
     for trade in trades:
+        if not trade.open_rate:
+            continue
         if trade.close_date:
             durations.append((trade.close_date - trade.open_date).total_seconds())
         if trade.close_profit:
@@ -158,9 +231,9 @@ def _profit(bot: Bot, update: Update) -> None:
         else:
             # Get current rate
             current_rate = exchange.get_ticker(trade.pair)['bid']
-            profit = 100 * ((current_rate - trade.open_rate) / trade.open_rate)
+            profit = trade.calc_profit(current_rate)
 
-        profit_amounts.append((profit / 100) * trade.stake_amount)
+        profit_amounts.append(profit * trade.stake_amount)
         profits.append(profit)
 
     best_pair = Trade.session.query(Trade.pair, func.sum(Trade.close_profit).label('profit_sum')) \
@@ -175,7 +248,7 @@ def _profit(bot: Bot, update: Update) -> None:
 
     bp_pair, bp_rate = best_pair
     markdown_msg = """
-*ROI:* `{profit_btc:.2f} ({profit:.2f}%)`
+*ROI:* `{profit_btc:.8f} ({profit:.2f}%)`
 *Trade Count:* `{trade_count}`
 *First Trade opened:* `{first_trade_date}`
 *Latest Trade opened:* `{latest_trade_date}`
@@ -183,17 +256,41 @@ def _profit(bot: Bot, update: Update) -> None:
 *Best Performing:* `{best_pair}: {best_rate:.2f}%`
     """.format(
         profit_btc=round(sum(profit_amounts), 8),
-        profit=round(sum(profits), 2),
+        profit=round(sum(profits) * 100, 2),
         trade_count=len(trades),
         first_trade_date=arrow.get(trades[0].open_date).humanize(),
         latest_trade_date=arrow.get(trades[-1].open_date).humanize(),
         avg_duration=str(timedelta(seconds=sum(durations) / float(len(durations)))).split('.')[0],
         best_pair=bp_pair,
-        best_rate=round(bp_rate, 2),
+        best_rate=round(bp_rate * 100, 2),
     )
     send_msg(markdown_msg, bot=bot)
 
 
+@authorized_only
+def _balance(bot: Bot, update: Update) -> None:
+    """
+    Handler for /balance
+    Returns current account balance per crypto
+    """
+    output = ''
+    balances = [
+        c for c in exchange.get_balances()
+        if c['Balance'] or c['Available'] or c['Pending']
+    ]
+    if not balances:
+        output = '`All balances are zero.`'
+
+    for currency in balances:
+        output += """*Currency*: {Currency}
+*Available*: {Available}
+*Balance*: {Balance}
+*Pending*: {Pending}
+
+""".format(**currency)
+    send_msg(output)
+
+
 @authorized_only
 def _start(bot: Bot, update: Update) -> None:
     """
@@ -238,38 +335,29 @@ def _forcesell(bot: Bot, update: Update) -> None:
         send_msg('`trader is not running`', bot=bot)
         return
 
-    try:
-        trade_id = int(update.message.text
-                       .replace('/forcesell', '')
-                       .strip())
-        # Query for trade
-        trade = Trade.query.filter(and_(
-            Trade.id == trade_id,
-            Trade.is_open.is_(True)
-        )).first()
-        if not trade:
-            send_msg('There is no open trade with ID: `{}`'.format(trade_id))
-            return
-        # Get current rate
-        current_rate = exchange.get_ticker(trade.pair)['bid']
-        # Get available balance
-        currency = trade.pair.split('_')[1]
-        balance = exchange.get_balance(currency)
-        # Execute sell
-        profit = trade.exec_sell_order(current_rate, balance)
-        message = '*{}:* Selling [{}]({}) at rate `{:f} (profit: {}%)`'.format(
-            trade.exchange,
-            trade.pair.replace('_', '/'),
-            exchange.get_pair_detail_url(trade.pair),
-            trade.close_rate,
-            round(profit, 2)
-        )
-        logger.info(message)
-        send_msg(message)
+    trade_id = update.message.text.replace('/forcesell', '').strip()
+    if trade_id == 'all':
+        # Execute sell for all open orders
+        for trade in Trade.query.filter(Trade.is_open.is_(True)).all():
+            # Get current rate
+            current_rate = exchange.get_ticker(trade.pair)['bid']
+            from freqtrade.main import execute_sell
+            execute_sell(trade, current_rate)
+        return
 
-    except ValueError:
-        send_msg('Invalid argument. Usage: `/forcesell <trade_id>`')
+    # Query for trade
+    trade = Trade.query.filter(and_(
+        Trade.id == trade_id,
+        Trade.is_open.is_(True)
+    )).first()
+    if not trade:
+        send_msg('Invalid argument. See `/help` to view usage')
         logger.warning('/forcesell: Invalid argument received')
+        return
+    # Get current rate
+    current_rate = exchange.get_ticker(trade.pair)['bid']
+    from freqtrade.main import execute_sell
+    execute_sell(trade, current_rate)
 
 
 @authorized_only
@@ -291,13 +379,37 @@ def _performance(bot: Bot, update: Update) -> None:
         .order_by(text('profit_sum DESC')) \
         .all()
 
-    stats = '\n'.join('{index}. <code>{pair}\t{profit:.2f}%</code>'.format(
+    stats = '\n'.join('{index}.\t<code>{pair}\t{profit:.2f}%</code>'.format(
         index=i + 1,
         pair=pair,
-        profit=round(rate, 2)
+        profit=round(rate * 100, 2)
     ) for i, (pair, rate) in enumerate(pair_rates))
 
-    message = '<b>Performance:</b>\n{}\n'.format(stats)
+    message = '<b>Performance:</b>\n{}'.format(stats)
+    logger.debug(message)
+    send_msg(message, parse_mode=ParseMode.HTML)
+
+
+@authorized_only
+def _count(bot: Bot, update: Update) -> None:
+    """
+    Handler for /count.
+    Returns the number of trades running
+    :param bot: telegram bot
+    :param update: message update
+    :return: None
+    """
+    if get_state() != State.RUNNING:
+        send_msg('`trader is not running`', bot=bot)
+        return
+
+    trades = Trade.query.filter(Trade.is_open.is_(True)).all()
+
+    message = tabulate({
+        'current': [len(trades)],
+        'max': [_CONF['max_open_trades']]
+    }, headers=['current', 'max'], tablefmt='simple')
+    message = "<pre>{}</pre>".format(message)
     logger.debug(message)
     send_msg(message, parse_mode=ParseMode.HTML)
 
@@ -314,15 +426,43 @@ def _help(bot: Bot, update: Update) -> None:
     message = """
 */start:* `Starts the trader`
 */stop:* `Stops the trader`
-*/status:* `Lists all open trades`
+*/status [table]:* `Lists all open trades`
+            *table :* `will display trades in a table`
 */profit:* `Lists cumulative profit from all finished trades`
-*/forcesell <trade_id>:* `Instantly sells the given trade, regardless of profit`
+*/forcesell <trade_id>|all:* `Instantly sells the given trade or all trades, regardless of profit`
 */performance:* `Show performance of each finished trade grouped by pair`
+*/count:* `Show number of trades running compared to allowed number of trades`
+*/balance:* `Show account balance per currency`
 */help:* `This help message`
+*/version:* `Show version`
     """
     send_msg(message, bot=bot)
 
 
+@authorized_only
+def _version(bot: Bot, update: Update) -> None:
+    """
+    Handler for /version.
+    Show version information
+    :param bot: telegram bot
+    :param update: message update
+    :return: None
+    """
+    send_msg('*Version:* `{}`'.format(__version__), bot=bot)
+
+
+def shorten_date(date):
+    """
+    Trim the date so it fits on small screens
+    """
+    new_date = re.sub('seconds?', 'sec', date)
+    new_date = re.sub('minutes?', 'min', new_date)
+    new_date = re.sub('hours?', 'h', new_date)
+    new_date = re.sub('days?', 'd', new_date)
+    new_date = re.sub('^an?', '1', new_date)
+    return new_date
+
+
 def send_msg(msg: str, bot: Bot = None, parse_mode: ParseMode = ParseMode.MARKDOWN) -> None:
     """
     Send given markdown message
@@ -331,18 +471,17 @@ def send_msg(msg: str, bot: Bot = None, parse_mode: ParseMode = ParseMode.MARKDO
     :param parse_mode: telegram parse mode
     :return: None
     """
-    if _CONF['telegram'].get('enabled', False):
-        try:
-            bot = bot or _updater.bot
-            try:
-                bot.send_message(_CONF['telegram']['chat_id'], msg, parse_mode=parse_mode)
-            except NetworkError as error:
-                # Sometimes the telegram server resets the current connection,
-                # if this is the case we send the message again.
-                logger.warning(
-                    'Got Telegram NetworkError: %s! Trying one more time.',
-                    error.message
-                )
-                bot.send_message(_CONF['telegram']['chat_id'], msg, parse_mode=parse_mode)
-        except Exception:
-            logger.exception('Exception occurred within Telegram API')
+    if not is_enabled():
+        return
+
+    bot = bot or _UPDATER.bot
+    try:
+        bot.send_message(_CONF['telegram']['chat_id'], msg, parse_mode=parse_mode)
+    except NetworkError as error:
+        # Sometimes the telegram server resets the current connection,
+        # if this is the case we send the message again.
+        logger.warning(
+            'Got Telegram NetworkError: %s! Trying one more time.',
+            error.message
+        )
+        bot.send_message(_CONF['telegram']['chat_id'], msg, parse_mode=parse_mode)

freqtrade/tests/conftest.py

@@ -0,0 +1,149 @@
+# pragma pylint: disable=missing-docstring
+import json
+from datetime import datetime
+from unittest.mock import MagicMock
+
+import pytest
+from jsonschema import validate
+from telegram import Message, Chat, Update
+
+from freqtrade.misc import CONF_SCHEMA
+
+
+@pytest.fixture(scope="module")
+def default_conf():
+    """ Returns validated configuration suitable for most tests """
+    configuration = {
+        "max_open_trades": 1,
+        "stake_currency": "BTC",
+        "stake_amount": 0.05,
+        "dry_run": True,
+        "minimal_roi": {
+            "40":  0.0,
+            "30":  0.01,
+            "20":  0.02,
+            "0":  0.04
+        },
+        "stoploss": -0.05,
+        "bid_strategy": {
+            "ask_last_balance": 0.0
+        },
+        "exchange": {
+            "name": "bittrex",
+            "enabled": True,
+            "key": "key",
+            "secret": "secret",
+            "pair_whitelist": [
+                "BTC_ETH",
+                "BTC_TKN",
+                "BTC_TRST",
+                "BTC_SWT",
+                "BTC_BCC"
+            ]
+        },
+        "telegram": {
+            "enabled": True,
+            "token": "token",
+            "chat_id": "0"
+        },
+        "initial_state": "running"
+    }
+    validate(configuration, CONF_SCHEMA)
+    return configuration
+
+
+@pytest.fixture(scope="module")
+def backtest_conf():
+    return {
+        "minimal_roi": {
+            "40":  0.0,
+            "30":  0.01,
+            "20":  0.02,
+            "0":  0.04
+        },
+        "stoploss": -0.05
+    }
+
+
+@pytest.fixture(scope="module")
+def backdata():
+    result = {}
+    for pair in ['btc-neo', 'btc-eth', 'btc-omg', 'btc-edg', 'btc-pay',
+                 'btc-pivx', 'btc-qtum', 'btc-mtl', 'btc-etc', 'btc-ltc']:
+        with open('freqtrade/tests/testdata/' + pair + '.json') as data_file:
+            result[pair] = json.load(data_file)
+    return result
+
+
+@pytest.fixture
+def update():
+    _update = Update(0)
+    _update.message = Message(0, 0, datetime.utcnow(), Chat(0, 0))
+    return _update
+
+
+@pytest.fixture
+def ticker():
+    return MagicMock(return_value={
+        'bid': 0.07256061,
+        'ask': 0.072661,
+        'last': 0.07256061,
+    })
+
+
+@pytest.fixture
+def health():
+    return MagicMock(return_value=[{
+        'Currency': 'BTC',
+        'IsActive': True,
+        'LastChecked': '2017-11-13T20:15:00.00',
+        'Notice': None
+    }, {
+        'Currency': 'ETH',
+        'IsActive': True,
+        'LastChecked': '2017-11-13T20:15:00.00',
+        'Notice': None
+    }, {
+        'Currency': 'TRST',
+        'IsActive': True,
+        'LastChecked': '2017-11-13T20:15:00.00',
+        'Notice': None
+    }, {
+        'Currency': 'SWT',
+        'IsActive': True,
+        'LastChecked': '2017-11-13T20:15:00.00',
+        'Notice': None
+    }, {
+        'Currency': 'BCC',
+        'IsActive': False,
+        'LastChecked': '2017-11-13T20:15:00.00',
+        'Notice': None
+    }])
+
+
+@pytest.fixture
+def limit_buy_order():
+    return {
+        'id': 'mocked_limit_buy',
+        'type': 'LIMIT_BUY',
+        'pair': 'mocked',
+        'opened': datetime.utcnow(),
+        'rate': 0.07256061,
+        'amount': 206.43811673387373,
+        'remaining': 0.0,
+        'closed': datetime.utcnow(),
+    }
+
+
+@pytest.fixture
+def limit_sell_order():
+    return {
+        'id': 'mocked_limit_sell',
+        'type': 'LIMIT_SELL',
+        'pair': 'mocked',
+        'opened': datetime.utcnow(),
+        'rate': 0.0802134,
+        'amount': 206.43811673387373,
+        'remaining': 0.0,
+        'closed': datetime.utcnow(),
+    }

freqtrade/tests/test_analyze.py

@@ -1,47 +1,39 @@
 # pragma pylint: disable=missing-docstring
+from datetime import datetime
+import json
 import pytest
-import arrow
 from pandas import DataFrame
 
 from freqtrade.analyze import parse_ticker_dataframe, populate_buy_trend, populate_indicators, \
     get_buy_signal
 
-RESULT_BITTREX = {
-    'success': True,
-    'message': '',
-    'result': [
-        {'O': 0.00065311, 'H': 0.00065311, 'L': 0.00065311, 'C': 0.00065311, 'V': 22.17210568, 'T': '2017-08-30T10:40:00', 'BV': 0.01448082},
-        {'O': 0.00066194, 'H': 0.00066195, 'L': 0.00066194, 'C': 0.00066195, 'V': 33.4727437, 'T': '2017-08-30T10:34:00', 'BV': 0.02215696},
-        {'O': 0.00065311, 'H': 0.00065311, 'L': 0.00065311, 'C': 0.00065311, 'V': 53.85127609, 'T': '2017-08-30T10:37:00', 'BV': 0.0351708},
-        {'O': 0.00066194, 'H': 0.00066194, 'L': 0.00065311, 'C': 0.00065311, 'V': 46.29210665, 'T': '2017-08-30T10:42:00', 'BV': 0.03063118},
-    ]
-}
 
 @pytest.fixture
 def result():
-    return parse_ticker_dataframe(RESULT_BITTREX['result'], arrow.get('2017-08-30T10:00:00'))
+    with open('freqtrade/tests/testdata/btc-eth.json') as data_file:
+        return parse_ticker_dataframe(json.load(data_file))
 
-def test_dataframe_has_correct_columns(result):
+
+def test_dataframe_correct_columns(result):
     assert result.columns.tolist() == \
-                        ['close', 'high', 'low', 'open', 'date', 'volume']
+        ['close', 'high', 'low', 'open', 'date', 'volume']
+
+
+def test_dataframe_correct_length(result):
+    assert len(result.index) == 5751
 
-def test_orders_by_date(result):
-    assert result['date'].tolist() == \
-                        ['2017-08-30T10:34:00',
-                        '2017-08-30T10:37:00',
-                        '2017-08-30T10:40:00',
-                        '2017-08-30T10:42:00']
 
 def test_populates_buy_trend(result):
     dataframe = populate_buy_trend(populate_indicators(result))
     assert 'buy' in dataframe.columns
     assert 'buy_price' in dataframe.columns
 
+
 def test_returns_latest_buy_signal(mocker):
-    buydf = DataFrame([{'buy': 1, 'date': arrow.utcnow()}])
+    buydf = DataFrame([{'buy': 1, 'date': datetime.today()}])
     mocker.patch('freqtrade.analyze.analyze_ticker', return_value=buydf)
     assert get_buy_signal('BTC-ETH')
 
-    buydf = DataFrame([{'buy': 0, 'date': arrow.utcnow()}])
+    buydf = DataFrame([{'buy': 0, 'date': datetime.today()}])
     mocker.patch('freqtrade.analyze.analyze_ticker', return_value=buydf)
     assert not get_buy_signal('BTC-ETH')

freqtrade/tests/test_backtesting.py

@@ -1,5 +1,4 @@
 # pragma pylint: disable=missing-docstring
-import json
 import logging
 import os
 
@@ -7,71 +6,60 @@ import pytest
 import arrow
 from pandas import DataFrame
 
+from freqtrade import exchange
 from freqtrade.analyze import analyze_ticker
+from freqtrade.exchange import Bittrex
 from freqtrade.main import should_sell
 from freqtrade.persistence import Trade
 
-logging.disable(logging.DEBUG) # disable debug logs that slow backtesting a lot
+logging.disable(logging.DEBUG)  # disable debug logs that slow backtesting a lot
 
-def print_results(results):
-    print('Made {} buys. Average profit {:.2f}%. Total profit was {:.3f}. Average duration {:.1f} mins.'.format(
-        len(results.index),
-        results.profit.mean() * 100.0,
-        results.profit.sum(),
-        results.duration.mean() * 5
-    ))
 
-@pytest.fixture
-def pairs():
-    return ['btc-neo', 'btc-eth', 'btc-omg', 'btc-edg', 'btc-pay',
-            'btc-pivx', 'btc-qtum', 'btc-mtl', 'btc-etc', 'btc-ltc']
+def format_results(results):
+    return 'Made {} buys. Average profit {:.2f}%. Total profit was {:.3f}. Average duration {:.1f} mins.'.format(
+        len(results.index), results.profit.mean() * 100.0, results.profit.sum(), results.duration.mean() * 5)
 
-@pytest.fixture
-def conf():
-    return {
-        "minimal_roi": {
-            "50":  0.0,
-            "40":  0.01,
-            "30":  0.02,
-            "0":  0.045
-        },
-        "stoploss": -0.40
-    }
+
+def print_pair_results(pair, results):
+    print('For currency {}:'.format(pair))
+    print(format_results(results[results.currency == pair]))
+
+
+def backtest(backtest_conf, backdata, mocker):
+    trades = []
+    exchange._API = Bittrex({'key': '', 'secret': ''})
+    mocked_history = mocker.patch('freqtrade.analyze.get_ticker_history')
+    mocker.patch.dict('freqtrade.main._CONF', backtest_conf)
+    mocker.patch('arrow.utcnow', return_value=arrow.get('2017-08-20T14:50:00'))
+    for pair, pair_data in backdata.items():
+        mocked_history.return_value = pair_data
+        ticker = analyze_ticker(pair)[['close', 'date', 'buy']].copy()
+        # for each buy point
+        for row in ticker[ticker.buy == 1].itertuples(index=True):
+            trade = Trade(
+                open_rate=row.close,
+                open_date=row.date,
+                amount=1,
+                fee=exchange.get_fee() * 2
+            )
+            # calculate win/lose forwards from buy point
+            for row2 in ticker[row.Index:].itertuples(index=True):
+                if should_sell(trade, row2.close, row2.date):
+                    current_profit = trade.calc_profit(row2.close)
+
+                    trades.append((pair, current_profit, row2.Index - row.Index))
+                    break
+    labels = ['currency', 'profit', 'duration']
+    results = DataFrame.from_records(trades, columns=labels)
+    return results
 
 
 @pytest.mark.skipif(not os.environ.get('BACKTEST', False), reason="BACKTEST not set")
-def test_backtest(conf, pairs, mocker):
-    trades = []
-    mocker.patch.dict('freqtrade.main._CONF', conf)
-    for pair in pairs:
-        with open('freqtrade/tests/testdata/'+pair+'.json') as data_file:
-            data = json.load(data_file)
-
-            mocker.patch('freqtrade.analyze.get_ticker_history', return_value=data)
-            mocker.patch('arrow.utcnow', return_value=arrow.get('2017-08-20T14:50:00'))
-            ticker = analyze_ticker(pair)
-            # for each buy point
-            for index, row in ticker[ticker.buy == 1].iterrows():
-                trade = Trade(
-                    open_rate=row['close'],
-                    open_date=arrow.get(row['date']).datetime,
-                    amount=1,
-                )
-                # calculate win/lose forwards from buy point
-                for index2, row2 in ticker[index:].iterrows():
-                    if should_sell(trade, row2['close'], arrow.get(row2['date']).datetime):
-                        current_profit = (row2['close'] - trade.open_rate) / trade.open_rate
-
-                        trades.append((pair, current_profit, index2 - index))
-                        break
-        
-    labels = ['currency', 'profit', 'duration']
-    results = DataFrame.from_records(trades, columns=labels)
+def test_backtest(backtest_conf, backdata, mocker, report=True):
+    results = backtest(backtest_conf, backdata, mocker)
 
     print('====================== BACKTESTING REPORT ================================')
-
-    for pair in pairs:
-        print('For currency {}:'.format(pair))
-        print_results(results[results.currency == pair])
+    for pair in backdata:
+        print_pair_results(pair, results)
     print('TOTAL OVER ALL TRADES:')
-    print_results(results)
+    print(format_results(results))

freqtrade/tests/test_exchange.py

@@ -0,0 +1,36 @@
+# pragma pylint: disable=missing-docstring
+from unittest.mock import MagicMock
+
+import pytest
+
+from freqtrade.exchange import validate_pairs
+
+
+def test_validate_pairs(default_conf, mocker):
+    api_mock = MagicMock()
+    api_mock.get_markets = MagicMock(return_value=[
+        'BTC_ETH', 'BTC_TKN', 'BTC_TRST', 'BTC_SWT', 'BTC_BCC',
+    ])
+    mocker.patch('freqtrade.exchange._API', api_mock)
+    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
+    validate_pairs(default_conf['exchange']['pair_whitelist'])
+
+
+def test_validate_pairs_not_available(default_conf, mocker):
+    api_mock = MagicMock()
+    api_mock.get_markets = MagicMock(return_value=[])
+    mocker.patch('freqtrade.exchange._API', api_mock)
+    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
+    with pytest.raises(RuntimeError, match=r'not available'):
+        validate_pairs(default_conf['exchange']['pair_whitelist'])
+
+
+def test_validate_pairs_not_compatible(default_conf, mocker):
+    api_mock = MagicMock()
+    api_mock.get_markets = MagicMock(return_value=['BTC_ETH', 'BTC_TKN', 'BTC_TRST', 'BTC_SWT'])
+    default_conf['stake_currency'] = 'ETH'
+    mocker.patch('freqtrade.exchange._API', api_mock)
+    mocker.patch.dict('freqtrade.exchange._CONF', default_conf)
+    with pytest.raises(RuntimeError, match=r'not compatible'):
+        validate_pairs(default_conf['exchange']['pair_whitelist'])
+

freqtrade/tests/test_hyperopt.py

@@ -1,112 +1,58 @@
 # pragma pylint: disable=missing-docstring
-import json
 import logging
 import os
 from functools import reduce
+from math import exp
+from operator import itemgetter
 
 import pytest
-import arrow
+from hyperopt import fmin, tpe, hp, Trials, STATUS_OK
 from pandas import DataFrame
 
-from hyperopt import fmin, tpe, hp
+from freqtrade.tests.test_backtesting import backtest, format_results
+from freqtrade.vendor.qtpylib.indicators import crossed_above
 
-from freqtrade.analyze import analyze_ticker
-from freqtrade.main import should_sell
-from freqtrade.persistence import Trade
+logging.disable(logging.DEBUG)  # disable debug logs that slow backtesting a lot
 
-logging.disable(logging.DEBUG) # disable debug logs that slow backtesting a lot
-
-def print_results(results):
-    print('Made {} buys. Average profit {:.2f}%. Total profit was {:.3f}. Average duration {:.1f} mins.'.format(
-        len(results.index),
-        results.profit.mean() * 100.0,
-        results.profit.sum(),
-        results.duration.mean() * 5
-    ))
-
-@pytest.fixture
-def pairs():
-    return ['btc-neo', 'btc-eth', 'btc-omg', 'btc-edg', 'btc-pay',
-            'btc-pivx', 'btc-qtum', 'btc-mtl', 'btc-etc', 'btc-ltc']
-
-@pytest.fixture
-def conf():
-    return {
-        "minimal_roi": {
-            "40":  0.0,
-            "30":  0.01,
-            "20":  0.02,
-            "0":  0.04
-        },
-        "stoploss": -0.05
-    }
-
-
-def backtest(conf, pairs, mocker, buy_strategy):
-    trades = []
-    mocker.patch.dict('freqtrade.main._CONF', conf)
-    for pair in pairs:
-        with open('freqtrade/tests/testdata/'+pair+'.json') as data_file:
-            data = json.load(data_file)
-
-            mocker.patch('freqtrade.analyze.get_ticker_history', return_value=data)
-            mocker.patch('arrow.utcnow', return_value=arrow.get('2017-08-20T14:50:00'))
-            mocker.patch('freqtrade.analyze.populate_buy_trend', side_effect=buy_strategy)
-            ticker = analyze_ticker(pair)
-            # for each buy point
-            for index, row in ticker[ticker.buy == 1].iterrows():
-                trade = Trade(
-                    open_rate=row['close'],
-                    open_date=arrow.get(row['date']).datetime,
-                    amount=1,
-                )
-                # calculate win/lose forwards from buy point
-                for index2, row2 in ticker[index:].iterrows():
-                    if should_sell(trade, row2['close'], arrow.get(row2['date']).datetime):
-                        current_profit = (row2['close'] - trade.open_rate) / trade.open_rate
-
-                        trades.append((pair, current_profit, index2 - index))
-                        break
-
-    labels = ['currency', 'profit', 'duration']
-    results = DataFrame.from_records(trades, columns=labels)
-
-    print_results(results)
-
-    # set the value below to suit your number concurrent trades so its realistic to 20days of data
-    TARGET_TRADES = 1200
-    if results.profit.sum() == 0 or results.profit.mean() == 0:
-        return 49999999999 # avoid division by zero, return huge value to discard result
-    return abs(len(results.index) - 1200.1) / (results.profit.sum() ** 2) * results.duration.mean() # the smaller the better
+# set TARGET_TRADES to suit your number concurrent trades so its realistic to 20days of data
+TARGET_TRADES = 1300
+TOTAL_TRIES = 4
+current_tries = 0
 
 def buy_strategy_generator(params):
-    print(params)
     def populate_buy_trend(dataframe: DataFrame) -> DataFrame:
         conditions = []
         # GUARDS AND TRENDS
-        if params['below_sma']['enabled']:
-            conditions.append(dataframe['close'] < dataframe['sma'])
-        if params['over_sma']['enabled']:
-            conditions.append(dataframe['close'] > dataframe['sma'])
+        if params['uptrend_long_ema']['enabled']:
+            conditions.append(dataframe['ema50'] > dataframe['ema100'])
+        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['cci']['enabled']:
-            conditions.append(dataframe['cci'] < params['cci']['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)
 
-        prev_fastd = dataframe['fastd'].shift(1)
         # TRIGGERS
         triggers = {
             'lower_bb': dataframe['tema'] <= dataframe['blower'],
-            'faststoch10': (dataframe['fastd'] >= 10) & (prev_fastd < 10),
+            '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'])),
         }
         conditions.append(triggers.get(params['trigger']['type']))
 
@@ -118,34 +64,56 @@ def buy_strategy_generator(params):
         return dataframe
     return populate_buy_trend
 
+
 @pytest.mark.skipif(not os.environ.get('BACKTEST', False), reason="BACKTEST not set")
-def test_hyperopt(conf, pairs, mocker):
+def test_hyperopt(backtest_conf, backdata, mocker):
+    mocked_buy_trend = mocker.patch('freqtrade.analyze.populate_buy_trend')
 
     def optimizer(params):
-        return backtest(conf, pairs, mocker, buy_strategy_generator(params))
+        mocked_buy_trend.side_effect = buy_strategy_generator(params)
+
+        results = backtest(backtest_conf, backdata, mocker)
+
+        result = format_results(results)
+
+        total_profit = results.profit.sum() * 1000
+        trade_count = len(results.index)
+
+        trade_loss = 1 - 0.4 * exp(-(trade_count - TARGET_TRADES) ** 2 / 10 ** 5.2)
+        profit_loss = max(0, 1 - total_profit / 15000)  # max profit 15000
+
+        global current_tries
+        current_tries += 1
+        print('{}/{}: {}'.format(current_tries, TOTAL_TRIES, result))
+
+        return {
+            'loss': trade_loss + profit_loss,
+            'status': STATUS_OK,
+            'result': result
+        }
 
     space = {
         'mfi': hp.choice('mfi', [
             {'enabled': False},
-            {'enabled': True, 'value': hp.uniform('mfi-value', 2, 40)}
+            {'enabled': True, 'value': hp.quniform('mfi-value', 5, 25, 1)}
         ]),
         'fastd': hp.choice('fastd', [
             {'enabled': False},
-            {'enabled': True, 'value': hp.uniform('fastd-value', 2, 40)}
+            {'enabled': True, 'value': hp.quniform('fastd-value', 10, 50, 1)}
         ]),
         'adx': hp.choice('adx', [
             {'enabled': False},
-            {'enabled': True, 'value': hp.uniform('adx-value', 2, 40)}
+            {'enabled': True, 'value': hp.quniform('adx-value', 15, 50, 1)}
         ]),
-        'cci': hp.choice('cci', [
+        'rsi': hp.choice('rsi', [
             {'enabled': False},
-            {'enabled': True, 'value': hp.uniform('cci-value', -200, -100)}
+            {'enabled': True, 'value': hp.quniform('rsi-value', 20, 40, 1)}
         ]),
-        'below_sma': hp.choice('below_sma', [
+        'uptrend_long_ema': hp.choice('uptrend_long_ema', [
             {'enabled': False},
             {'enabled': True}
         ]),
-        'over_sma': hp.choice('over_sma', [
+        'uptrend_short_ema': hp.choice('uptrend_short_ema', [
             {'enabled': False},
             {'enabled': True}
         ]),
@@ -153,14 +121,28 @@ def test_hyperopt(conf, pairs, mocker):
             {'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': 'faststoch10'}
+            {'type': 'faststoch10'},
+            {'type': 'ao_cross_zero'},
+            {'type': 'ema5_cross_ema10'},
+            {'type': 'macd_cross_signal'},
+            {'type': 'sar_reversal'},
+            {'type': 'stochf_cross'},
+            {'type': 'ht_sine'},
         ]),
     }
-
-    print('Best parameters {}'.format(fmin(fn=optimizer, space=space, algo=tpe.suggest, max_evals=40)))
+    trials = Trials()
+    best = fmin(fn=optimizer, space=space, algo=tpe.suggest, max_evals=TOTAL_TRIES, trials=trials)
+    print('\n\n\n\n==================== HYPEROPT BACKTESTING REPORT ==============================')
+    print('Best parameters {}'.format(best))
+    newlist = sorted(trials.results, key=itemgetter('loss'))
+    print('Result: {}'.format(newlist[0]['result']))

freqtrade/tests/test_main.py

@@ -1,89 +1,167 @@
 # pragma pylint: disable=missing-docstring
 import copy
-from unittest.mock import MagicMock, call
+from unittest.mock import MagicMock
 
 import pytest
-from jsonschema import validate
+import requests
+from sqlalchemy import create_engine
 
 from freqtrade.exchange import Exchanges
 from freqtrade.main import create_trade, handle_trade, close_trade_if_fulfilled, init, \
-    get_target_bid
-from freqtrade.misc import CONF_SCHEMA
+    get_target_bid, _process
+from freqtrade.misc import get_state, State
 from freqtrade.persistence import Trade
 
 
-@pytest.fixture
-def conf():
-    configuration = {
-        "max_open_trades": 3,
-        "stake_currency": "BTC",
-        "stake_amount": 0.05,
-        "dry_run": True,
-        "minimal_roi": {
-            "2880": 0.005,
-            "720": 0.01,
-            "0": 0.02
-        },
-        "bid_strategy": {
-            "ask_last_balance": 0.0
-        },
-        "exchange": {
-            "name": "bittrex",
-            "enabled": True,
-            "key": "key",
-            "secret": "secret",
-            "pair_whitelist": [
-                "BTC_ETH",
-                "BTC_TKN",
-                "BTC_TRST",
-                "BTC_SWT",
-            ]
-        },
-        "telegram": {
-            "enabled": True,
-            "token": "token",
-            "chat_id": "chat_id"
-        }
-    }
-    validate(configuration, CONF_SCHEMA)
-    return configuration
+def test_process_trade_creation(default_conf, ticker, health, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    mocker.patch.multiple('freqtrade.main.telegram', init=MagicMock(), send_msg=MagicMock())
+    mocker.patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True)
+    mocker.patch.multiple('freqtrade.main.exchange',
+                          validate_pairs=MagicMock(),
+                          get_ticker=ticker,
+                          get_wallet_health=health,
+                          buy=MagicMock(return_value='mocked_limit_buy'))
+    init(default_conf, create_engine('sqlite://'))
 
-def test_create_trade(conf, mocker):
-    mocker.patch.dict('freqtrade.main._CONF', conf)
-    buy_signal = mocker.patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True)
+    trades = Trade.query.filter(Trade.is_open.is_(True)).all()
+    assert len(trades) == 0
+
+    result = _process()
+    assert result is True
+
+    trades = Trade.query.filter(Trade.is_open.is_(True)).all()
+    assert len(trades) == 1
+    trade = trades[0]
+    assert trade is not None
+    assert trade.stake_amount == default_conf['stake_amount']
+    assert trade.is_open
+    assert trade.open_date is not None
+    assert trade.exchange == Exchanges.BITTREX.name
+    assert trade.open_rate == 0.072661
+    assert trade.amount == 0.6864067381401302
+
+
+def test_process_exchange_failures(default_conf, ticker, health, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    mocker.patch.multiple('freqtrade.main.telegram', init=MagicMock(), send_msg=MagicMock())
+    mocker.patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True)
+    sleep_mock = mocker.patch('time.sleep', side_effect=lambda _: None)
+    mocker.patch.multiple('freqtrade.main.exchange',
+                          validate_pairs=MagicMock(),
+                          get_ticker=ticker,
+                          get_wallet_health=health,
+                          buy=MagicMock(side_effect=requests.exceptions.RequestException))
+    init(default_conf, create_engine('sqlite://'))
+    result = _process()
+    assert result is False
+    assert sleep_mock.has_calls()
+
+
+def test_process_runtime_error(default_conf, ticker, health, mocker):
+    msg_mock = MagicMock()
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    mocker.patch.multiple('freqtrade.main.telegram', init=MagicMock(), send_msg=msg_mock)
+    mocker.patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True)
+    mocker.patch.multiple('freqtrade.main.exchange',
+                          validate_pairs=MagicMock(),
+                          get_ticker=ticker,
+                          get_wallet_health=health,
+                          buy=MagicMock(side_effect=RuntimeError))
+    init(default_conf, create_engine('sqlite://'))
+    assert get_state() == State.RUNNING
+
+    result = _process()
+    assert result is False
+    assert get_state() == State.STOPPED
+    assert 'RuntimeError' in msg_mock.call_args_list[-1][0][0]
+
+
+def test_process_trade_handling(default_conf, ticker, limit_buy_order, health, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    mocker.patch.multiple('freqtrade.main.telegram', init=MagicMock(), send_msg=MagicMock())
+    mocker.patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True)
+    mocker.patch.multiple('freqtrade.main.exchange',
+                          validate_pairs=MagicMock(),
+                          get_ticker=ticker,
+                          get_wallet_health=health,
+                          buy=MagicMock(return_value='mocked_limit_buy'),
+                          get_order=MagicMock(return_value=limit_buy_order))
+    init(default_conf, create_engine('sqlite://'))
+
+    trades = Trade.query.filter(Trade.is_open.is_(True)).all()
+    assert len(trades) == 0
+    result = _process()
+    assert result is True
+    trades = Trade.query.filter(Trade.is_open.is_(True)).all()
+    assert len(trades) == 1
+
+    result = _process()
+    assert result is False
+
+
+def test_create_trade(default_conf, ticker, limit_buy_order, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    mocker.patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True)
     mocker.patch.multiple('freqtrade.main.telegram', init=MagicMock(), send_msg=MagicMock())
     mocker.patch.multiple('freqtrade.main.exchange',
                           validate_pairs=MagicMock(),
-                          get_ticker=MagicMock(return_value={
-                              'bid': 0.07256061,
-                              'ask': 0.072661,
-                              'last': 0.07256061
-                          }),
-                          buy=MagicMock(return_value='mocked_order_id'))
+                          get_ticker=ticker,
+                          buy=MagicMock(return_value='mocked_limit_buy'))
     # Save state of current whitelist
-    whitelist = copy.deepcopy(conf['exchange']['pair_whitelist'])
+    whitelist = copy.deepcopy(default_conf['exchange']['pair_whitelist'])
 
-    init(conf, 'sqlite://')
-    for pair in ['BTC_ETH', 'BTC_TKN', 'BTC_TRST', 'BTC_SWT']:
-        trade = create_trade(15.0)
-        Trade.session.add(trade)
-        Trade.session.flush()
-        assert trade is not None
-        assert trade.open_rate == 0.072661
-        assert trade.pair == pair
-        assert trade.exchange == Exchanges.BITTREX.name
-        assert trade.amount == 206.43811673387373
-        assert trade.stake_amount == 15.0
-        assert trade.is_open
-        assert trade.open_date is not None
-        assert whitelist == conf['exchange']['pair_whitelist']
+    init(default_conf, create_engine('sqlite://'))
+    trade = create_trade(15.0)
+    Trade.session.add(trade)
+    Trade.session.flush()
+    assert trade is not None
+    assert trade.stake_amount == 15.0
+    assert trade.is_open
+    assert trade.open_date is not None
+    assert trade.exchange == Exchanges.BITTREX.name
 
-    buy_signal.assert_has_calls(
-        [call('BTC_ETH'), call('BTC_TKN'), call('BTC_TRST'), call('BTC_SWT')]
-    )
+    # Simulate fulfilled LIMIT_BUY order for trade
+    trade.update(limit_buy_order)
 
-def test_handle_trade(conf, mocker):
-    mocker.patch.dict('freqtrade.main._CONF', conf)
+    assert trade.open_rate == 0.07256061
+    assert trade.amount == 206.43811673387373
+
+    assert whitelist == default_conf['exchange']['pair_whitelist']
+
+
+def test_create_trade_no_stake_amount(default_conf, ticker, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    mocker.patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True)
+    mocker.patch.multiple('freqtrade.main.telegram', init=MagicMock(), send_msg=MagicMock())
+    mocker.patch.multiple('freqtrade.main.exchange',
+                          validate_pairs=MagicMock(),
+                          get_ticker=ticker,
+                          buy=MagicMock(return_value='mocked_limit_buy'),
+                          get_balance=MagicMock(return_value=default_conf['stake_amount'] * 0.5))
+    with pytest.raises(ValueError, match=r'.*stake amount.*'):
+        create_trade(default_conf['stake_amount'])
+
+
+def test_create_trade_no_pairs(default_conf, ticker, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    mocker.patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True)
+    mocker.patch.multiple('freqtrade.main.telegram', init=MagicMock(), send_msg=MagicMock())
+    mocker.patch.multiple('freqtrade.main.exchange',
+                          validate_pairs=MagicMock(),
+                          get_ticker=ticker,
+                          buy=MagicMock(return_value='mocked_limit_buy'))
+
+    with pytest.raises(ValueError, match=r'.*No pair in whitelist.*'):
+        conf = copy.deepcopy(default_conf)
+        conf['exchange']['pair_whitelist'] = []
+        mocker.patch.dict('freqtrade.main._CONF', conf)
+        create_trade(default_conf['stake_amount'])
+
+
+def test_handle_trade(default_conf, limit_buy_order, limit_sell_order, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    mocker.patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True)
     mocker.patch.multiple('freqtrade.main.telegram', init=MagicMock(), send_msg=MagicMock())
     mocker.patch.multiple('freqtrade.main.exchange',
                           validate_pairs=MagicMock(),
@@ -92,17 +170,45 @@ def test_handle_trade(conf, mocker):
                               'ask': 0.172661,
                               'last': 0.17256061
                           }),
-                          buy=MagicMock(return_value='mocked_order_id'))
+                          buy=MagicMock(return_value='mocked_limit_buy'),
+                          sell=MagicMock(return_value='mocked_limit_sell'))
+    init(default_conf, create_engine('sqlite://'))
+    trade = create_trade(15.0)
+    trade.update(limit_buy_order)
+    Trade.session.add(trade)
+    Trade.session.flush()
     trade = Trade.query.filter(Trade.is_open.is_(True)).first()
     assert trade
-    handle_trade(trade)
-    assert trade.close_rate == 0.17256061
-    assert trade.close_profit == 137.4872490056564
-    assert trade.close_date is not None
-    assert trade.open_order_id == 'dry_run'
 
-def test_close_trade(conf, mocker):
-    mocker.patch.dict('freqtrade.main._CONF', conf)
+    handle_trade(trade)
+    assert trade.open_order_id == 'mocked_limit_sell'
+    assert close_trade_if_fulfilled(trade) is False
+
+    # Simulate fulfilled LIMIT_SELL order for trade
+    trade.update(limit_sell_order)
+
+    assert trade.close_rate == 0.0802134
+    assert trade.close_profit == 0.10046755
+    assert trade.close_date is not None
+
+
+def test_close_trade(default_conf, ticker, limit_buy_order, limit_sell_order, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    mocker.patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True)
+    mocker.patch.multiple('freqtrade.main.telegram', init=MagicMock(), send_msg=MagicMock())
+    mocker.patch.multiple('freqtrade.main.exchange',
+                          validate_pairs=MagicMock(),
+                          get_ticker=ticker,
+                          buy=MagicMock(return_value='mocked_limit_buy'))
+
+    # Create trade and sell it
+    init(default_conf, create_engine('sqlite://'))
+    trade = create_trade(15.0)
+    trade.update(limit_buy_order)
+    trade.update(limit_sell_order)
+
+    Trade.session.add(trade)
+    Trade.session.flush()
     trade = Trade.query.filter(Trade.is_open.is_(True)).first()
     assert trade
 
@@ -112,15 +218,20 @@ def test_close_trade(conf, mocker):
     closed = close_trade_if_fulfilled(trade)
     assert closed
     assert not trade.is_open
+    with pytest.raises(ValueError, match=r'.*closed trade.*'):
+        handle_trade(trade)
+
 
 def test_balance_fully_ask_side(mocker):
     mocker.patch.dict('freqtrade.main._CONF', {'bid_strategy': {'ask_last_balance': 0.0}})
     assert get_target_bid({'ask': 20, 'last': 10}) == 20
 
+
 def test_balance_fully_last_side(mocker):
     mocker.patch.dict('freqtrade.main._CONF', {'bid_strategy': {'ask_last_balance': 1.0}})
     assert get_target_bid({'ask': 20, 'last': 10}) == 10
 
-def test_balance_when_last_bigger_than_ask(mocker):
+
+def test_balance_bigger_last_ask(mocker):
     mocker.patch.dict('freqtrade.main._CONF', {'bid_strategy': {'ask_last_balance': 1.0}})
     assert get_target_bid({'ask': 5, 'last': 10}) == 5

freqtrade/tests/test_misc.py

@@ -0,0 +1,20 @@
+# pragma pylint: disable=missing-docstring
+import time
+
+from freqtrade.misc import throttle
+
+
+def test_throttle():
+
+    def func():
+        return 42
+
+    start = time.time()
+    result = throttle(func, 0.1)
+    end = time.time()
+
+    assert result == 42
+    assert end - start > 0.1
+
+    result = throttle(func, -1)
+    assert result == 42

freqtrade/tests/test_persistence.py

@@ -1,20 +1,66 @@
 # pragma pylint: disable=missing-docstring
+import pytest
+
 from freqtrade.exchange import Exchanges
 from freqtrade.persistence import Trade
 
-def test_exec_sell_order(mocker):
-    api_mock = mocker.patch('freqtrade.main.exchange.sell', side_effect='mocked_order_id')
+
+def test_update(limit_buy_order, limit_sell_order):
     trade = Trade(
         pair='BTC_ETH',
         stake_amount=1.00,
-        open_rate=0.50,
-        amount=10.00,
+        fee=0.1,
         exchange=Exchanges.BITTREX,
-        open_order_id='mocked'
     )
-    profit = trade.exec_sell_order(1.00, 10.00)
-    api_mock.assert_called_once_with('BTC_ETH', 1.0, 10.0)
-    assert profit == 100.0
-    assert trade.close_rate == 1.0
-    assert trade.close_profit == profit
+    assert trade.open_order_id is None
+    assert trade.open_rate is None
+    assert trade.close_profit is None
+    assert trade.close_date is None
+
+    trade.open_order_id = 'something'
+    trade.update(limit_buy_order)
+    assert trade.open_order_id is None
+    assert trade.open_rate == 0.07256061
+    assert trade.close_profit is None
+    assert trade.close_date is None
+
+    trade.open_order_id = 'something'
+    trade.update(limit_sell_order)
+    assert trade.open_order_id is None
+    assert trade.open_rate == 0.07256061
+    assert trade.close_profit == 0.00546755
     assert trade.close_date is not None
+
+
+def test_update_open_order(limit_buy_order):
+    trade = Trade(
+        pair='BTC_ETH',
+        stake_amount=1.00,
+        fee=0.1,
+        exchange=Exchanges.BITTREX,
+    )
+
+    assert trade.open_order_id is None
+    assert trade.open_rate is None
+    assert trade.close_profit is None
+    assert trade.close_date is None
+
+    limit_buy_order['closed'] = False
+    trade.update(limit_buy_order)
+
+    assert trade.open_order_id is None
+    assert trade.open_rate is None
+    assert trade.close_profit is None
+    assert trade.close_date is None
+
+
+def test_update_invalid_order(limit_buy_order):
+    trade = Trade(
+        pair='BTC_ETH',
+        stake_amount=1.00,
+        fee=0.1,
+        exchange=Exchanges.BITTREX,
+    )
+    limit_buy_order['type'] = 'invalid'
+    with pytest.raises(ValueError, match=r'Unknown order type'):
+        trade.update(limit_buy_order)

freqtrade/tests/test_telegram.py

@@ -1,76 +1,106 @@
-# pragma pylint: disable=missing-docstring
+# pragma pylint: disable=missing-docstring, too-many-arguments, too-many-ancestors
+import re
 from datetime import datetime
+from random import randint
 from unittest.mock import MagicMock
 
 import pytest
-from jsonschema import validate
-from telegram import Bot, Update, Message, Chat
+from sqlalchemy import create_engine
+from telegram import Update, Message, Chat
+from telegram.error import NetworkError
 
+from freqtrade import __version__
 from freqtrade.main import init, create_trade
-from freqtrade.misc import update_state, State, get_state, CONF_SCHEMA
+from freqtrade.misc import update_state, State, get_state
 from freqtrade.persistence import Trade
-from freqtrade.rpc.telegram import _status, _profit, _forcesell, _performance, _start, _stop
+from freqtrade.rpc import telegram
+from freqtrade.rpc.telegram import (
+    _status, _status_table, _profit, _forcesell, _performance, _count, _start, _stop, _balance,
+    authorized_only, _help, is_enabled, send_msg,
+    _version)
 
 
-@pytest.fixture
-def conf():
-    configuration = {
-        "max_open_trades": 3,
-        "stake_currency": "BTC",
-        "stake_amount": 0.05,
-        "dry_run": True,
-        "minimal_roi": {
-            "2880": 0.005,
-            "720": 0.01,
-            "0": 0.02
-        },
-        "bid_strategy": {
-            "ask_last_balance": 0.0
-        },
-        "exchange": {
-            "name": "bittrex",
-            "enabled": True,
-            "key": "key",
-            "secret": "secret",
-            "pair_whitelist": [
-                "BTC_ETH"
-            ]
-        },
-        "telegram": {
-            "enabled": True,
-            "token": "token",
-            "chat_id": "0"
-        },
-        "initial_state": "running"
-    }
-    validate(configuration, CONF_SCHEMA)
-    return configuration
-
-@pytest.fixture
-def update():
-    _update = Update(0)
-    _update.message = Message(0, 0, datetime.utcnow(), Chat(0, 0))
-    return _update
+def test_is_enabled(default_conf, mocker):
+    mocker.patch.dict('freqtrade.rpc.telegram._CONF', default_conf)
+    default_conf['telegram']['enabled'] = False
+    assert is_enabled() is False
 
 
-class MagicBot(MagicMock, Bot):
-    pass
+def test_init_disabled(default_conf, mocker):
+    mocker.patch.dict('freqtrade.rpc.telegram._CONF', default_conf)
+    default_conf['telegram']['enabled'] = False
+    telegram.init(default_conf)
 
 
-def test_status_handle(conf, update, mocker):
-    mocker.patch.dict('freqtrade.main._CONF', conf)
+def test_authorized_only(default_conf, mocker):
+    mocker.patch.dict('freqtrade.rpc.telegram._CONF', default_conf)
+
+    chat = Chat(0, 0)
+    update = Update(randint(1, 100))
+    update.message = Message(randint(1, 100), 0, datetime.utcnow(), chat)
+    state = {'called': False}
+
+    @authorized_only
+    def dummy_handler(*args, **kwargs) -> None:
+        state['called'] = True
+
+    dummy_handler(MagicMock(), update)
+    assert state['called'] is True
+
+
+def test_authorized_only_unauthorized(default_conf, mocker):
+    mocker.patch.dict('freqtrade.rpc.telegram._CONF', default_conf)
+
+    chat = Chat(0xdeadbeef, 0)
+    update = Update(randint(1, 100))
+    update.message = Message(randint(1, 100), 0, datetime.utcnow(), chat)
+    state = {'called': False}
+
+    @authorized_only
+    def dummy_handler(*args, **kwargs) -> None:
+        state['called'] = True
+
+    dummy_handler(MagicMock(), update)
+    assert state['called'] is False
+
+
+def test_authorized_only_exception(default_conf, mocker):
+    mocker.patch.dict('freqtrade.rpc.telegram._CONF', default_conf)
+
+    update = Update(randint(1, 100))
+    update.message = Message(randint(1, 100), 0, datetime.utcnow(), Chat(0, 0))
+
+    @authorized_only
+    def dummy_handler(*args, **kwargs) -> None:
+        raise Exception('test')
+
+    dummy_handler(MagicMock(), update)
+
+
+def test_status_handle(default_conf, update, ticker, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
     mocker.patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True)
     msg_mock = MagicMock()
-    mocker.patch.multiple('freqtrade.main.telegram', _CONF=conf, init=MagicMock(), send_msg=msg_mock)
+    mocker.patch.multiple('freqtrade.main.telegram',
+                          _CONF=default_conf,
+                          init=MagicMock(),
+                          send_msg=msg_mock)
     mocker.patch.multiple('freqtrade.main.exchange',
                           validate_pairs=MagicMock(),
-                          get_ticker=MagicMock(return_value={
-                              'bid': 0.07256061,
-                              'ask': 0.072661,
-                              'last': 0.07256061
-                          }),
-                          buy=MagicMock(return_value='mocked_order_id'))
-    init(conf, 'sqlite://')
+                          get_ticker=ticker)
+    init(default_conf, create_engine('sqlite://'))
+
+    update_state(State.STOPPED)
+    _status(bot=MagicMock(), update=update)
+    assert msg_mock.call_count == 1
+    assert 'trader is not running' in msg_mock.call_args_list[0][0][0]
+    msg_mock.reset_mock()
+
+    update_state(State.RUNNING)
+    _status(bot=MagicMock(), update=update)
+    assert msg_mock.call_count == 1
+    assert 'no active trade' in msg_mock.call_args_list[0][0][0]
+    msg_mock.reset_mock()
 
     # Create some test data
     trade = create_trade(15.0)
@@ -78,122 +108,435 @@ def test_status_handle(conf, update, mocker):
     Trade.session.add(trade)
     Trade.session.flush()
 
-    _status(bot=MagicBot(), update=update)
+    # Trigger status while we have a fulfilled order for the open trade
+    _status(bot=MagicMock(), update=update)
+
     assert msg_mock.call_count == 2
     assert '[BTC_ETH]' in msg_mock.call_args_list[-1][0][0]
 
-def test_profit_handle(conf, update, mocker):
-    mocker.patch.dict('freqtrade.main._CONF', conf)
+
+def test_status_table_handle(default_conf, update, ticker, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
     mocker.patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True)
     msg_mock = MagicMock()
-    mocker.patch.multiple('freqtrade.main.telegram', _CONF=conf, init=MagicMock(), send_msg=msg_mock)
+    mocker.patch.multiple(
+        'freqtrade.main.telegram',
+        _CONF=default_conf,
+        init=MagicMock(),
+        send_msg=msg_mock)
     mocker.patch.multiple('freqtrade.main.exchange',
                           validate_pairs=MagicMock(),
-                          get_ticker=MagicMock(return_value={
-                              'bid': 0.07256061,
-                              'ask': 0.072661,
-                              'last': 0.07256061
-                          }),
+                          get_ticker=ticker,
                           buy=MagicMock(return_value='mocked_order_id'))
-    init(conf, 'sqlite://')
+    init(default_conf, create_engine('sqlite://'))
+    update_state(State.STOPPED)
+    _status_table(bot=MagicMock(), update=update)
+    assert msg_mock.call_count == 1
+    assert 'trader is not running' in msg_mock.call_args_list[0][0][0]
+    msg_mock.reset_mock()
+
+    update_state(State.RUNNING)
+    _status_table(bot=MagicMock(), update=update)
+    assert msg_mock.call_count == 1
+    assert 'no active order' in msg_mock.call_args_list[0][0][0]
+    msg_mock.reset_mock()
 
     # Create some test data
     trade = create_trade(15.0)
     assert trade
-    trade.close_rate = 0.07256061
-    trade.close_profit = 100.00
+    Trade.session.add(trade)
+    Trade.session.flush()
+
+    _status_table(bot=MagicMock(), update=update)
+
+    text = re.sub('</?pre>', '', msg_mock.call_args_list[-1][0][0])
+    line = text.split("\n")
+    fields = re.sub('[ ]+', ' ', line[2].strip()).split(' ')
+
+    assert int(fields[0]) == 1
+    assert fields[1] == 'BTC_ETH'
+    assert msg_mock.call_count == 2
+
+
+def test_profit_handle(default_conf, update, ticker, limit_buy_order, limit_sell_order, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    mocker.patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True)
+    msg_mock = MagicMock()
+    mocker.patch.multiple('freqtrade.main.telegram',
+                          _CONF=default_conf,
+                          init=MagicMock(),
+                          send_msg=msg_mock)
+    mocker.patch.multiple('freqtrade.main.exchange',
+                          validate_pairs=MagicMock(),
+                          get_ticker=ticker)
+    init(default_conf, create_engine('sqlite://'))
+
+    _profit(bot=MagicMock(), update=update)
+    assert msg_mock.call_count == 1
+    assert 'no closed trade' in msg_mock.call_args_list[0][0][0]
+    msg_mock.reset_mock()
+
+    # Create some test data
+    trade = create_trade(15.0)
+    assert trade
+
+    # Simulate fulfilled LIMIT_BUY order for trade
+    trade.update(limit_buy_order)
+
+    _profit(bot=MagicMock(), update=update)
+    assert msg_mock.call_count == 2
+    assert 'no closed trade' in msg_mock.call_args_list[-1][0][0]
+    msg_mock.reset_mock()
+
+    # Simulate fulfilled LIMIT_SELL order for trade
+    trade.update(limit_sell_order)
+
     trade.close_date = datetime.utcnow()
-    trade.open_order_id = None
     trade.is_open = False
     Trade.session.add(trade)
     Trade.session.flush()
 
-    _profit(bot=MagicBot(), update=update)
-    assert msg_mock.call_count == 2
-    assert '(100.00%)' in msg_mock.call_args_list[-1][0][0]
+    _profit(bot=MagicMock(), update=update)
+    assert msg_mock.call_count == 1
+    assert '*ROI:* `1.50701325 (10.05%)`' in msg_mock.call_args_list[-1][0][0]
+    assert 'Best Performing:* `BTC_ETH: 10.05%`' in msg_mock.call_args_list[-1][0][0]
 
-def test_forcesell_handle(conf, update, mocker):
-    mocker.patch.dict('freqtrade.main._CONF', conf)
+
+def test_forcesell_handle(default_conf, update, ticker, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
     mocker.patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True)
     msg_mock = MagicMock()
-    mocker.patch.multiple('freqtrade.main.telegram', _CONF=conf, init=MagicMock(), send_msg=msg_mock)
+    mocker.patch.multiple('freqtrade.main.telegram',
+                          _CONF=default_conf,
+                          init=MagicMock(),
+                          send_msg=msg_mock)
     mocker.patch.multiple('freqtrade.main.exchange',
                           validate_pairs=MagicMock(),
-                          get_ticker=MagicMock(return_value={
-                              'bid': 0.07256061,
-                              'ask': 0.072661,
-                              'last': 0.07256061
-                          }),
-                          buy=MagicMock(return_value='mocked_order_id'))
-    init(conf, 'sqlite://')
+                          get_ticker=ticker)
+    init(default_conf, create_engine('sqlite://'))
 
     # Create some test data
     trade = create_trade(15.0)
     assert trade
+
     Trade.session.add(trade)
     Trade.session.flush()
 
     update.message.text = '/forcesell 1'
-    _forcesell(bot=MagicBot(), update=update)
+    _forcesell(bot=MagicMock(), update=update)
 
     assert msg_mock.call_count == 2
     assert 'Selling [BTC/ETH]' in msg_mock.call_args_list[-1][0][0]
-    assert '0.072561' in msg_mock.call_args_list[-1][0][0]
+    assert '0.07256061 (profit: ~-0.64%)' in msg_mock.call_args_list[-1][0][0]
 
-def test_performance_handle(conf, update, mocker):
-    mocker.patch.dict('freqtrade.main._CONF', conf)
+
+def test_forcesell_all_handle(default_conf, update, ticker, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
     mocker.patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True)
     msg_mock = MagicMock()
-    mocker.patch.multiple('freqtrade.main.telegram', _CONF=conf, init=MagicMock(), send_msg=msg_mock)
+    mocker.patch.multiple('freqtrade.main.telegram',
+                          _CONF=default_conf,
+                          init=MagicMock(),
+                          send_msg=msg_mock)
     mocker.patch.multiple('freqtrade.main.exchange',
                           validate_pairs=MagicMock(),
-                          get_ticker=MagicMock(return_value={
-                              'bid': 0.07256061,
-                              'ask': 0.072661,
-                              'last': 0.07256061
-                          }),
-                          buy=MagicMock(return_value='mocked_order_id'))
-    init(conf, 'sqlite://')
+                          get_ticker=ticker)
+    init(default_conf, create_engine('sqlite://'))
+
+    # Create some test data
+    for _ in range(4):
+        Trade.session.add(create_trade(15.0))
+    Trade.session.flush()
+
+    msg_mock.reset_mock()
+
+    update.message.text = '/forcesell all'
+    _forcesell(bot=MagicMock(), update=update)
+
+    assert msg_mock.call_count == 4
+    for args in msg_mock.call_args_list:
+        assert '0.07256061 (profit: ~-0.64%)' in args[0][0]
+
+
+def test_forcesell_handle_invalid(default_conf, update, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    mocker.patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True)
+    msg_mock = MagicMock()
+    mocker.patch.multiple('freqtrade.main.telegram',
+                          _CONF=default_conf,
+                          init=MagicMock(),
+                          send_msg=msg_mock)
+    mocker.patch.multiple('freqtrade.main.exchange',
+                          validate_pairs=MagicMock())
+    init(default_conf, create_engine('sqlite://'))
+
+    # Trader is not running
+    update_state(State.STOPPED)
+    update.message.text = '/forcesell 1'
+    _forcesell(bot=MagicMock(), update=update)
+    assert msg_mock.call_count == 1
+    assert 'not running' in msg_mock.call_args_list[0][0][0]
+
+    # No argument
+    msg_mock.reset_mock()
+    update_state(State.RUNNING)
+    update.message.text = '/forcesell'
+    _forcesell(bot=MagicMock(), update=update)
+    assert msg_mock.call_count == 1
+    assert 'Invalid argument' in msg_mock.call_args_list[0][0][0]
+
+    # Invalid argument
+    msg_mock.reset_mock()
+    update_state(State.RUNNING)
+    update.message.text = '/forcesell 123456'
+    _forcesell(bot=MagicMock(), update=update)
+    assert msg_mock.call_count == 1
+    assert 'Invalid argument.' in msg_mock.call_args_list[0][0][0]
+
+
+def test_performance_handle(
+        default_conf, update, ticker, limit_buy_order, limit_sell_order, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    mocker.patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True)
+    msg_mock = MagicMock()
+    mocker.patch.multiple('freqtrade.main.telegram',
+                          _CONF=default_conf,
+                          init=MagicMock(),
+                          send_msg=msg_mock)
+    mocker.patch.multiple('freqtrade.main.exchange',
+                          validate_pairs=MagicMock(),
+                          get_ticker=ticker)
+    init(default_conf, create_engine('sqlite://'))
 
     # Create some test data
     trade = create_trade(15.0)
     assert trade
-    trade.close_rate = 0.07256061
-    trade.close_profit = 100.00
+
+    # Simulate fulfilled LIMIT_BUY order for trade
+    trade.update(limit_buy_order)
+
+    # Simulate fulfilled LIMIT_SELL order for trade
+    trade.update(limit_sell_order)
+
     trade.close_date = datetime.utcnow()
-    trade.open_order_id = None
     trade.is_open = False
     Trade.session.add(trade)
     Trade.session.flush()
 
-    _performance(bot=MagicBot(), update=update)
+    _performance(bot=MagicMock(), update=update)
     assert msg_mock.call_count == 2
     assert 'Performance' in msg_mock.call_args_list[-1][0][0]
-    assert 'BTC_ETH	100.00%' in msg_mock.call_args_list[-1][0][0]
+    assert '<code>BTC_ETH\t10.05%</code>' in msg_mock.call_args_list[-1][0][0]
 
-def test_start_handle(conf, update, mocker):
-    mocker.patch.dict('freqtrade.main._CONF', conf)
+
+def test_count_handle(default_conf, update, ticker, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    mocker.patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True)
     msg_mock = MagicMock()
-    mocker.patch.multiple('freqtrade.main.telegram', _CONF=conf, init=MagicMock(), send_msg=msg_mock)
-    mocker.patch.multiple('freqtrade.main.exchange', _CONF=conf, init=MagicMock())
-    init(conf, 'sqlite://')
+    mocker.patch.multiple(
+        'freqtrade.main.telegram',
+        _CONF=default_conf,
+        init=MagicMock(),
+        send_msg=msg_mock)
+    mocker.patch.multiple('freqtrade.main.exchange',
+                          validate_pairs=MagicMock(),
+                          get_ticker=ticker,
+                          buy=MagicMock(return_value='mocked_order_id'))
+    init(default_conf, create_engine('sqlite://'))
+    update_state(State.STOPPED)
+    _count(bot=MagicMock(), update=update)
+    assert msg_mock.call_count == 1
+    assert 'not running' in msg_mock.call_args_list[0][0][0]
+    msg_mock.reset_mock()
+    update_state(State.RUNNING)
 
+    # Create some test data
+    Trade.session.add(create_trade(15.0))
+    Trade.session.flush()
+
+    msg_mock.reset_mock()
+    _count(bot=MagicMock(), update=update)
+
+    msg = '<pre>  current    max\n---------  -----\n        1      {}</pre>'.format(
+        default_conf['max_open_trades']
+    )
+    assert msg in msg_mock.call_args_list[0][0][0]
+
+
+def test_performance_handle_invalid(default_conf, update, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    mocker.patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True)
+    msg_mock = MagicMock()
+    mocker.patch.multiple('freqtrade.main.telegram',
+                          _CONF=default_conf,
+                          init=MagicMock(),
+                          send_msg=msg_mock)
+    mocker.patch.multiple('freqtrade.main.exchange',
+                          validate_pairs=MagicMock())
+    init(default_conf, create_engine('sqlite://'))
+
+    # Trader is not running
+    update_state(State.STOPPED)
+    _performance(bot=MagicMock(), update=update)
+    assert msg_mock.call_count == 1
+    assert 'not running' in msg_mock.call_args_list[0][0][0]
+
+
+def test_start_handle(default_conf, update, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    msg_mock = MagicMock()
+    mocker.patch.multiple('freqtrade.main.telegram',
+                          _CONF=default_conf,
+                          init=MagicMock(),
+                          send_msg=msg_mock)
+    mocker.patch.multiple('freqtrade.main.exchange',
+                          _CONF=default_conf,
+                          init=MagicMock())
+    init(default_conf, create_engine('sqlite://'))
     update_state(State.STOPPED)
     assert get_state() == State.STOPPED
-    _start(bot=MagicBot(), update=update)
+    _start(bot=MagicMock(), update=update)
     assert get_state() == State.RUNNING
     assert msg_mock.call_count == 0
 
-def test_stop_handle(conf, update, mocker):
-    mocker.patch.dict('freqtrade.main._CONF', conf)
-    msg_mock = MagicMock()
-    mocker.patch.multiple('freqtrade.main.telegram', _CONF=conf, init=MagicMock(), send_msg=msg_mock)
-    mocker.patch.multiple('freqtrade.main.exchange', _CONF=conf, init=MagicMock())
-    init(conf, 'sqlite://')
 
+def test_start_handle_already_running(default_conf, update, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    msg_mock = MagicMock()
+    mocker.patch.multiple('freqtrade.main.telegram',
+                          _CONF=default_conf,
+                          init=MagicMock(),
+                          send_msg=msg_mock)
+    mocker.patch.multiple('freqtrade.main.exchange',
+                          _CONF=default_conf,
+                          init=MagicMock())
+    init(default_conf, create_engine('sqlite://'))
     update_state(State.RUNNING)
     assert get_state() == State.RUNNING
-    _stop(bot=MagicBot(), update=update)
+    _start(bot=MagicMock(), update=update)
+    assert get_state() == State.RUNNING
+    assert msg_mock.call_count == 1
+    assert 'already running' in msg_mock.call_args_list[0][0][0]
+
+
+def test_stop_handle(default_conf, update, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    msg_mock = MagicMock()
+    mocker.patch.multiple('freqtrade.main.telegram',
+                          _CONF=default_conf,
+                          init=MagicMock(),
+                          send_msg=msg_mock)
+    mocker.patch.multiple('freqtrade.main.exchange',
+                          _CONF=default_conf,
+                          init=MagicMock())
+    init(default_conf, create_engine('sqlite://'))
+    update_state(State.RUNNING)
+    assert get_state() == State.RUNNING
+    _stop(bot=MagicMock(), update=update)
     assert get_state() == State.STOPPED
     assert msg_mock.call_count == 1
     assert 'Stopping trader' in msg_mock.call_args_list[0][0][0]
+
+
+def test_stop_handle_already_stopped(default_conf, update, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    msg_mock = MagicMock()
+    mocker.patch.multiple('freqtrade.main.telegram',
+                          _CONF=default_conf,
+                          init=MagicMock(),
+                          send_msg=msg_mock)
+    mocker.patch.multiple('freqtrade.main.exchange',
+                          _CONF=default_conf,
+                          init=MagicMock())
+    init(default_conf, create_engine('sqlite://'))
+    update_state(State.STOPPED)
+    assert get_state() == State.STOPPED
+    _stop(bot=MagicMock(), update=update)
+    assert get_state() == State.STOPPED
+    assert msg_mock.call_count == 1
+    assert 'already stopped' in msg_mock.call_args_list[0][0][0]
+
+
+def test_balance_handle(default_conf, update, mocker):
+    mock_balance = [{
+        'Currency': 'BTC',
+        'Balance': 10.0,
+        'Available': 12.0,
+        'Pending': 0.0,
+        'CryptoAddress': 'XXXX',
+    }, {
+        'Currency': 'ETH',
+        'Balance': 0.0,
+        'Available': 0.0,
+        'Pending': 0.0,
+        'CryptoAddress': 'XXXX',
+    }]
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    msg_mock = MagicMock()
+    mocker.patch.multiple('freqtrade.main.telegram',
+                          _CONF=default_conf,
+                          init=MagicMock(),
+                          send_msg=msg_mock)
+    mocker.patch.multiple('freqtrade.main.exchange',
+                          get_balances=MagicMock(return_value=mock_balance))
+
+    _balance(bot=MagicMock(), update=update)
+    assert msg_mock.call_count == 1
+    assert '*Currency*: BTC' in msg_mock.call_args_list[0][0][0]
+    assert 'Balance' in msg_mock.call_args_list[0][0][0]
+
+
+def test_help_handle(default_conf, update, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    msg_mock = MagicMock()
+    mocker.patch.multiple('freqtrade.main.telegram',
+                          _CONF=default_conf,
+                          init=MagicMock(),
+                          send_msg=msg_mock)
+
+    _help(bot=MagicMock(), update=update)
+    assert msg_mock.call_count == 1
+    assert '*/help:* `This help message`' in msg_mock.call_args_list[0][0][0]
+
+
+def test_version_handle(default_conf, update, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    msg_mock = MagicMock()
+    mocker.patch.multiple('freqtrade.main.telegram',
+                          _CONF=default_conf,
+                          init=MagicMock(),
+                          send_msg=msg_mock)
+
+    _version(bot=MagicMock(), update=update)
+    assert msg_mock.call_count == 1
+    assert '*Version:* `{}`'.format(__version__) in msg_mock.call_args_list[0][0][0]
+
+
+def test_send_msg(default_conf, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    mocker.patch.multiple('freqtrade.main.telegram',
+                          _CONF=default_conf,
+                          init=MagicMock())
+    bot = MagicMock()
+    send_msg('test', bot)
+    assert len(bot.method_calls) == 0
+    bot.reset_mock()
+
+    default_conf['telegram']['enabled'] = True
+    send_msg('test', bot)
+    assert len(bot.method_calls) == 1
+
+
+def test_send_msg_network_error(default_conf, mocker):
+    mocker.patch.dict('freqtrade.main._CONF', default_conf)
+    mocker.patch.multiple('freqtrade.main.telegram',
+                          _CONF=default_conf,
+                          init=MagicMock())
+    default_conf['telegram']['enabled'] = True
+    bot = MagicMock()
+    bot.send_message = MagicMock(side_effect=NetworkError('Oh snap'))
+    with pytest.raises(NetworkError, match=r'Oh snap'):
+        send_msg('test', bot)
+
+    # Bot should've tried to send it twice
+    assert len(bot.method_calls) == 2

freqtrade/tests/testdata/download_backtest_data.py

@@ -1,16 +1,24 @@
 #!/usr/bin/env python3
 
 """This script generate json data from bittrex"""
+import json
+from os import path
 
-from urllib.request import urlopen
+from freqtrade import exchange
+from freqtrade.exchange import Bittrex
 
-CURRENCIES = ["ok", "neo", "dash", "etc", "eth", "snt"]
+PAIRS = ['BTC-OK', 'BTC-NEO', 'BTC-DASH', 'BTC-ETC', 'BTC-ETH', 'BTC-SNT']
+TICKER_INTERVAL = 1  # ticker interval in minutes (currently implemented: 1 and 5)
+OUTPUT_DIR = path.dirname(path.realpath(__file__))
 
-for cur in CURRENCIES:
-    url1 = 'https://bittrex.com/Api/v2.0/pub/market/GetTicks?marketName=BTC-'
-    url = url1+cur+'&tickInterval=fiveMin'
-    x = urlopen(url)
-    json_data = x.read()
-    json_str = str(json_data, 'utf-8')
-    with open('btc-'+cur+'.json', 'w') as file:
-        file.write(json_str)
+# Init Bittrex exchange
+exchange._API = Bittrex({'key': '', 'secret': ''})
+
+for pair in PAIRS:
+    data = exchange.get_ticker_history(pair, TICKER_INTERVAL)
+    filename = path.join(OUTPUT_DIR, '{}-{}m.json'.format(
+        pair.lower(),
+        TICKER_INTERVAL,
+    ))
+    with open(filename, 'w') as fp:
+        json.dump(data, fp)

freqtrade/vendor/qtpylib/indicators.py

@@ -0,0 +1,625 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# QTPyLib: Quantitative Trading Python Library
+# https://github.com/ranaroussi/qtpylib
+#
+# Copyright 2016 Ran Aroussi
+#
+# Licensed under the GNU Lesser General Public License, v3.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.gnu.org/licenses/lgpl-3.0.en.html
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+import numpy as np
+import pandas as pd
+import warnings
+import sys
+
+from datetime import datetime, timedelta
+from pandas.core.base import PandasObject
+
+# =============================================
+# check min, python version
+if sys.version_info < (3, 4):
+    raise SystemError("QTPyLib requires Python version >= 3.4")
+
+# =============================================
+warnings.simplefilter(action="ignore", category=RuntimeWarning)
+
+# =============================================
+
+
+def numpy_rolling_window(data, window):
+    shape = data.shape[:-1] + (data.shape[-1] - window + 1, window)
+    strides = data.strides + (data.strides[-1],)
+    return np.lib.stride_tricks.as_strided(data, shape=shape, strides=strides)
+
+
+def numpy_rolling_series(func):
+    def func_wrapper(data, window, as_source=False):
+        series = data.values if isinstance(data, pd.Series) else data
+
+        new_series = np.empty(len(series)) * np.nan
+        calculated = func(series, window)
+        new_series[-len(calculated):] = calculated
+
+        if as_source and isinstance(data, pd.Series):
+            return pd.Series(index=data.index, data=new_series)
+
+        return new_series
+
+    return func_wrapper
+
+
+@numpy_rolling_series
+def numpy_rolling_mean(data, window, as_source=False):
+    return np.mean(numpy_rolling_window(data, window), -1)
+
+
+@numpy_rolling_series
+def numpy_rolling_std(data, window, as_source=False):
+    return np.std(numpy_rolling_window(data, window), -1)
+
+# ---------------------------------------------
+
+
+def session(df, start='17:00', end='16:00'):
+    """ remove previous globex day from df """
+    if len(df) == 0:
+        return df
+
+    # get start/end/now as decimals
+    int_start = list(map(int, start.split(':')))
+    int_start = (int_start[0] + int_start[1] - 1 / 100) - 0.0001
+    int_end = list(map(int, end.split(':')))
+    int_end = int_end[0] + int_end[1] / 100
+    int_now = (df[-1:].index.hour[0] + (df[:1].index.minute[0]) / 100)
+
+    # same-dat session?
+    is_same_day = int_end > int_start
+
+    # set pointers
+    curr = prev = df[-1:].index[0].strftime('%Y-%m-%d')
+
+    # globex/forex session
+    if not is_same_day:
+        prev = (datetime.strptime(curr, '%Y-%m-%d') -
+                timedelta(1)).strftime('%Y-%m-%d')
+
+    # slice
+    if int_now >= int_start:
+        df = df[df.index >= curr + ' ' + start]
+    else:
+        df = df[df.index >= prev + ' ' + start]
+
+    return df.copy()
+
+
+# ---------------------------------------------
+
+def heikinashi(bars):
+    bars = bars.copy()
+    bars['ha_close'] = (bars['open'] + bars['high'] +
+                        bars['low'] + bars['close']) / 4
+    bars['ha_open'] = (bars['open'].shift(1) + bars['close'].shift(1)) / 2
+    bars.loc[:1, 'ha_open'] = bars['open'].values[0]
+    bars.loc[1:, 'ha_open'] = (
+        (bars['ha_open'].shift(1) + bars['ha_close'].shift(1)) / 2)[1:]
+    bars['ha_high'] = bars.loc[:, ['high', 'ha_open', 'ha_close']].max(axis=1)
+    bars['ha_low'] = bars.loc[:, ['low', 'ha_open', 'ha_close']].min(axis=1)
+
+    return pd.DataFrame(
+        index=bars.index,
+        data={
+            'open': bars['ha_open'],
+            'high': bars['ha_high'],
+            'low': bars['ha_low'],
+            'close': bars['ha_close']})
+
+
+# ---------------------------------------------
+
+def tdi(series, rsi_len=13, bollinger_len=34, rsi_smoothing=2,
+        rsi_signal_len=7, bollinger_std=1.6185):
+    rsi_series = rsi(series, rsi_len)
+    bb_series = bollinger_bands(rsi_series, bollinger_len, bollinger_std)
+    signal = sma(rsi_series, rsi_signal_len)
+    rsi_series = sma(rsi_series, rsi_smoothing)
+
+    return pd.DataFrame(index=series.index, data={
+        "rsi": rsi_series,
+        "signal": signal,
+        "bbupper": bb_series['upper'],
+        "bblower": bb_series['lower'],
+        "bbmid": bb_series['mid']
+    })
+
+# ---------------------------------------------
+
+
+def awesome_oscillator(df, weighted=False, fast=5, slow=34):
+    midprice = (df['high'] + df['low']) / 2
+
+    if weighted:
+        ao = (midprice.ewm(fast).mean() - midprice.ewm(slow).mean()).values
+    else:
+        ao = numpy_rolling_mean(midprice, fast) - \
+            numpy_rolling_mean(midprice, slow)
+
+    return pd.Series(index=df.index, data=ao)
+
+
+# ---------------------------------------------
+
+def nans(len=1):
+    mtx = np.empty(len)
+    mtx[:] = np.nan
+    return mtx
+
+
+# ---------------------------------------------
+
+def typical_price(bars):
+    res = (bars['high'] + bars['low'] + bars['close']) / 3.
+    return pd.Series(index=bars.index, data=res)
+
+
+# ---------------------------------------------
+
+def mid_price(bars):
+    res = (bars['high'] + bars['low']) / 2.
+    return pd.Series(index=bars.index, data=res)
+
+
+# ---------------------------------------------
+
+def ibs(bars):
+    """ Internal bar strength """
+    res = np.round((bars['close'] - bars['low']) /
+                   (bars['high'] - bars['low']), 2)
+    return pd.Series(index=bars.index, data=res)
+
+
+# ---------------------------------------------
+
+def true_range(bars):
+    return pd.DataFrame({
+        "hl": bars['high'] - bars['low'],
+        "hc": abs(bars['high'] - bars['close'].shift(1)),
+        "lc": abs(bars['low'] - bars['close'].shift(1))
+    }).max(axis=1)
+
+
+# ---------------------------------------------
+
+def atr(bars, window=14, exp=False):
+    tr = true_range(bars)
+
+    if exp:
+        res = rolling_weighted_mean(tr, window)
+    else:
+        res = rolling_mean(tr, window)
+
+    res = pd.Series(res)
+    return (res.shift(1) * (window - 1) + res) / window
+
+
+# ---------------------------------------------
+
+def crossed(series1, series2, direction=None):
+    if isinstance(series1, np.ndarray):
+        series1 = pd.Series(series1)
+
+    if isinstance(series2, int) or isinstance(series2, float) or isinstance(series2, np.ndarray):
+        series2 = pd.Series(index=series1.index, data=series2)
+
+    if direction is None or direction == "above":
+        above = pd.Series((series1 > series2) & (
+            series1.shift(1) <= series2.shift(1)))
+
+    if direction is None or direction == "below":
+        below = pd.Series((series1 < series2) & (
+            series1.shift(1) >= series2.shift(1)))
+
+    if direction is None:
+        return above or below
+
+    return above if direction is "above" else below
+
+
+def crossed_above(series1, series2):
+    return crossed(series1, series2, "above")
+
+
+def crossed_below(series1, series2):
+    return crossed(series1, series2, "below")
+
+# ---------------------------------------------
+
+
+def rolling_std(series, window=200, min_periods=None):
+    min_periods = window if min_periods is None else min_periods
+    try:
+        if min_periods == window:
+            return numpy_rolling_std(series, window, True)
+        else:
+            try:
+                return series.rolling(window=window, min_periods=min_periods).std()
+            except BaseException:
+                return pd.Series(series).rolling(window=window, min_periods=min_periods).std()
+    except BaseException:
+        return pd.rolling_std(series, window=window, min_periods=min_periods)
+
+
+# ---------------------------------------------
+
+def rolling_mean(series, window=200, min_periods=None):
+    min_periods = window if min_periods is None else min_periods
+    try:
+        if min_periods == window:
+            return numpy_rolling_mean(series, window, True)
+        else:
+            try:
+                return series.rolling(window=window, min_periods=min_periods).mean()
+            except BaseException:
+                return pd.Series(series).rolling(window=window, min_periods=min_periods).mean()
+    except BaseException:
+        return pd.rolling_mean(series, window=window, min_periods=min_periods)
+
+
+# ---------------------------------------------
+
+def rolling_min(series, window=14, min_periods=None):
+    min_periods = window if min_periods is None else min_periods
+    try:
+        try:
+            return series.rolling(window=window, min_periods=min_periods).min()
+        except BaseException:
+            return pd.Series(series).rolling(window=window, min_periods=min_periods).min()
+    except BaseException:
+        return pd.rolling_min(series, window=window, min_periods=min_periods)
+
+
+# ---------------------------------------------
+
+def rolling_max(series, window=14, min_periods=None):
+    min_periods = window if min_periods is None else min_periods
+    try:
+        try:
+            return series.rolling(window=window, min_periods=min_periods).min()
+        except BaseException:
+            return pd.Series(series).rolling(window=window, min_periods=min_periods).min()
+    except BaseException:
+        return pd.rolling_min(series, window=window, min_periods=min_periods)
+
+
+# ---------------------------------------------
+
+def rolling_weighted_mean(series, window=200, min_periods=None):
+    min_periods = window if min_periods is None else min_periods
+    try:
+        return series.ewm(span=window, min_periods=min_periods).mean()
+    except BaseException:
+        return pd.ewma(series, span=window, min_periods=min_periods)
+
+
+# ---------------------------------------------
+
+def hull_moving_average(series, window=200):
+    wma = (2 * rolling_weighted_mean(series, window=window / 2)) - \
+        rolling_weighted_mean(series, window=window)
+    return rolling_weighted_mean(wma, window=np.sqrt(window))
+
+
+# ---------------------------------------------
+
+def sma(series, window=200, min_periods=None):
+    return rolling_mean(series, window=window, min_periods=min_periods)
+
+
+# ---------------------------------------------
+
+def wma(series, window=200, min_periods=None):
+    return rolling_weighted_mean(series, window=window, min_periods=min_periods)
+
+
+# ---------------------------------------------
+
+def hma(series, window=200):
+    return hull_moving_average(series, window=window)
+
+
+# ---------------------------------------------
+
+def vwap(bars):
+    """
+    calculate vwap of entire time series
+    (input can be pandas series or numpy array)
+    bars are usually mid [ (h+l)/2 ] or typical [ (h+l+c)/3 ]
+    """
+    typical = ((bars['high'] + bars['low'] + bars['close']) / 3).values
+    volume = bars['volume'].values
+
+    return pd.Series(index=bars.index,
+                     data=np.cumsum(volume * typical) / np.cumsum(volume))
+
+
+# ---------------------------------------------
+
+def rolling_vwap(bars, window=200, min_periods=None):
+    """
+    calculate vwap using moving window
+    (input can be pandas series or numpy array)
+    bars are usually mid [ (h+l)/2 ] or typical [ (h+l+c)/3 ]
+    """
+    min_periods = window if min_periods is None else min_periods
+
+    typical = ((bars['high'] + bars['low'] + bars['close']) / 3)
+    volume = bars['volume']
+
+    left = (volume * typical).rolling(window=window,
+                                      min_periods=min_periods).sum()
+    right = volume.rolling(window=window, min_periods=min_periods).sum()
+
+    return pd.Series(index=bars.index, data=(left / right))
+
+
+# ---------------------------------------------
+
+def rsi(series, window=14):
+    """
+    compute the n period relative strength indicator
+    """
+    # 100-(100/relative_strength)
+    deltas = np.diff(series)
+    seed = deltas[:window + 1]
+
+    # default values
+    ups = seed[seed > 0].sum() / window
+    downs = -seed[seed < 0].sum() / window
+    rsival = np.zeros_like(series)
+    rsival[:window] = 100. - 100. / (1. + ups / downs)
+
+    # period values
+    for i in range(window, len(series)):
+        delta = deltas[i - 1]
+        if delta > 0:
+            upval = delta
+            downval = 0
+        else:
+            upval = 0
+            downval = -delta
+
+        ups = (ups * (window - 1) + upval) / window
+        downs = (downs * (window - 1.) + downval) / window
+        rsival[i] = 100. - 100. / (1. + ups / downs)
+
+    # return rsival
+    return pd.Series(index=series.index, data=rsival)
+
+
+# ---------------------------------------------
+
+def macd(series, fast=3, slow=10, smooth=16):
+    """
+    compute the MACD (Moving Average Convergence/Divergence)
+    using a fast and slow exponential moving avg'
+    return value is emaslow, emafast, macd which are len(x) arrays
+    """
+    macd = rolling_weighted_mean(series, window=fast) - \
+        rolling_weighted_mean(series, window=slow)
+    signal = rolling_weighted_mean(macd, window=smooth)
+    histogram = macd - signal
+    # return macd, signal, histogram
+    return pd.DataFrame(index=series.index, data={
+        'macd': macd.values,
+        'signal': signal.values,
+        'histogram': histogram.values
+    })
+
+
+# ---------------------------------------------
+
+def bollinger_bands(series, window=20, stds=2):
+    sma = rolling_mean(series, window=window)
+    std = rolling_std(series, window=window)
+    upper = sma + std * stds
+    lower = sma - std * stds
+
+    return pd.DataFrame(index=series.index, data={
+        'upper': upper,
+        'mid': sma,
+        'lower': lower
+    })
+
+
+# ---------------------------------------------
+
+def weighted_bollinger_bands(series, window=20, stds=2):
+    ema = rolling_weighted_mean(series, window=window)
+    std = rolling_std(series, window=window)
+    upper = ema + std * stds
+    lower = ema - std * stds
+
+    return pd.DataFrame(index=series.index, data={
+        'upper': upper.values,
+        'mid': ema.values,
+        'lower': lower.values
+    })
+
+
+# ---------------------------------------------
+
+def returns(series):
+    try:
+        res = (series / series.shift(1) -
+               1).replace([np.inf, -np.inf], float('NaN'))
+    except BaseException:
+        res = nans(len(series))
+
+    return pd.Series(index=series.index, data=res)
+
+
+# ---------------------------------------------
+
+def log_returns(series):
+    try:
+        res = np.log(series / series.shift(1)
+                     ).replace([np.inf, -np.inf], float('NaN'))
+    except BaseException:
+        res = nans(len(series))
+
+    return pd.Series(index=series.index, data=res)
+
+
+# ---------------------------------------------
+
+def implied_volatility(series, window=252):
+    try:
+        logret = np.log(series / series.shift(1)
+                        ).replace([np.inf, -np.inf], float('NaN'))
+        res = numpy_rolling_std(logret, window) * np.sqrt(window)
+    except BaseException:
+        res = nans(len(series))
+
+    return pd.Series(index=series.index, data=res)
+
+
+# ---------------------------------------------
+
+def keltner_channel(bars, window=14, atrs=2):
+    typical_mean = rolling_mean(typical_price(bars), window)
+    atrval = atr(bars, window) * atrs
+
+    upper = typical_mean + atrval
+    lower = typical_mean - atrval
+
+    return pd.DataFrame(index=bars.index, data={
+        'upper': upper.values,
+        'mid': typical_mean.values,
+        'lower': lower.values
+    })
+
+
+# ---------------------------------------------
+
+def roc(series, window=14):
+    """
+    compute rate of change
+    """
+    res = (series - series.shift(window)) / series.shift(window)
+    return pd.Series(index=series.index, data=res)
+
+
+# ---------------------------------------------
+
+def cci(series, window=14):
+    """
+    compute commodity channel index
+    """
+    price = typical_price(series)
+    typical_mean = rolling_mean(price, window)
+    res = (price - typical_mean) / (.015 * np.std(typical_mean))
+    return pd.Series(index=series.index, data=res)
+
+
+# ---------------------------------------------
+
+def stoch(df, window=14, d=3, k=3, fast=False):
+    """
+    compute the n period relative strength indicator
+    http://excelta.blogspot.co.il/2013/09/stochastic-oscillator-technical.html
+    """
+    highs_ma = pd.concat([df['high'].shift(i)
+                          for i in np.arange(window)], 1).apply(list, 1)
+    highs_ma = highs_ma.T.max().T
+
+    lows_ma = pd.concat([df['low'].shift(i)
+                         for i in np.arange(window)], 1).apply(list, 1)
+    lows_ma = lows_ma.T.min().T
+
+    fast_k = ((df['close'] - lows_ma) / (highs_ma - lows_ma)) * 100
+    fast_d = numpy_rolling_mean(fast_k, d)
+
+    if fast:
+        data = {
+            'k': fast_k,
+            'd': fast_d
+        }
+
+    else:
+        slow_k = numpy_rolling_mean(fast_k, k)
+        slow_d = numpy_rolling_mean(slow_k, d)
+        data = {
+            'k': slow_k,
+            'd': slow_d
+        }
+
+    return pd.DataFrame(index=df.index, data=data)
+
+
+# ---------------------------------------------
+
+def zscore(bars, window=20, stds=1, col='close'):
+    """ get zscore of price """
+    std = numpy_rolling_std(bars[col], window)
+    mean = numpy_rolling_mean(bars[col], window)
+    return (bars[col] - mean) / (std * stds)
+
+# ---------------------------------------------
+
+
+def pvt(bars):
+    """ Price Volume Trend """
+    pvt = ((bars['close'] - bars['close'].shift(1)) /
+           bars['close'].shift(1)) * bars['volume']
+    return pvt.cumsum()
+
+
+# =============================================
+
+PandasObject.session = session
+PandasObject.atr = atr
+PandasObject.bollinger_bands = bollinger_bands
+PandasObject.cci = cci
+PandasObject.crossed = crossed
+PandasObject.crossed_above = crossed_above
+PandasObject.crossed_below = crossed_below
+PandasObject.heikinashi = heikinashi
+PandasObject.hull_moving_average = hull_moving_average
+PandasObject.ibs = ibs
+PandasObject.implied_volatility = implied_volatility
+PandasObject.keltner_channel = keltner_channel
+PandasObject.log_returns = log_returns
+PandasObject.macd = macd
+PandasObject.returns = returns
+PandasObject.roc = roc
+PandasObject.rolling_max = rolling_max
+PandasObject.rolling_min = rolling_min
+PandasObject.rolling_mean = rolling_mean
+PandasObject.rolling_std = rolling_std
+PandasObject.rsi = rsi
+PandasObject.stoch = stoch
+PandasObject.zscore = zscore
+PandasObject.pvt = pvt
+PandasObject.tdi = tdi
+PandasObject.true_range = true_range
+PandasObject.mid_price = mid_price
+PandasObject.typical_price = typical_price
+PandasObject.vwap = vwap
+PandasObject.rolling_vwap = rolling_vwap
+PandasObject.weighted_bollinger_bands = weighted_bollinger_bands
+PandasObject.rolling_weighted_mean = rolling_weighted_mean
+
+PandasObject.sma = sma
+PandasObject.wma = wma
+PandasObject.hma = hma

requirements.txt

@@ -1,7 +1,8 @@
--e git+https://github.com/ericsomdahl/python-bittrex.git@d7033d0#egg=python-bittrex
+-e git+https://github.com/ericsomdahl/python-bittrex.git@0.2.0#egg=python-bittrex
 SQLAlchemy==1.1.14
 python-telegram-bot==8.1.1
 arrow==0.10.0
+cachetools==2.0.1
 requests==2.18.4
 urllib3==1.22
 wrapt==1.10.11
@@ -17,7 +18,8 @@ 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
+tabulate==0.8.1
 
 # Required for plotting data
 #matplotlib==2.1.0
-#PYQT5==5.9
+#PYQT5==5.9

scripts/plot_dataframe.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+
+import matplotlib  # Install PYQT5 manually if you want to test this helper function
+matplotlib.use("Qt5Agg")
+import matplotlib.pyplot as plt
+
+from freqtrade import exchange, analyze
+
+
+def plot_analyzed_dataframe(pair: str) -> None:
+    """
+    Calls analyze() and plots the returned dataframe
+    :param pair: pair as str
+    :return: None
+    """
+
+    # Init Bittrex to use public API
+    exchange._API = exchange.Bittrex({'key': '', 'secret': ''})
+    dataframe = analyze.analyze_ticker(pair)
+
+    # Two subplots sharing x axis
+    fig, (ax1, ax2, ax3) = plt.subplots(3, sharex=True)
+    fig.suptitle(pair, fontsize=14, fontweight='bold')
+    ax1.plot(dataframe.index.values, dataframe['close'], label='close')
+    # ax1.plot(dataframe.index.values, dataframe['sell'], 'ro', label='sell')
+    ax1.plot(dataframe.index.values, dataframe['sma'], '--', label='SMA')
+    ax1.plot(dataframe.index.values, dataframe['tema'], ':', label='TEMA')
+    ax1.plot(dataframe.index.values, dataframe['blower'], '-.', label='BB low')
+    ax1.plot(dataframe.index.values, dataframe['buy_price'], 'bo', label='buy')
+    ax1.legend()
+
+    ax2.plot(dataframe.index.values, dataframe['adx'], label='ADX')
+    ax2.plot(dataframe.index.values, dataframe['mfi'], label='MFI')
+    # ax2.plot(dataframe.index.values, [25] * len(dataframe.index.values))
+    ax2.legend()
+
+    ax3.plot(dataframe.index.values, dataframe['fastk'], label='k')
+    ax3.plot(dataframe.index.values, dataframe['fastd'], label='d')
+    ax3.plot(dataframe.index.values, [20] * len(dataframe.index.values))
+    ax3.legend()
+
+    # Fine-tune figure; make subplots close to each other and hide x ticks for
+    # all but bottom plot.
+    fig.subplots_adjust(hspace=0)
+    plt.setp([a.get_xticklabels() for a in fig.axes[:-1]], visible=False)
+    plt.show()
+
+
+if __name__ == '__main__':
+    plot_analyzed_dataframe('BTC_ETH')
+

setup.py

@@ -1,5 +1,11 @@
+from sys import version_info
 from setuptools import setup
 
+if version_info.major == 3 and version_info.minor < 6 or \
+        version_info.major < 3:
+    print('Your Python interpreter must be 3.6 or greater!')
+    exit(1)
+
 from freqtrade import __version__
 
 
@@ -15,21 +21,23 @@ setup(name='freqtrade',
       setup_requires=['pytest-runner'],
       tests_require=['pytest', 'pytest-mock', 'pytest-cov'],
       install_requires=[
-          'python-bittrex==0.1.3',
-          'SQLAlchemy==1.1.13',
-          'python-telegram-bot==8.1.1',
-          'arrow==0.10.0',
-          'requests==2.18.4',
-          'urllib3==1.22',
-          'wrapt==1.10.11',
-          'pandas==0.20.3',
-          'scikit-learn==0.19.0',
-          'scipy==0.19.1',
-          'jsonschema==2.6.0',
-          'TA-Lib==0.4.10',
+          'python-bittrex',
+          'SQLAlchemy',
+          'python-telegram-bot',
+          'arrow',
+          'requests',
+          'urllib3',
+          'wrapt',
+          'pandas',
+          'scikit-learn',
+          'scipy',
+          'jsonschema',
+          'TA-Lib',
+          'tabulate',
+          'cachetools',
       ],
       dependency_links=[
-          "git+https://github.com/ericsomdahl/python-bittrex.git@d7033d0#egg=python-bittrex-0.1.3"
+          "git+https://github.com/ericsomdahl/python-bittrex.git@0.2.0#egg=python-bittrex"
       ],
       include_package_data=True,
       zip_safe=False,