move project into freqtrade/

freqtrade/__init__.py

@@ -0,0 +1 @@
+__version__ = '0.10.0'

freqtrade/analyze.py

@@ -0,0 +1,166 @@
+import time
+from datetime import timedelta
+import logging
+import arrow
+import requests
+from pandas import DataFrame
+import talib.abstract as ta
+
+
+logging.basicConfig(level=logging.DEBUG,
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+
+def get_ticker(pair: str, minimum_date: arrow.Arrow) -> dict:
+    """
+    Request ticker data from Bittrex for a given currency pair
+    """
+    url = 'https://bittrex.com/Api/v2.0/pub/market/GetTicks'
+    headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36',
+    }
+    params = {
+        'marketName': pair.replace('_', '-'),
+        'tickInterval': 'fiveMin',
+        '_': minimum_date.timestamp * 1000
+    }
+    data = requests.get(url, params=params, headers=headers).json()
+    if not data['success']:
+        raise RuntimeError('BITTREX: {}'.format(data['message']))
+    return data
+
+
+def parse_ticker_dataframe(ticker: list, minimum_date: arrow.Arrow) -> DataFrame:
+    """
+    Analyses the trend for the given pair
+    :param pair: pair as str in format BTC_ETH or BTC-ETH
+    :return: DataFrame
+    """
+    df = DataFrame(ticker) \
+        .drop('BV', 1) \
+        .rename(columns={'C':'close', 'V':'volume', 'O':'open', 'H':'high', 'L':'low', 'T':'date'}) \
+        .sort_values('date')
+    return df[df['date'].map(arrow.get) > minimum_date]
+
+def populate_indicators(dataframe: DataFrame) -> DataFrame:
+    """
+    Adds several different TA indicators to the given DataFrame
+    """
+    dataframe['sar'] = ta.SAR(dataframe, 0.02, 0.22)
+    dataframe['adx'] = ta.ADX(dataframe)
+    stoch = ta.STOCHF(dataframe)
+    dataframe['fastd'] = stoch['fastd']
+    dataframe['fastk'] = stoch['fastk']
+    dataframe['blower'] = ta.BBANDS(dataframe, nbdevup=2, nbdevdn=2)['lowerband']
+    dataframe['cci'] = ta.CCI(dataframe, timeperiod=5)
+    dataframe['sma'] = ta.SMA(dataframe, timeperiod=100)
+    dataframe['tema'] = ta.TEMA(dataframe, timeperiod=4)
+    dataframe['mfi'] = ta.MFI(dataframe)
+    return dataframe
+
+
+def populate_buy_trend(dataframe: DataFrame) -> DataFrame:
+    """
+    Based on TA indicators, populates the buy trend for the given dataframe
+    :param dataframe: DataFrame
+    :return: DataFrame with buy column
+    """
+
+    dataframe.loc[
+        (dataframe['close'] < dataframe['sma']) &
+        (dataframe['cci'] < -100) &
+        (dataframe['tema'] <= dataframe['blower']) &
+        (dataframe['mfi'] < 30) &
+        (dataframe['fastd'] < 20) &
+        (dataframe['adx'] > 20),
+        'buy'] = 1
+    dataframe.loc[dataframe['buy'] == 1, 'buy_price'] = dataframe['close']
+
+    return dataframe
+
+
+def analyze_ticker(pair: str) -> DataFrame:
+    """
+    Get ticker data for given currency pair, push it to a DataFrame and
+    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(pair, minimum_date)
+    dataframe = parse_ticker_dataframe(data['result'], minimum_date)
+
+    if dataframe.empty:
+        logger.warning('Empty dataframe for pair %s', pair)
+        return dataframe
+    
+    dataframe = populate_indicators(dataframe)
+    dataframe = populate_buy_trend(dataframe)
+    return dataframe
+
+def get_buy_signal(pair: str) -> bool:
+    """
+    Calculates a buy signal based several technical analysis indicators
+    :param pair: pair in format BTC_ANT or BTC-ANT
+    :return: True if pair is good for buying, False otherwise
+    """
+    dataframe = analyze_ticker(pair)
+
+    if dataframe.empty:
+        return False
+
+    latest = dataframe.iloc[-1]
+
+    # Check if dataframe is out of date
+    signal_date = arrow.get(latest['date'])
+    if signal_date < arrow.now() - timedelta(minutes=10):
+        return False
+
+    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) = plt.subplots(2, sharex=True)
+    fig.suptitle(pair, fontsize=14, fontweight='bold')
+    ax1.plot(dataframe.index.values, dataframe['sar'], 'g_', label='pSAR')
+    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['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()
+
+    # 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:
+        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.py

@@ -0,0 +1,170 @@
+import enum
+import logging
+from typing import List
+
+from bittrex.bittrex import Bittrex
+
+logger = logging.getLogger(__name__)
+
+# Current selected exchange
+EXCHANGE = None
+_API = None
+_CONF = {}
+
+
+class Exchange(enum.Enum):
+    BITTREX = 1
+
+
+def init(config: dict) -> None:
+    """
+    Initializes this module with the given config,
+    it does basic validation whether the specified
+    exchange and pairs are valid.
+    :param config: config to use
+    :return: None
+    """
+    global _API, EXCHANGE
+
+    _CONF.update(config)
+
+    if config['dry_run']:
+        logger.info('Instance is running with dry_run enabled')
+
+    use_bittrex = config.get('bittrex', {}).get('enabled', False)
+    if use_bittrex:
+        EXCHANGE = Exchange.BITTREX
+        _API = Bittrex(api_key=config['bittrex']['key'], api_secret=config['bittrex']['secret'])
+    else:
+        raise RuntimeError('No exchange specified. Aborting!')
+
+    # Check if all pairs are available
+    markets = get_markets()
+    exchange_name = EXCHANGE.name.lower()
+    for pair in config[exchange_name]['pair_whitelist']:
+        if pair not in markets:
+            raise RuntimeError('Pair {} is not available at {}'.format(pair, exchange_name))
+
+
+def buy(pair: str, rate: float, amount: float) -> str:
+    """
+    Places a limit buy order.
+    :param pair: Pair as str, format: BTC_ETH
+    :param rate: Rate limit for order
+    :param amount: The amount to purchase
+    :return: order_id of the placed buy order
+    """
+    if _CONF['dry_run']:
+        return 'dry_run'
+    elif EXCHANGE == Exchange.BITTREX:
+        data = _API.buy_limit(pair.replace('_', '-'), amount, rate)
+        if not data['success']:
+            raise RuntimeError('BITTREX: {}'.format(data['message']))
+        return data['result']['uuid']
+
+
+def sell(pair: str, rate: float, amount: float) -> str:
+    """
+    Places a limit sell order.
+    :param pair: Pair as str, format: BTC_ETH
+    :param rate: Rate limit for order
+    :param amount: The amount to sell
+    :return: None
+    """
+    if _CONF['dry_run']:
+        return 'dry_run'
+    elif EXCHANGE == Exchange.BITTREX:
+        data = _API.sell_limit(pair.replace('_', '-'), amount, rate)
+        if not data['success']:
+            raise RuntimeError('BITTREX: {}'.format(data['message']))
+        return data['result']['uuid']
+
+
+def get_balance(currency: str) -> float:
+    """
+    Get account balance.
+    :param currency: currency as str, format: BTC
+    :return: float
+    """
+    if _CONF['dry_run']:
+        return 999.9
+    elif EXCHANGE == Exchange.BITTREX:
+        data = _API.get_balance(currency)
+        if not data['success']:
+            raise RuntimeError('BITTREX: {}'.format(data['message']))
+        return float(data['result']['Balance'] or 0.0)
+
+
+def get_ticker(pair: str) -> dict:
+    """
+    Get Ticker for given pair.
+    :param pair: Pair as str, format: BTC_ETC
+    :return: dict
+    """
+    if EXCHANGE == Exchange.BITTREX:
+        data = _API.get_ticker(pair.replace('_', '-'))
+        if not data['success']:
+            raise RuntimeError('BITTREX: {}'.format(data['message']))
+        return {
+            'bid': float(data['result']['Bid']),
+            'ask': float(data['result']['Ask']),
+            'last': float(data['result']['Last']),
+        }
+
+
+def cancel_order(order_id: str) -> None:
+    """
+    Cancel order for given order_id
+    :param order_id: id as str
+    :return: None
+    """
+    if _CONF['dry_run']:
+        pass
+    elif EXCHANGE == Exchange.BITTREX:
+        data = _API.cancel(order_id)
+        if not data['success']:
+            raise RuntimeError('BITTREX: {}'.format(data['message']))
+
+
+def get_open_orders(pair: str) -> List[dict]:
+    """
+    Get all open orders for given pair.
+    :param pair: Pair as str, format: BTC_ETC
+    :return: list of dicts
+    """
+    if _CONF['dry_run']:
+        return []
+    elif EXCHANGE == Exchange.BITTREX:
+        data = _API.get_open_orders(pair.replace('_', '-'))
+        if not data['success']:
+            raise RuntimeError('BITTREX: {}'.format(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']]
+
+
+def get_pair_detail_url(pair: str) -> str:
+    """
+    Returns the market detail url for the given pair
+    :param pair: pair as str, format: BTC_ANT
+    :return: url as str
+    """
+    if EXCHANGE == Exchange.BITTREX:
+        return 'https://bittrex.com/Market/Index?MarketName={}'.format(pair.replace('_', '-'))
+
+
+def get_markets() -> List[str]:
+    """
+    Returns all available markets
+    :return: list of all available pairs
+    """
+    if EXCHANGE == Exchange. BITTREX:
+        data = _API.get_markets()
+        if not data['success']:
+            raise RuntimeError('BITTREX: {}'.format(data['message']))
+        return [m['MarketName'].replace('-', '_') for m in data['result']]

freqtrade/main.py

@@ -0,0 +1,270 @@
+#!/usr/bin/env python
+import json
+import logging
+import time
+import traceback
+from datetime import datetime
+from typing import Dict, Optional
+
+from jsonschema import validate
+
+from freqtrade import exchange, persistence, __version__
+from freqtrade.analyze import get_buy_signal
+from freqtrade.misc import State, update_state, get_state, CONF_SCHEMA
+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__)
+
+_CONF = {}
+
+
+def _process() -> None:
+    """
+    Queries the persistence layer for open trades and handles them,
+    otherwise a new trade is created.
+    :return: None
+    """
+    try:
+        # Query trades from persistence layer
+        trades = Trade.query.filter(Trade.is_open.is_(True)).all()
+        if len(trades) < _CONF['max_open_trades']:
+            try:
+                # Create entity and execute trade
+                trade = create_trade(float(_CONF['stake_amount']), exchange.EXCHANGE)
+                if trade:
+                    Trade.session.add(trade)
+                else:
+                    logging.info('Got no buy signal...')
+            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__)
+        logger.exception(msg)
+
+
+def close_trade_if_fulfilled(trade: Trade) -> bool:
+    """
+    Checks if the trade is closable, and if so it is being closed.
+    :param trade: Trade
+    :return: True if trade has been closed else False
+    """
+    # If we don't have an open order and the close rate is already set,
+    # we can close this trade.
+    if trade.close_profit is not None \
+            and trade.close_date is not None \
+            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)
+        return True
+    return False
+
+
+def execute_sell(trade: Trade, current_rate: float) -> None:
+    """
+    Executes a sell for the given trade and current rate
+    :param trade: Trade instance
+    :param current_rate: current rate
+    :return: None
+    """
+    # Get available balance
+    currency = trade.pair.split('_')[1]
+    balance = exchange.get_balance(currency)
+    whitelist = _CONF[trade.exchange.name.lower()]['pair_whitelist']
+
+    profit = trade.exec_sell_order(current_rate, balance)
+    whitelist.append(trade.pair)
+    message = '*{}:* Selling [{}]({}) at rate `{:f} (profit: {}%)`'.format(
+        trade.exchange.name,
+        trade.pair.replace('_', '/'),
+        exchange.get_pair_detail_url(trade.pair),
+        trade.close_rate,
+        round(profit, 2)
+    )
+    logger.info(message)
+    telegram.send_msg(message)
+
+
+def should_sell(trade: Trade, current_rate: float, current_time: datetime) -> bool:
+    """
+    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
+
+    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:
+            return True
+
+    logger.debug('Threshold not reached. (cur_profit: %1.2f%%)', current_profit * 100.0)
+    return False
+
+
+def handle_trade(trade: Trade) -> None:
+    """
+    Sells the current pair if the threshold is reached and updates the trade record.
+    :return: None
+    """
+    try:
+        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')
+
+def get_target_bid(ticker: Dict[str, float]) -> float:
+    """ Calculates bid target between current ask price and last price """
+    if ticker['ask'] < ticker['last']:
+        return ticker['ask']
+    balance = _CONF['bid_strategy']['ask_last_balance']
+    return ticker['ask'] + balance * (ticker['last'] - ticker['ask'])
+
+
+def create_trade(stake_amount: float, _exchange: exchange.Exchange) -> Optional[Trade]:
+    """
+    Checks the implemented trading indicator(s) for a randomly picked pair,
+    if one pair triggers the buy_signal a new trade record gets created
+    :param stake_amount: amount of btc to spend
+    :param _exchange: exchange to use
+    """
+    logger.info('Creating new trade with stake_amount: %f ...', stake_amount)
+    whitelist = _CONF[_exchange.name.lower()]['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'])
+        )
+
+    # Remove currently opened and latest pairs from whitelist
+    trades = Trade.query.filter(Trade.is_open.is_(True)).all()
+    latest_trade = Trade.query.filter(Trade.is_open.is_(False)).order_by(Trade.id.desc()).first()
+    if latest_trade:
+        trades.append(latest_trade)
+    for trade in trades:
+        if trade.pair in whitelist:
+            whitelist.remove(trade.pair)
+            logger.debug('Ignoring %s in pair whitelist', trade.pair)
+    if not whitelist:
+        raise ValueError('No pair in whitelist')
+
+    # Pick pair based on StochRSI buy signals
+    for _pair in whitelist:
+        if get_buy_signal(_pair):
+            pair = _pair
+            break
+    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)
+
+    # Create trade entity and return
+    message = '*{}:* Buying [{}]({}) at rate `{:f}`'.format(
+        _exchange.name,
+        pair.replace('_', '/'),
+        exchange.get_pair_detail_url(pair),
+        open_rate
+    )
+    logger.info(message)
+    telegram.send_msg(message)
+    return Trade(pair=pair,
+                 stake_amount=stake_amount,
+                 open_rate=open_rate,
+                 open_date=datetime.utcnow(),
+                 amount=amount,
+                 exchange=_exchange,
+                 open_order_id=order_id,
+                 is_open=True)
+
+
+def init(config: dict, db_url: Optional[str] = None) -> None:
+    """
+    Initializes all modules and updates the config
+    :param config: config as dict
+    :param db_url: database connector string for sqlalchemy (Optional)
+    :return: None
+    """
+    # Initialize all modules
+    telegram.init(config)
+    persistence.init(config, db_url)
+    exchange.init(config)
+
+    # Set initial application state
+    initial_state = config.get('initial_state')
+    if initial_state:
+        update_state(State[initial_state.upper()])
+    else:
+        update_state(State.STOPPED)
+
+
+def app(config: dict) -> None:
+    """
+    Main function which handles the application state
+    :param config: config as dict
+    :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(25)
+            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`')
+
+
+if __name__ == '__main__':
+    with open('config.json') as file:
+        _CONF = json.load(file)
+        validate(_CONF, CONF_SCHEMA)
+        app(_CONF)

freqtrade/misc.py

@@ -0,0 +1,103 @@
+import enum
+
+from wrapt import synchronized
+
+
+class State(enum.Enum):
+    RUNNING = 0
+    STOPPED = 1
+
+
+# Current application state
+_STATE = State.STOPPED
+
+
+@synchronized
+def update_state(state: State) -> None:
+    """
+    Updates the application state
+    :param state: new state
+    :return: None
+    """
+    global _STATE
+    _STATE = state
+
+
+@synchronized
+def get_state() -> State:
+    """
+    Gets the current application state
+    :return:
+    """
+    return _STATE
+
+
+# Required json-schema for user specified config
+CONF_SCHEMA = {
+    'type': 'object',
+    'properties': {
+        'max_open_trades': {'type': 'integer', 'minimum': 1},
+        'stake_currency': {'type': 'string', 'enum': ['BTC', 'ETH', 'USDT']},
+        'stake_amount': {'type': 'number', 'minimum': 0.0005},
+        'dry_run': {'type': 'boolean'},
+        'minimal_roi': {
+            'type': 'object',
+            'patternProperties': {
+                '^[0-9.]+$': {'type': 'number'}
+            },
+            'minProperties': 1
+        },
+        'stoploss': {'type': 'number', 'maximum': 0, 'exclusiveMaximum': True},
+        'bid_strategy': {
+            'type': 'object',
+            'properties': {
+                'ask_last_balance': {
+                    'type': 'number',
+                    'minimum': 0,
+                    'maximum': 1,
+                    'exclusiveMaximum': False
+                },
+            },
+            'required': ['ask_last_balance']
+        },
+        'bittrex': {'$ref': '#/definitions/exchange'},
+        'telegram': {
+            'type': 'object',
+            'properties': {
+                'enabled': {'type': 'boolean'},
+                'token': {'type': 'string'},
+                'chat_id': {'type': 'string'},
+            },
+            'required': ['enabled', 'token', 'chat_id']
+        },
+        'initial_state': {'type': 'string', 'enum': ['running', 'stopped']},
+    },
+    'definitions': {
+        'exchange': {
+            'type': 'object',
+            'properties': {
+                'enabled': {'type': 'boolean'},
+                'key': {'type': 'string'},
+                'secret': {'type': 'string'},
+                'pair_whitelist': {
+                    'type': 'array',
+                    'items': {'type': 'string'},
+                    'uniqueItems': True
+                }
+            },
+            'required': ['enabled', 'key', 'secret', 'pair_whitelist']
+        }
+    },
+    'anyOf': [
+        {'required': ['bittrex']}
+    ],
+    'required': [
+        'max_open_trades',
+        'stake_currency',
+        'stake_amount',
+        'dry_run',
+        'minimal_roi',
+        'bid_strategy',
+        'telegram'
+    ]
+}

freqtrade/persistence.py

@@ -0,0 +1,87 @@
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import Boolean, Column, DateTime, Float, Integer, String, create_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 freqtrade import exchange
+
+_CONF = {}
+
+Base = declarative_base()
+
+
+def init(config: dict, db_url: Optional[str] = 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)
+    :return: None
+    """
+    _CONF.update(config)
+    if not db_url:
+        if _CONF.get('dry_run', False):
+            db_url = 'sqlite:///tradesv2.dry_run.sqlite'
+        else:
+            db_url = 'sqlite:///tradesv2.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)
+
+
+class Trade(Base):
+    __tablename__ = 'trades'
+
+    id = Column(Integer, primary_key=True)
+    exchange = Column(Enum(exchange.Exchange), nullable=False)
+    pair = Column(String, nullable=False)
+    is_open = Column(Boolean, nullable=False, default=True)
+    open_rate = Column(Float, nullable=False)
+    close_rate = Column(Float)
+    close_profit = Column(Float)
+    stake_amount = Column(Float, name='btc_amount', nullable=False)
+    amount = Column(Float, nullable=False)
+    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
+        )
+
+    def exec_sell_order(self, rate: float, amount: float) -> float:
+        """
+        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
+        """
+        profit = 100 * ((rate - self.open_rate) / self.open_rate)
+
+        # 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
+
+        # Flush changes
+        Trade.session.flush()
+        return profit

