2017-11-07 16:54:44 +00:00
|
|
|
#!/usr/bin/env python3
|
2017-10-06 10:22:04 +00:00
|
|
|
import copy
|
2017-09-08 13:51:00 +00:00
|
|
|
import json
|
2017-05-12 17:11:56 +00:00
|
|
|
import logging
|
2017-11-17 16:18:31 +00:00
|
|
|
import sys
|
2017-05-12 17:11:56 +00:00
|
|
|
import time
|
|
|
|
import traceback
|
|
|
|
from datetime import datetime
|
2017-11-11 18:20:53 +00:00
|
|
|
from typing import Dict, Optional, List
|
2017-09-01 19:11:46 +00:00
|
|
|
|
2017-10-31 23:25:12 +00:00
|
|
|
import requests
|
2017-11-11 18:20:53 +00:00
|
|
|
from cachetools import cached, TTLCache
|
2017-09-08 13:51:00 +00:00
|
|
|
|
2017-11-20 21:15:19 +00:00
|
|
|
from freqtrade import __version__, exchange, persistence, rpc, DependencyException, \
|
|
|
|
OperationalException
|
2017-11-14 17:06:03 +00:00
|
|
|
from freqtrade.analyze import get_signal, SignalType
|
2017-11-17 16:54:31 +00:00
|
|
|
from freqtrade.misc import State, get_state, update_state, parse_args, throttle, \
|
2017-11-20 21:15:19 +00:00
|
|
|
load_config
|
2017-09-28 21:26:28 +00:00
|
|
|
from freqtrade.persistence import Trade
|
2017-12-25 07:51:41 +00:00
|
|
|
from freqtrade.fiat_convert import CryptoToFiatConverter
|
2017-05-12 17:11:56 +00:00
|
|
|
|
2017-11-08 21:43:47 +00:00
|
|
|
logger = logging.getLogger('freqtrade')
|
2017-05-17 23:46:08 +00:00
|
|
|
|
2017-09-08 21:10:22 +00:00
|
|
|
_CONF = {}
|
|
|
|
|
2017-09-08 13:51:00 +00:00
|
|
|
|
2017-12-30 13:15:07 +00:00
|
|
|
def refresh_whitelist(whitelist: List[str]) -> List[str]:
|
2017-11-13 20:34:47 +00:00
|
|
|
"""
|
|
|
|
Check wallet health and remove pair from whitelist if necessary
|
2018-01-02 11:04:47 +00:00
|
|
|
:param whitelist: the sorted list (based on BaseVolume) of pairs the user might want to trade
|
2017-12-30 13:15:07 +00:00
|
|
|
:return: the list of pairs the user wants to trade without the one unavailable or black_listed
|
2017-11-13 20:34:47 +00:00
|
|
|
"""
|
2018-01-02 11:04:47 +00:00
|
|
|
sanitized_whitelist = whitelist
|
2017-11-13 20:34:47 +00:00
|
|
|
health = exchange.get_wallet_health()
|
2018-01-02 11:04:47 +00:00
|
|
|
known_pairs = set()
|
2017-11-13 20:34:47 +00:00
|
|
|
for status in health:
|
|
|
|
pair = '{}_{}'.format(_CONF['stake_currency'], status['Currency'])
|
2018-01-02 11:04:47 +00:00
|
|
|
known_pairs.add(pair)
|
2017-12-30 13:15:07 +00:00
|
|
|
if pair not in whitelist or pair in _CONF['exchange'].get('pair_blacklist', []):
|
2017-11-13 20:34:47 +00:00
|
|
|
continue
|
2018-01-02 11:04:47 +00:00
|
|
|
if not status['IsActive']:
|
|
|
|
sanitized_whitelist.remove(pair)
|
2017-11-13 20:34:47 +00:00
|
|
|
logger.info(
|
|
|
|
'Ignoring %s from whitelist (reason: %s).',
|
|
|
|
pair, status.get('Notice') or 'wallet is not active'
|
|
|
|
)
|
2018-01-02 11:04:47 +00:00
|
|
|
|
|
|
|
# We need to remove pairs that are unknown
|
|
|
|
final_list = [x for x in sanitized_whitelist if x in known_pairs]
|
|
|
|
return final_list
|
2017-11-13 20:34:47 +00:00
|
|
|
|
|
|
|
|
2017-12-30 13:15:07 +00:00
|
|
|
def _process(nb_assets: Optional[int] = 0) -> bool:
|
2017-08-30 18:19:14 +00:00
|
|
|
"""
|
2017-09-08 13:51:00 +00:00
|
|
|
Queries the persistence layer for open trades and handles them,
|
|
|
|
otherwise a new trade is created.
|
2017-12-30 13:15:07 +00:00
|
|
|
:param: nb_assets: the maximum number of pairs to be traded at the same time
|
2017-11-07 21:26:08 +00:00
|
|
|
:return: True if a trade has been created or closed, False otherwise
|
2017-08-30 18:19:14 +00:00
|
|
|
"""
|
2017-11-07 21:26:08 +00:00
|
|
|
state_changed = False
|
2017-09-08 22:31:40 +00:00
|
|
|
try:
|
2017-11-13 20:34:47 +00:00
|
|
|
# Refresh whitelist based on wallet maintenance
|
2017-12-30 13:15:07 +00:00
|
|
|
sanitized_list = refresh_whitelist(
|
2017-12-16 02:39:47 +00:00
|
|
|
gen_pair_whitelist(
|
2017-12-30 13:15:07 +00:00
|
|
|
_CONF['stake_currency']
|
|
|
|
) if nb_assets else _CONF['exchange']['pair_whitelist']
|
2017-11-13 20:34:47 +00:00
|
|
|
)
|
2017-12-30 13:15:07 +00:00
|
|
|
|
|
|
|
# Keep only the subsets of pairs wanted (up to nb_assets)
|
|
|
|
final_list = sanitized_list[:nb_assets] if nb_assets else sanitized_list
|
|
|
|
_CONF['exchange']['pair_whitelist'] = final_list
|
|
|
|
|
2017-09-08 22:31:40 +00:00
|
|
|
# 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
|
2017-11-22 19:51:25 +00:00
|
|
|
state_changed = create_trade(float(_CONF['stake_amount']))
|
|
|
|
if not state_changed:
|
2017-11-10 16:56:03 +00:00
|
|
|
logger.info(
|
|
|
|
'Checked all whitelisted currencies. '
|
|
|
|
'Found no suitable entry positions for buying. Will keep looking ...'
|
|
|
|
)
|
2017-12-25 11:07:50 +00:00
|
|
|
except DependencyException as exception:
|
|
|
|
logger.warning('Unable to create trade: %s', exception)
|
2017-09-08 22:31:40 +00:00
|
|
|
|
|
|
|
for trade in trades:
|
2017-10-31 23:25:12 +00:00
|
|
|
# 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))
|
|
|
|
|
2017-11-17 19:17:29 +00:00
|
|
|
if trade.is_open and trade.open_order_id is None:
|
2017-10-31 23:25:12 +00:00
|
|
|
# Check if we can sell our current pair
|
2017-11-07 21:26:08 +00:00
|
|
|
state_changed = handle_trade(trade) or state_changed
|
2017-10-31 23:25:12 +00:00
|
|
|
|
|
|
|
Trade.session.flush()
|
2017-11-07 16:45:13 +00:00
|
|
|
except (requests.exceptions.RequestException, json.JSONDecodeError) as error:
|
2017-11-16 15:39:06 +00:00
|
|
|
logger.warning(
|
|
|
|
'Got %s in _process(), retrying in 30 seconds...',
|
|
|
|
error
|
|
|
|
)
|
2017-10-31 23:25:12 +00:00
|
|
|
time.sleep(30)
|
2017-11-20 21:15:19 +00:00
|
|
|
except OperationalException:
|
|
|
|
rpc.send_msg('*Status:* Got OperationalException:\n```\n{traceback}```{hint}'.format(
|
2017-11-06 00:03:37 +00:00
|
|
|
traceback=traceback.format_exc(),
|
2017-11-06 17:15:33 +00:00
|
|
|
hint='Issue `/start` if you think it is safe to restart.'
|
2017-11-06 00:03:37 +00:00
|
|
|
))
|
2017-11-20 21:15:19 +00:00
|
|
|
logger.exception('Got OperationalException. Stopping trader ...')
|
2017-11-06 00:03:37 +00:00
|
|
|
update_state(State.STOPPED)
|
2017-11-07 21:26:08 +00:00
|
|
|
return state_changed
|
2017-05-14 12:14:16 +00:00
|
|
|
|
2017-05-12 17:11:56 +00:00
|
|
|
|
2017-10-31 23:22:38 +00:00
|
|
|
def execute_sell(trade: Trade, limit: float) -> None:
|
2017-09-08 14:27:00 +00:00
|
|
|
"""
|
2017-10-31 23:22:38 +00:00
|
|
|
Executes a limit sell for the given trade and limit
|
2017-09-08 14:27:00 +00:00
|
|
|
:param trade: Trade instance
|
2017-10-31 23:22:38 +00:00
|
|
|
:param limit: limit rate for the sell order
|
2017-09-08 14:27:00 +00:00
|
|
|
:return: None
|
|
|
|
"""
|
2017-10-31 23:22:38 +00:00
|
|
|
# Execute sell and update trade record
|
|
|
|
order_id = exchange.sell(str(trade.pair), limit, trade.amount)
|
|
|
|
trade.open_order_id = order_id
|
|
|
|
|
2017-12-17 21:07:56 +00:00
|
|
|
fmt_exp_profit = round(trade.calc_profit_percent(rate=limit) * 100, 2)
|
2017-12-25 07:51:41 +00:00
|
|
|
profit_trade = trade.calc_profit(rate=limit)
|
|
|
|
|
2017-12-30 03:52:55 +00:00
|
|
|
message = '*{exchange}:* Selling [{pair}]({pair_url}) with limit `{limit:.8f}`'.format(
|
|
|
|
exchange=trade.exchange,
|
|
|
|
pair=trade.pair.replace('_', '/'),
|
|
|
|
pair_url=exchange.get_pair_detail_url(trade.pair),
|
|
|
|
limit=limit
|
|
|
|
)
|
|
|
|
|
|
|
|
# For regular case, when the configuration exists
|
|
|
|
if 'stake_currency' in _CONF and 'fiat_display_currency' in _CONF:
|
|
|
|
fiat_converter = CryptoToFiatConverter()
|
|
|
|
profit_fiat = fiat_converter.convert_amount(
|
|
|
|
profit_trade,
|
|
|
|
_CONF['stake_currency'],
|
|
|
|
_CONF['fiat_display_currency']
|
|
|
|
)
|
2018-01-01 19:18:38 +00:00
|
|
|
message += '` ({gain}: {profit_percent:.2f}%, {profit_coin:.8f} {coin}`' \
|
2017-12-30 03:52:55 +00:00
|
|
|
'` / {profit_fiat:.3f} {fiat})`'.format(
|
2018-01-01 19:18:38 +00:00
|
|
|
gain="profit" if fmt_exp_profit > 0 else "loss",
|
2017-12-25 07:51:41 +00:00
|
|
|
profit_percent=fmt_exp_profit,
|
|
|
|
profit_coin=profit_trade,
|
|
|
|
coin=_CONF['stake_currency'],
|
|
|
|
profit_fiat=profit_fiat,
|
|
|
|
fiat=_CONF['fiat_display_currency'],
|
2017-12-30 03:52:55 +00:00
|
|
|
)
|
|
|
|
# Because telegram._forcesell does not have the configuration
|
|
|
|
# Ignore the FIAT value and does not show the stake_currency as well
|
|
|
|
else:
|
2018-01-01 19:18:38 +00:00
|
|
|
message += '` ({gain}: {profit_percent:.2f}%, {profit_coin:.8f})`'.format(
|
|
|
|
gain="profit" if fmt_exp_profit > 0 else "loss",
|
2017-12-30 03:52:55 +00:00
|
|
|
profit_percent=fmt_exp_profit,
|
|
|
|
profit_coin=profit_trade
|
|
|
|
)
|
|
|
|
|
|
|
|
# Send the message
|
|
|
|
rpc.send_msg(message)
|
2017-11-22 19:51:25 +00:00
|
|
|
Trade.session.flush()
|
2017-09-07 14:33:04 +00:00
|
|
|
|
2017-05-12 17:11:56 +00:00
|
|
|
|
2017-11-16 05:49:06 +00:00
|
|
|
def min_roi_reached(trade: Trade, current_rate: float, current_time: datetime) -> bool:
|
2017-09-25 12:42:16 +00:00
|
|
|
"""
|
2017-11-16 05:49:06 +00:00
|
|
|
Based an earlier trade and current price and ROI configuration, decides whether bot should sell
|
2017-09-25 12:42:16 +00:00
|
|
|
:return True if bot should sell at current rate
|
|
|
|
"""
|
2017-12-17 21:07:56 +00:00
|
|
|
current_profit = trade.calc_profit_percent(current_rate)
|
2017-09-25 12:42:16 +00:00
|
|
|
if 'stoploss' in _CONF and current_profit < float(_CONF['stoploss']):
|
|
|
|
logger.debug('Stop loss hit.')
|
|
|
|
return True
|
|
|
|
|
2017-11-16 18:17:23 +00:00
|
|
|
# Check if time matches and current rate is above threshold
|
|
|
|
time_diff = (current_time - trade.open_date).total_seconds() / 60
|
2017-09-25 12:42:16 +00:00
|
|
|
for duration, threshold in sorted(_CONF['minimal_roi'].items()):
|
2017-10-31 23:22:38 +00:00
|
|
|
if time_diff > float(duration) and current_profit > threshold:
|
2017-09-25 12:42:16 +00:00
|
|
|
return True
|
|
|
|
|
2017-12-17 21:07:56 +00:00
|
|
|
logger.debug('Threshold not reached. (cur_profit: %1.2f%%)', float(current_profit) * 100.0)
|
2017-09-25 12:42:16 +00:00
|
|
|
return False
|
|
|
|
|
|
|
|
|
2017-11-07 21:26:08 +00:00
|
|
|
def handle_trade(trade: Trade) -> bool:
|
2017-05-12 17:11:56 +00:00
|
|
|
"""
|
2017-05-14 12:14:16 +00:00
|
|
|
Sells the current pair if the threshold is reached and updates the trade record.
|
2017-11-07 21:26:08 +00:00
|
|
|
:return: True if trade has been sold, False otherwise
|
2017-05-12 17:11:56 +00:00
|
|
|
"""
|
2017-11-07 21:26:08 +00:00
|
|
|
if not trade.is_open:
|
|
|
|
raise ValueError('attempt to handle closed trade: {}'.format(trade))
|
2017-09-25 12:17:29 +00:00
|
|
|
|
2017-11-07 21:26:08 +00:00
|
|
|
logger.debug('Handling %s ...', trade)
|
|
|
|
current_rate = exchange.get_ticker(trade.pair)['bid']
|
2017-11-24 20:58:00 +00:00
|
|
|
|
|
|
|
# Check if minimal roi has been reached
|
2017-12-28 23:00:30 +00:00
|
|
|
if min_roi_reached(trade, current_rate, datetime.utcnow()):
|
|
|
|
logger.debug('Executing sell due to ROI ...')
|
|
|
|
execute_sell(trade, current_rate)
|
|
|
|
return True
|
2017-11-24 20:58:00 +00:00
|
|
|
|
|
|
|
# Check if sell signal has been enabled and triggered
|
|
|
|
if _CONF.get('experimental', {}).get('use_sell_signal'):
|
|
|
|
logger.debug('Checking sell_signal ...')
|
2017-12-28 23:00:30 +00:00
|
|
|
if get_signal(trade.pair, SignalType.SELL):
|
|
|
|
logger.debug('Executing sell due to sell signal ...')
|
|
|
|
execute_sell(trade, current_rate)
|
|
|
|
return True
|
2017-11-24 20:58:00 +00:00
|
|
|
|
2017-12-28 23:00:30 +00:00
|
|
|
return False
|
2017-05-12 17:11:56 +00:00
|
|
|
|
2017-10-06 10:22:04 +00:00
|
|
|
|
2017-09-20 14:34:47 +00:00
|
|
|
def get_target_bid(ticker: Dict[str, float]) -> float:
|
2017-09-17 20:21:46 +00:00
|
|
|
""" 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'])
|
|
|
|
|
2017-05-12 17:11:56 +00:00
|
|
|
|
2017-11-22 19:51:25 +00:00
|
|
|
def create_trade(stake_amount: float) -> bool:
|
2017-05-12 17:11:56 +00:00
|
|
|
"""
|
2017-09-01 18:46:01 +00:00
|
|
|
Checks the implemented trading indicator(s) for a randomly picked pair,
|
|
|
|
if one pair triggers the buy_signal a new trade record gets created
|
2017-05-12 17:11:56 +00:00
|
|
|
:param stake_amount: amount of btc to spend
|
2017-11-22 19:51:25 +00:00
|
|
|
:return: True if a trade object has been created and persisted, False otherwise
|
2017-05-12 17:11:56 +00:00
|
|
|
"""
|
2017-11-08 21:43:47 +00:00
|
|
|
logger.info(
|
|
|
|
'Checking buy signals to create a new trade with stake_amount: %f ...',
|
|
|
|
stake_amount
|
|
|
|
)
|
2017-10-06 10:22:04 +00:00
|
|
|
whitelist = copy.deepcopy(_CONF['exchange']['pair_whitelist'])
|
2017-09-11 11:59:11 +00:00
|
|
|
# Check if stake_amount is fulfilled
|
2017-09-08 21:10:22 +00:00
|
|
|
if exchange.get_balance(_CONF['stake_currency']) < stake_amount:
|
2017-11-20 21:15:19 +00:00
|
|
|
raise DependencyException(
|
2017-11-03 20:37:20 +00:00
|
|
|
'stake amount is not fulfilled (currency={})'.format(_CONF['stake_currency'])
|
2017-09-08 21:10:22 +00:00
|
|
|
)
|
2017-05-12 22:30:08 +00:00
|
|
|
|
2017-05-17 17:42:45 +00:00
|
|
|
# Remove currently opened and latest pairs from whitelist
|
2017-09-30 15:02:07 +00:00
|
|
|
for trade in Trade.query.filter(Trade.is_open.is_(True)).all():
|
2017-05-21 14:52:36 +00:00
|
|
|
if trade.pair in whitelist:
|
|
|
|
whitelist.remove(trade.pair)
|
2017-08-27 13:50:59 +00:00
|
|
|
logger.debug('Ignoring %s in pair whitelist', trade.pair)
|
2017-05-12 22:30:08 +00:00
|
|
|
if not whitelist:
|
2017-11-20 21:15:19 +00:00
|
|
|
raise DependencyException('No pair in whitelist')
|
2017-05-12 22:30:08 +00:00
|
|
|
|
2017-05-24 19:52:41 +00:00
|
|
|
# Pick pair based on StochRSI buy signals
|
2018-01-01 18:32:58 +00:00
|
|
|
for _pair in whitelist:
|
|
|
|
if get_signal(_pair, SignalType.BUY):
|
2017-09-08 21:10:22 +00:00
|
|
|
pair = _pair
|
2017-05-24 19:52:41 +00:00
|
|
|
break
|
|
|
|
else:
|
2017-11-22 19:51:25 +00:00
|
|
|
return False
|
2017-05-24 19:52:41 +00:00
|
|
|
|
2017-11-22 20:01:44 +00:00
|
|
|
# Calculate amount
|
2017-10-31 23:22:38 +00:00
|
|
|
buy_limit = get_target_bid(exchange.get_ticker(pair))
|
2017-11-22 20:01:44 +00:00
|
|
|
amount = stake_amount / buy_limit
|
2017-05-14 12:14:16 +00:00
|
|
|
|
2017-11-01 01:20:55 +00:00
|
|
|
order_id = exchange.buy(pair, buy_limit, amount)
|
2018-01-01 22:21:43 +00:00
|
|
|
|
|
|
|
fiat_converter = CryptoToFiatConverter()
|
|
|
|
stake_amount_fiat = fiat_converter.convert_amount(
|
|
|
|
stake_amount,
|
|
|
|
_CONF['stake_currency'],
|
|
|
|
_CONF['fiat_display_currency']
|
|
|
|
)
|
|
|
|
|
2017-05-14 12:14:16 +00:00
|
|
|
# Create trade entity and return
|
2018-01-01 22:21:43 +00:00
|
|
|
rpc.send_msg('*{}:* Buying [{}]({}) with limit `{:.8f} ({:.6f} {}, {:.3f} {})` '.format(
|
2017-10-31 23:22:38 +00:00
|
|
|
exchange.get_name().upper(),
|
2017-06-05 19:17:10 +00:00
|
|
|
pair.replace('_', '/'),
|
2017-09-08 13:51:00 +00:00
|
|
|
exchange.get_pair_detail_url(pair),
|
2018-01-01 22:21:43 +00:00
|
|
|
buy_limit, stake_amount, _CONF['stake_currency'],
|
|
|
|
stake_amount_fiat, _CONF['fiat_display_currency']
|
2017-11-18 20:43:21 +00:00
|
|
|
))
|
2017-11-01 01:20:55 +00:00
|
|
|
# Fee is applied twice because we make a LIMIT_BUY and LIMIT_SELL
|
2017-11-22 19:51:25 +00:00
|
|
|
trade = Trade(
|
|
|
|
pair=pair,
|
|
|
|
stake_amount=stake_amount,
|
|
|
|
amount=amount,
|
2017-12-17 21:07:56 +00:00
|
|
|
fee=exchange.get_fee(),
|
2017-11-22 19:51:25 +00:00
|
|
|
open_rate=buy_limit,
|
|
|
|
open_date=datetime.utcnow(),
|
|
|
|
exchange=exchange.get_name().upper(),
|
|
|
|
open_order_id=order_id
|
|
|
|
)
|
|
|
|
Trade.session.add(trade)
|
|
|
|
Trade.session.flush()
|
|
|
|
return True
|
2017-05-12 17:11:56 +00:00
|
|
|
|
|
|
|
|
2017-09-08 21:10:22 +00:00
|
|
|
def init(config: dict, db_url: Optional[str] = None) -> None:
|
2017-09-08 13:51:00 +00:00
|
|
|
"""
|
|
|
|
Initializes all modules and updates the config
|
|
|
|
:param config: config as dict
|
2017-09-08 19:39:31 +00:00
|
|
|
:param db_url: database connector string for sqlalchemy (Optional)
|
2017-09-08 13:51:00 +00:00
|
|
|
:return: None
|
|
|
|
"""
|
|
|
|
# Initialize all modules
|
2017-11-18 20:30:31 +00:00
|
|
|
rpc.init(config)
|
2017-09-08 19:39:31 +00:00
|
|
|
persistence.init(config, db_url)
|
2017-09-08 13:51:00 +00:00
|
|
|
exchange.init(config)
|
|
|
|
|
2017-09-08 22:31:40 +00:00
|
|
|
# Set initial application state
|
|
|
|
initial_state = config.get('initial_state')
|
|
|
|
if initial_state:
|
|
|
|
update_state(State[initial_state.upper()])
|
|
|
|
else:
|
|
|
|
update_state(State.STOPPED)
|
2017-09-08 13:51:00 +00:00
|
|
|
|
2017-10-27 13:52:14 +00:00
|
|
|
|
2017-11-11 18:20:53 +00:00
|
|
|
@cached(TTLCache(maxsize=1, ttl=1800))
|
2017-12-30 13:15:07 +00:00
|
|
|
def gen_pair_whitelist(base_currency: str, key: str = 'BaseVolume') -> List[str]:
|
2017-11-11 18:20:53 +00:00
|
|
|
"""
|
|
|
|
Updates the whitelist with with a dynamically generated list
|
|
|
|
:param base_currency: base currency as str
|
|
|
|
: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)),
|
2017-11-14 16:48:19 +00:00
|
|
|
key=lambda s: s.get(key) or 0.0,
|
2017-11-11 18:20:53 +00:00
|
|
|
reverse=True
|
|
|
|
)
|
2017-12-11 07:56:03 +00:00
|
|
|
|
2017-12-30 13:15:07 +00:00
|
|
|
return [s['MarketName'].replace('-', '_') for s in summaries]
|
2017-11-11 18:20:53 +00:00
|
|
|
|
|
|
|
|
2017-11-20 21:15:19 +00:00
|
|
|
def cleanup() -> None:
|
2017-10-27 13:52:14 +00:00
|
|
|
"""
|
|
|
|
Cleanup the application state und finish all pending tasks
|
|
|
|
:return: None
|
|
|
|
"""
|
2017-11-18 20:30:31 +00:00
|
|
|
rpc.send_msg('*Status:* `Stopping trader...`')
|
2017-10-27 13:52:14 +00:00
|
|
|
logger.info('Stopping trader and cleaning up modules...')
|
|
|
|
update_state(State.STOPPED)
|
|
|
|
persistence.cleanup()
|
2017-11-18 20:30:31 +00:00
|
|
|
rpc.cleanup()
|
2017-10-27 13:52:14 +00:00
|
|
|
exit(0)
|
|
|
|
|
2017-09-08 13:51:00 +00:00
|
|
|
|
2017-11-20 21:15:19 +00:00
|
|
|
def main() -> None:
|
2017-09-08 22:31:40 +00:00
|
|
|
"""
|
2017-11-08 20:17:51 +00:00
|
|
|
Loads and validates the config and handles the main loop
|
2017-09-08 22:31:40 +00:00
|
|
|
:return: None
|
|
|
|
"""
|
2017-11-08 20:17:51 +00:00
|
|
|
global _CONF
|
2017-11-17 16:18:31 +00:00
|
|
|
args = parse_args(sys.argv[1:])
|
|
|
|
if not args:
|
2017-11-14 21:15:24 +00:00
|
|
|
exit(0)
|
2017-11-08 20:17:51 +00:00
|
|
|
|
2017-11-08 21:43:47 +00:00
|
|
|
# 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
|
2017-11-17 16:54:31 +00:00
|
|
|
_CONF = load_config(args.config)
|
2017-11-08 20:17:51 +00:00
|
|
|
|
2017-11-08 21:43:47 +00:00
|
|
|
# Initialize all modules and start main loop
|
2017-11-11 18:20:53 +00:00
|
|
|
if args.dynamic_whitelist:
|
|
|
|
logger.info('Using dynamically generated whitelist. (--dynamic-whitelist detected)')
|
2017-11-20 21:15:19 +00:00
|
|
|
|
2017-12-14 14:10:11 +00:00
|
|
|
# If the user ask for Dry run with a local DB instead of memory
|
|
|
|
if args.dry_run_db:
|
|
|
|
if _CONF.get('dry_run', False):
|
|
|
|
_CONF.update({'dry_run_db': True})
|
2017-12-16 02:39:47 +00:00
|
|
|
logger.info(
|
|
|
|
'Dry_run will use the DB file: "tradesv3.dry_run.sqlite". (--dry_run_db detected)'
|
|
|
|
)
|
2017-12-14 14:10:11 +00:00
|
|
|
else:
|
|
|
|
logger.info('Dry run is disabled. (--dry_run_db ignored)')
|
|
|
|
|
2017-11-20 21:15:19 +00:00
|
|
|
try:
|
|
|
|
init(_CONF)
|
|
|
|
old_state = None
|
|
|
|
while True:
|
|
|
|
new_state = get_state()
|
|
|
|
# Log state transition
|
|
|
|
if new_state != old_state:
|
|
|
|
rpc.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),
|
2017-12-30 14:43:22 +00:00
|
|
|
nb_assets=args.dynamic_whitelist,
|
2017-11-20 21:15:19 +00:00
|
|
|
)
|
|
|
|
old_state = new_state
|
|
|
|
except KeyboardInterrupt:
|
|
|
|
logger.info('Got SIGINT, aborting ...')
|
2017-11-21 19:24:52 +00:00
|
|
|
except BaseException:
|
|
|
|
logger.exception('Got fatal exception!')
|
2017-11-20 21:15:19 +00:00
|
|
|
finally:
|
|
|
|
cleanup()
|
2017-09-08 13:51:00 +00:00
|
|
|
|
|
|
|
|
2017-09-28 21:47:51 +00:00
|
|
|
if __name__ == '__main__':
|
|
|
|
main()
|