freqtrade/rpc/__init__.py

@@ -0,0 +1 @@
+from . import telegram

freqtrade/rpc/telegram.py

@@ -0,0 +1,326 @@
+import logging
+from datetime import timedelta
+from typing import Callable, Any
+
+import arrow
+from sqlalchemy import and_, func, text
+from telegram import ParseMode, Bot, Update
+from telegram.error import NetworkError
+from telegram.ext import CommandHandler, Updater
+
+from freqtrade import exchange
+from freqtrade.misc import get_state, State, update_state
+from freqtrade.persistence import Trade
+
+# Remove noisy log messages
+logging.getLogger('requests.packages.urllib3').setLevel(logging.INFO)
+logging.getLogger('telegram').setLevel(logging.INFO)
+logger = logging.getLogger(__name__)
+
+_updater = None
+_CONF = {}
+
+
+def init(config: dict) -> None:
+    """
+    Initializes this module with the given config,
+    registers all known command handlers
+    and starts polling for message updates
+    :param config: config to use
+    :return: None
+    """
+    global _updater
+
+    _CONF.update(config)
+    if not _CONF['telegram']['enabled']:
+        return
+
+    _updater = Updater(token=config['telegram']['token'], workers=0)
+
+    # Register command handler and start telegram message polling
+    handles = [
+        CommandHandler('status', _status),
+        CommandHandler('profit', _profit),
+        CommandHandler('start', _start),
+        CommandHandler('stop', _stop),
+        CommandHandler('forcesell', _forcesell),
+        CommandHandler('performance', _performance),
+    ]
+    for handle in handles:
+        _updater.dispatcher.add_handler(handle)
+    _updater.start_polling(
+        clean=True,
+        bootstrap_retries=3,
+        timeout=30,
+        read_latency=60,
+    )
+    logger.info(
+        'rpc.telegram is listening for following commands: %s',
+        [h.command for h in handles]
+    )
+
+
+def authorized_only(command_handler: Callable[[Bot, Update], None]) -> Callable[..., Any]:
+    """
+    Decorator to check if the message comes from the correct chat_id
+    :param command_handler: Telegram CommandHandler
+    :return: decorated function
+    """
+    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))
+
+        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:
+            logger.info('Rejected unauthorized message from: %s', update.message.chat_id)
+    return wrapper
+
+
+@authorized_only
+def _status(bot: Bot, update: Update) -> None:
+    """
+    Handler for /status.
+    Returns the current TradeThread status
+    :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:
+        for trade in trades:
+            # 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
+
+            fmt_close_profit = '{:.2f}%'.format(
+                round(trade.close_profit, 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}`
+*Close Rate:* `{close_rate}`
+*Current Rate:* `{current_rate}`
+*Close Profit:* `{close_profit}`
+*Current Profit:* `{current_profit:.2f}%`
+*Open Order:* `{open_order}`
+            """.format(
+                trade_id=trade.id,
+                pair=trade.pair,
+                market_url=exchange.get_pair_detail_url(trade.pair),
+                date=arrow.get(trade.open_date).humanize(),
+                open_rate=trade.open_rate,
+                close_rate=trade.close_rate,
+                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,
+            )
+            send_msg(message, bot=bot)
+
+
+@authorized_only
+def _profit(bot: Bot, update: Update) -> None:
+    """
+    Handler for /profit.
+    Returns a cumulative profit statistics.
+    :param bot: telegram bot
+    :param update: message update
+    :return: None
+    """
+    trades = Trade.query.order_by(Trade.id).all()
+
+    profit_amounts = []
+    profits = []
+    durations = []
+    for trade in trades:
+        if trade.close_date:
+            durations.append((trade.close_date - trade.open_date).total_seconds())
+        if trade.close_profit:
+            profit = trade.close_profit
+        else:
+            # Get current rate
+            current_rate = exchange.get_ticker(trade.pair)['bid']
+            profit = 100 * ((current_rate - trade.open_rate) / trade.open_rate)
+
+        profit_amounts.append((profit / 100) * trade.stake_amount)
+        profits.append(profit)
+
+    best_pair = Trade.session.query(Trade.pair, func.sum(Trade.close_profit).label('profit_sum')) \
+        .filter(Trade.is_open.is_(False)) \
+        .group_by(Trade.pair) \
+        .order_by(text('profit_sum DESC')) \
+        .first()
+
+    if not best_pair:
+        send_msg('*Status:* `no closed trade`', bot=bot)
+        return
+
+    bp_pair, bp_rate = best_pair
+    markdown_msg = """
+*ROI:* `{profit_btc:.2f} ({profit:.2f}%)`
+*Trade Count:* `{trade_count}`
+*First Trade opened:* `{first_trade_date}`
+*Latest Trade opened:* `{latest_trade_date}`
+*Avg. Duration:* `{avg_duration}`
+*Best Performing:* `{best_pair}: {best_rate:.2f}%`
+    """.format(
+        profit_btc=round(sum(profit_amounts), 8),
+        profit=round(sum(profits), 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),
+    )
+    send_msg(markdown_msg, bot=bot)
+
+
+@authorized_only
+def _start(bot: Bot, update: Update) -> None:
+    """
+    Handler for /start.
+    Starts TradeThread
+    :param bot: telegram bot
+    :param update: message update
+    :return: None
+    """
+    if get_state() == State.RUNNING:
+        send_msg('*Status:* `already running`', bot=bot)
+    else:
+        update_state(State.RUNNING)
+
+
+@authorized_only
+def _stop(bot: Bot, update: Update) -> None:
+    """
+    Handler for /stop.
+    Stops TradeThread
+    :param bot: telegram bot
+    :param update: message update
+    :return: None
+    """
+    if get_state() == State.RUNNING:
+        send_msg('`Stopping trader ...`', bot=bot)
+        update_state(State.STOPPED)
+    else:
+        send_msg('*Status:* `already stopped`', bot=bot)
+
+
+@authorized_only
+def _forcesell(bot: Bot, update: Update) -> None:
+    """
+    Handler for /forcesell <id>.
+    Sells the given trade at current price
+    :param bot: telegram bot
+    :param update: message update
+    :return: None
+    """
+    if get_state() != State.RUNNING:
+        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.name,
+            trade.pair.replace('_', '/'),
+            exchange.get_pair_detail_url(trade.pair),
+            trade.close_rate,
+            round(profit, 2)
+        )
+        logger.info(message)
+        send_msg(message)
+
+    except ValueError:
+        send_msg('Invalid argument. Usage: `/forcesell <trade_id>`')
+        logger.warning('/forcesell: Invalid argument received')
+
+
+@authorized_only
+def _performance(bot: Bot, update: Update) -> None:
+    """
+    Handler for /performance.
+    Shows a performance statistic from finished trades
+    :param bot: telegram bot
+    :param update: message update
+    :return: None
+    """
+    if get_state() != State.RUNNING:
+        send_msg('`trader is not running`', bot=bot)
+        return
+
+    pair_rates = Trade.session.query(Trade.pair, func.sum(Trade.close_profit).label('profit_sum')) \
+        .filter(Trade.is_open.is_(False)) \
+        .group_by(Trade.pair) \
+        .order_by(text('profit_sum DESC')) \
+        .all()
+
+    stats = '\n'.join('{index}. <code>{pair}\t{profit:.2f}%</code>'.format(
+        index=i + 1,
+        pair=pair,
+        profit=round(rate, 2)
+    ) for i, (pair, rate) in enumerate(pair_rates))
+
+    message = '<b>Performance:</b>\n{}\n'.format(stats)
+    logger.debug(message)
+    send_msg(message, parse_mode=ParseMode.HTML)
+
+
+def send_msg(msg: str, bot: Bot = None, parse_mode: ParseMode = ParseMode.MARKDOWN) -> None:
+    """
+    Send given markdown message
+    :param msg: message
+    :param bot: alternative bot
+    :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')

freqtrade/tests/test_analyze.py

@@ -0,0 +1,52 @@
+# pragma pylint: disable=missing-docstring
+import unittest
+from unittest.mock import patch
+
+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},
+    ]
+}
+
+class TestAnalyze(unittest.TestCase):
+    def setUp(self):
+        self.result = parse_ticker_dataframe(RESULT_BITTREX['result'], arrow.get('2017-08-30T10:00:00'))
+
+    def test_1_dataframe_has_correct_columns(self):
+        self.assertEqual(self.result.columns.tolist(),
+                         ['close', 'high', 'low', 'open', 'date', 'volume'])
+
+    def test_2_orders_by_date(self):
+        self.assertEqual(self.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_3_populates_buy_trend(self):
+        dataframe = populate_buy_trend(populate_indicators(self.result))
+        self.assertTrue('buy' in dataframe.columns)
+        self.assertTrue('buy_price' in dataframe.columns)
+
+    def test_4_returns_latest_buy_signal(self):
+        buydf = DataFrame([{'buy': 1, 'date': arrow.utcnow()}])
+        with patch('freqtrade.analyze.analyze_ticker', return_value=buydf):
+            self.assertEqual(get_buy_signal('BTC-ETH'), True)
+        buydf = DataFrame([{'buy': 0, 'date': arrow.utcnow()}])
+        with patch('freqtrade.analyze.analyze_ticker', return_value=buydf):
+            self.assertEqual(get_buy_signal('BTC-ETH'), False)
+
+
+if __name__ == '__main__':
+    unittest.main()

freqtrade/tests/test_backtesting.py

@@ -0,0 +1,75 @@
+# pragma pylint: disable=missing-docstring
+import json
+import logging
+import os
+import unittest
+from unittest.mock import patch
+
+import arrow
+from pandas import DataFrame
+
+from freqtrade.analyze import analyze_ticker
+from freqtrade.main import should_sell
+from freqtrade.persistence import Trade
+
+
+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
+    ))
+
+class TestMain(unittest.TestCase):
+    pairs = ['btc-neo', 'btc-eth', 'btc-omg', 'btc-edg', 'btc-pay', 'btc-pivx', 'btc-qtum', 'btc-mtl', 'btc-etc', 'btc-ltc']
+    conf = {
+        "minimal_roi": {
+            "60":  0.0,
+            "40":  0.01,
+            "20":  0.02,
+            "0":  0.03
+        },
+        "stoploss": -0.40
+    }
+
+    @classmethod
+    def setUpClass(cls):
+        logging.disable(logging.DEBUG) # disable debug logs that slow backtesting a lot
+
+    @unittest.skipIf(not os.environ.get('BACKTEST', False), "slow, should be run manually")
+    def test_backtest(self):
+        trades = []
+        with patch.dict('freqtrade.main._CONF', self.conf):
+            for pair in self.pairs:
+                with open('testdata/'+pair+'.json') as data_file:
+                    data = json.load(data_file)
+
+                    with patch('freqtrade.analyze.get_ticker', return_value=data):
+                        with 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)
+
+        print('====================== BACKTESTING REPORT ================================')
+
+        for pair in self.pairs:
+            print('For currency {}:'.format(pair))
+            print_results(results[results.currency == pair])
+        print('TOTAL OVER ALL TRADES:')
+        print_results(results)

freqtrade/tests/test_main.py

@@ -0,0 +1,115 @@
+import unittest
+from unittest.mock import patch, MagicMock
+
+from jsonschema import validate
+
+from freqtrade import exchange
+from freqtrade.main import create_trade, handle_trade, close_trade_if_fulfilled, init, \
+    get_target_bid
+from freqtrade.misc import CONF_SCHEMA
+from freqtrade.persistence import Trade
+
+
+class TestMain(unittest.TestCase):
+    conf = {
+        "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
+        },
+        "bittrex": {
+            "enabled": True,
+            "key": "key",
+            "secret": "secret",
+            "pair_whitelist": [
+                "BTC_ETH"
+            ]
+        },
+        "telegram": {
+            "enabled": True,
+            "token": "token",
+            "chat_id": "chat_id"
+        }
+    }
+
+    def test_1_create_trade(self):
+        with patch.dict('freqtrade.main._CONF', self.conf):
+            with patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True) as buy_signal:
+                with patch.multiple('freqtrade.main.telegram', init=MagicMock(), send_msg=MagicMock()):
+                    with patch.multiple('freqtrade.main.exchange',
+                                        get_ticker=MagicMock(return_value={
+                                            'bid': 0.07256061,
+                                            'ask': 0.072661,
+                                            'last': 0.07256061
+                                        }),
+                                        buy=MagicMock(return_value='mocked_order_id')):
+                        init(self.conf, 'sqlite://')
+                        trade = create_trade(15.0, exchange.Exchange.BITTREX)
+                        Trade.session.add(trade)
+                        Trade.session.flush()
+                        self.assertIsNotNone(trade)
+                        self.assertEqual(trade.open_rate, 0.072661)
+                        self.assertEqual(trade.pair, 'BTC_ETH')
+                        self.assertEqual(trade.exchange, exchange.Exchange.BITTREX)
+                        self.assertEqual(trade.amount, 206.43811673387373)
+                        self.assertEqual(trade.stake_amount, 15.0)
+                        self.assertEqual(trade.is_open, True)
+                        self.assertIsNotNone(trade.open_date)
+                        buy_signal.assert_called_once_with('BTC_ETH')
+
+    def test_2_handle_trade(self):
+        with patch.dict('freqtrade.main._CONF', self.conf):
+            with patch.multiple('freqtrade.main.telegram', init=MagicMock(), send_msg=MagicMock()):
+                with patch.multiple('freqtrade.main.exchange',
+                                    get_ticker=MagicMock(return_value={
+                                        'bid': 0.17256061,
+                                        'ask': 0.172661,
+                                        'last': 0.17256061
+                                    }),
+                                    buy=MagicMock(return_value='mocked_order_id')):
+                    trade = Trade.query.filter(Trade.is_open.is_(True)).first()
+                    self.assertTrue(trade)
+                    handle_trade(trade)
+                    self.assertEqual(trade.close_rate, 0.17256061)
+                    self.assertEqual(trade.close_profit, 137.4872490056564)
+                    self.assertIsNotNone(trade.close_date)
+                    self.assertEqual(trade.open_order_id, 'dry_run')
+
+    def test_3_close_trade(self):
+        with patch.dict('freqtrade.main._CONF', self.conf):
+            trade = Trade.query.filter(Trade.is_open.is_(True)).first()
+            self.assertTrue(trade)
+
+            # Simulate that there is no open order
+            trade.open_order_id = None
+
+            closed = close_trade_if_fulfilled(trade)
+            self.assertTrue(closed)
+            self.assertEqual(trade.is_open, False)
+
+    def test_balance_fully_ask_side(self):
+        with patch.dict('freqtrade.main._CONF', {'bid_strategy': {'ask_last_balance': 0.0}}):
+            self.assertEqual(get_target_bid({'ask': 20, 'last': 10}), 20)
+
+    def test_balance_fully_last_side(self):
+        with patch.dict('freqtrade.main._CONF', {'bid_strategy': {'ask_last_balance': 1.0}}):
+            self.assertEqual(get_target_bid({'ask': 20, 'last': 10}), 10)
+
+    def test_balance_when_last_bigger_than_ask(self):
+        with patch.dict('freqtrade.main._CONF', {'bid_strategy': {'ask_last_balance': 1.0}}):
+            self.assertEqual(get_target_bid({'ask': 5, 'last': 10}), 5)
+
+    @classmethod
+    def setUpClass(cls):
+        validate(cls.conf, CONF_SCHEMA)
+
+
+if __name__ == '__main__':
+    unittest.main()

freqtrade/tests/test_persistence.py

@@ -0,0 +1,28 @@
+import unittest
+from unittest.mock import patch
+
+from freqtrade.exchange import Exchange
+from freqtrade.persistence import Trade
+
+
+class TestTrade(unittest.TestCase):
+    def test_1_exec_sell_order(self):
+        with patch('freqtrade.main.exchange.sell', side_effect='mocked_order_id') as api_mock:
+            trade = Trade(
+                pair='BTC_ETH',
+                stake_amount=1.00,
+                open_rate=0.50,
+                amount=10.00,
+                exchange=Exchange.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)
+            self.assertEqual(profit, 100.0)
+            self.assertEqual(trade.close_rate, 1.0)
+            self.assertEqual(trade.close_profit, profit)
+            self.assertIsNotNone(trade.close_date)
+
+
+if __name__ == '__main__':
+    unittest.main()

freqtrade/tests/test_telegram.py

@@ -0,0 +1,195 @@
+import unittest
+from datetime import datetime
+from unittest.mock import patch, MagicMock
+
+from jsonschema import validate
+from telegram import Bot, Update, Message, Chat
+
+from freqtrade import exchange
+from freqtrade.main import init, create_trade
+from freqtrade.misc import update_state, State, get_state, CONF_SCHEMA
+from freqtrade.persistence import Trade
+from freqtrade.rpc.telegram import _status, _profit, _forcesell, _performance, _start, _stop
+
+
+class MagicBot(MagicMock, Bot):
+    pass
+
+
+class TestTelegram(unittest.TestCase):
+
+    conf = {
+        "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
+        },
+        "bittrex": {
+            "enabled": True,
+            "key": "key",
+            "secret": "secret",
+            "pair_whitelist": [
+                "BTC_ETH"
+            ]
+        },
+        "telegram": {
+            "enabled": True,
+            "token": "token",
+            "chat_id": "0"
+        },
+        "initial_state": "running"
+    }
+
+    def test_1_status_handle(self):
+        with patch.dict('freqtrade.main._CONF', self.conf):
+            with patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True):
+                msg_mock = MagicMock()
+                with patch.multiple('freqtrade.main.telegram', _CONF=self.conf, init=MagicMock(), send_msg=msg_mock):
+                    with patch.multiple('freqtrade.main.exchange',
+                                        get_ticker=MagicMock(return_value={
+                                            'bid': 0.07256061,
+                                            'ask': 0.072661,
+                                            'last': 0.07256061
+                                        }),
+                                        buy=MagicMock(return_value='mocked_order_id')):
+                        init(self.conf, 'sqlite://')
+
+                        # Create some test data
+                        trade = create_trade(15.0, exchange.Exchange.BITTREX)
+                        self.assertTrue(trade)
+                        Trade.session.add(trade)
+                        Trade.session.flush()
+
+                        _status(bot=MagicBot(), update=self.update)
+                        self.assertEqual(msg_mock.call_count, 2)
+                        self.assertIn('[BTC_ETH]', msg_mock.call_args_list[-1][0][0])
+
+    def test_2_profit_handle(self):
+        with patch.dict('freqtrade.main._CONF', self.conf):
+            with patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True):
+                msg_mock = MagicMock()
+                with patch.multiple('freqtrade.main.telegram', _CONF=self.conf, init=MagicMock(), send_msg=msg_mock):
+                    with patch.multiple('freqtrade.main.exchange',
+                                        get_ticker=MagicMock(return_value={
+                                            'bid': 0.07256061,
+                                            'ask': 0.072661,
+                                            'last': 0.07256061
+                                        }),
+                                        buy=MagicMock(return_value='mocked_order_id')):
+                        init(self.conf, 'sqlite://')
+
+                        # Create some test data
+                        trade = create_trade(15.0, exchange.Exchange.BITTREX)
+                        self.assertTrue(trade)
+                        trade.close_rate = 0.07256061
+                        trade.close_profit = 100.00
+                        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=self.update)
+                        self.assertEqual(msg_mock.call_count, 2)
+                        self.assertIn('(100.00%)', msg_mock.call_args_list[-1][0][0])
+
+    def test_3_forcesell_handle(self):
+        with patch.dict('freqtrade.main._CONF', self.conf):
+            with patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True):
+                msg_mock = MagicMock()
+                with patch.multiple('freqtrade.main.telegram', _CONF=self.conf, init=MagicMock(), send_msg=msg_mock):
+                    with patch.multiple('freqtrade.main.exchange',
+                                        get_ticker=MagicMock(return_value={
+                                            'bid': 0.07256061,
+                                            'ask': 0.072661,
+                                            'last': 0.07256061
+                                        }),
+                                        buy=MagicMock(return_value='mocked_order_id')):
+                        init(self.conf, 'sqlite://')
+
+                        # Create some test data
+                        trade = create_trade(15.0, exchange.Exchange.BITTREX)
+                        self.assertTrue(trade)
+                        Trade.session.add(trade)
+                        Trade.session.flush()
+
+                        self.update.message.text = '/forcesell 1'
+                        _forcesell(bot=MagicBot(), update=self.update)
+
+                        self.assertEqual(msg_mock.call_count, 2)
+                        self.assertIn('Selling [BTC/ETH]', msg_mock.call_args_list[-1][0][0])
+                        self.assertIn('0.072561', msg_mock.call_args_list[-1][0][0])
+
+    def test_4_performance_handle(self):
+        with patch.dict('freqtrade.main._CONF', self.conf):
+            with patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True):
+                msg_mock = MagicMock()
+                with patch.multiple('freqtrade.main.telegram', _CONF=self.conf, init=MagicMock(), send_msg=msg_mock):
+                    with patch.multiple('freqtrade.main.exchange',
+                                        get_ticker=MagicMock(return_value={
+                                            'bid': 0.07256061,
+                                            'ask': 0.072661,
+                                            'last': 0.07256061
+                                        }),
+                                        buy=MagicMock(return_value='mocked_order_id')):
+                        init(self.conf, 'sqlite://')
+
+                        # Create some test data
+                        trade = create_trade(15.0, exchange.Exchange.BITTREX)
+                        self.assertTrue(trade)
+                        trade.close_rate = 0.07256061
+                        trade.close_profit = 100.00
+                        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=self.update)
+                        self.assertEqual(msg_mock.call_count, 2)
+                        self.assertIn('Performance', msg_mock.call_args_list[-1][0][0])
+                        self.assertIn('BTC_ETH	100.00%', msg_mock.call_args_list[-1][0][0])
+
+    def test_5_start_handle(self):
+        with patch.dict('freqtrade.main._CONF', self.conf):
+            msg_mock = MagicMock()
+            with patch.multiple('freqtrade.main.telegram', _CONF=self.conf, init=MagicMock(), send_msg=msg_mock):
+                init(self.conf, 'sqlite://')
+
+                update_state(State.STOPPED)
+                self.assertEqual(get_state(), State.STOPPED)
+                _start(bot=MagicBot(), update=self.update)
+                self.assertEqual(get_state(), State.RUNNING)
+                self.assertEqual(msg_mock.call_count, 0)
+
+    def test_6_stop_handle(self):
+        with patch.dict('freqtrade.main._CONF', self.conf):
+            msg_mock = MagicMock()
+            with patch.multiple('freqtrade.main.telegram', _CONF=self.conf, init=MagicMock(), send_msg=msg_mock):
+                init(self.conf, 'sqlite://')
+
+                update_state(State.RUNNING)
+                self.assertEqual(get_state(), State.RUNNING)
+                _stop(bot=MagicBot(), update=self.update)
+                self.assertEqual(get_state(), State.STOPPED)
+                self.assertEqual(msg_mock.call_count, 1)
+                self.assertIn('Stopping trader', msg_mock.call_args_list[0][0][0])
+
+    def setUp(self):
+        self.update = Update(0)
+        self.update.message = Message(0, 0, datetime.utcnow(), Chat(0, 0))
+
+    @classmethod
+    def setUpClass(cls):
+        validate(cls.conf, CONF_SCHEMA)
+
+
+if __name__ == '__main__':
+    unittest.main()