stable/freqtrade/exchange/exchange.py

1045 lines
44 KiB
Python
Raw Normal View History

2017-11-18 07:52:28 +00:00
# pragma pylint: disable=W0603
"""
Cryptocurrency Exchanges support
"""
2019-06-09 12:05:36 +00:00
import asyncio
import inspect
2019-06-09 12:05:36 +00:00
import logging
from copy import deepcopy
2019-08-12 14:07:19 +00:00
from datetime import datetime, timezone
2019-06-09 12:05:36 +00:00
from math import ceil, floor
from random import randint
from typing import Any, Dict, List, Optional, Tuple
2017-09-01 19:11:46 +00:00
2018-12-11 18:47:48 +00:00
import arrow
import ccxt
2018-07-31 10:47:32 +00:00
import ccxt.async_support as ccxt_async
from ccxt.base.decimal_to_precision import ROUND_DOWN, ROUND_UP
2018-12-11 18:47:48 +00:00
from pandas import DataFrame
2019-06-09 12:05:36 +00:00
from freqtrade import (DependencyException, InvalidOrderException,
OperationalException, TemporaryError)
2018-12-12 19:16:03 +00:00
from freqtrade.data.converter import parse_ticker_dataframe
from freqtrade.exchange.common import BAD_EXCHANGES, retrier, retrier_async
2019-06-09 12:05:36 +00:00
from freqtrade.misc import deep_merge_dicts
2017-05-12 17:11:56 +00:00
2017-05-14 12:14:16 +00:00
logger = logging.getLogger(__name__)
2017-05-12 17:11:56 +00:00
2019-09-12 01:39:52 +00:00
class Exchange:
2019-02-28 23:13:16 +00:00
_config: Dict = {}
2019-08-14 08:45:57 +00:00
# Parameters to add directly to ccxt sync/async initialization.
_ccxt_config: Dict = {}
2019-11-13 16:50:54 +00:00
2019-08-14 08:45:57 +00:00
# Parameters to add directly to buy/sell calls (like agreeing to trading agreement)
2019-02-17 22:34:15 +00:00
_params: Dict = {}
2019-02-24 18:35:29 +00:00
# Dict to specify which options each exchange implements
2019-06-09 12:05:36 +00:00
# This defines defaults, which can be selectively overridden by subclasses using _ft_has
# or by specifying them in the configuration.
_ft_has_default: Dict = {
2019-02-24 18:35:29 +00:00
"stoploss_on_exchange": False,
"order_time_in_force": ["gtc"],
"ohlcv_candle_limit": 500,
2019-06-09 12:35:58 +00:00
"ohlcv_partial_candle": True,
2019-08-14 17:22:52 +00:00
"trades_pagination": "time", # Possible are "time" or "id"
"trades_pagination_arg": "since",
2019-02-24 18:35:29 +00:00
}
2019-06-09 12:05:36 +00:00
_ft_has: Dict = {}
2019-02-24 18:35:29 +00:00
2019-10-13 08:33:22 +00:00
def __init__(self, config: dict, validate: bool = True) -> None:
2018-06-17 10:41:33 +00:00
"""
Initializes this module with the given config,
2019-02-24 18:35:29 +00:00
it does basic validation whether the specified exchange and pairs are valid.
2018-06-17 10:41:33 +00:00
:return: None
"""
2019-07-03 02:02:44 +00:00
self._api: ccxt.Exchange = None
self._api_async: ccxt_async.Exchange = None
2019-02-28 23:13:16 +00:00
self._config.update(config)
2018-08-19 17:37:48 +00:00
self._cached_ticker: Dict[str, Any] = {}
# Holds last candle refreshed time of each pair
self._pairs_last_refresh_time: Dict[Tuple[str, str], int] = {}
2019-03-10 12:30:45 +00:00
# Timestamp of last markets refresh
self._last_markets_refresh: int = 0
2018-08-19 17:37:48 +00:00
# Holds candles
self._klines: Dict[Tuple[str, str], DataFrame] = {}
2018-08-19 17:37:48 +00:00
2018-12-10 18:54:43 +00:00
# Holds all open sell orders for dry_run
self._dry_run_open_orders: Dict[str, Any] = {}
2018-08-19 17:37:48 +00:00
2018-06-17 10:41:33 +00:00
if config['dry_run']:
logger.info('Instance is running with dry_run enabled')
2017-10-01 21:28:09 +00:00
2018-06-17 10:41:33 +00:00
exchange_config = config['exchange']
2019-06-09 12:05:36 +00:00
# Deep merge ft_has with default ft_has options
self._ft_has = deep_merge_dicts(self._ft_has, deepcopy(self._ft_has_default))
if exchange_config.get("_ft_has_params"):
self._ft_has = deep_merge_dicts(exchange_config.get("_ft_has_params"),
self._ft_has)
2019-06-09 12:35:58 +00:00
logger.info("Overriding exchange._ft_has with config params, result: %s", self._ft_has)
2019-06-09 12:05:36 +00:00
2019-06-09 12:35:58 +00:00
# Assign this directly for easy access
self._ohlcv_candle_limit = self._ft_has['ohlcv_candle_limit']
self._ohlcv_partial_candle = self._ft_has['ohlcv_partial_candle']
2019-06-09 12:35:58 +00:00
2019-08-14 17:22:52 +00:00
self._trades_pagination = self._ft_has['trades_pagination']
self._trades_pagination_arg = self._ft_has['trades_pagination_arg']
2019-06-09 12:35:58 +00:00
# Initialize ccxt objects
ccxt_config = self._ccxt_config.copy()
ccxt_config = deep_merge_dicts(exchange_config.get('ccxt_config', {}),
ccxt_config)
2019-07-03 02:02:44 +00:00
self._api = self._init_ccxt(
exchange_config, ccxt_kwargs=ccxt_config)
ccxt_async_config = self._ccxt_config.copy()
ccxt_async_config = deep_merge_dicts(exchange_config.get('ccxt_async_config', {}),
ccxt_async_config)
2019-07-03 02:02:44 +00:00
self._api_async = self._init_ccxt(
exchange_config, ccxt_async, ccxt_kwargs=ccxt_async_config)
2017-10-01 21:28:09 +00:00
logger.info('Using Exchange "%s"', self.name)
2019-10-13 08:33:22 +00:00
if validate:
# Check if timeframe is available
self.validate_timeframes(config.get('ticker_interval'))
2019-10-13 08:33:22 +00:00
# Initial markets load
self._load_markets()
2019-10-13 08:33:22 +00:00
# Check if all pairs are available
self.validate_pairs(config['exchange']['pair_whitelist'])
self.validate_ordertypes(config.get('order_types', {}))
self.validate_order_time_in_force(config.get('order_time_in_force', {}))
self.validate_required_startup_candles(config.get('startup_candle_count', 0))
# Converts the interval provided in minutes in config to seconds
self.markets_refresh_interval: int = exchange_config.get(
"markets_refresh_interval", 60) * 60
def __del__(self):
"""
Destructor - clean up async stuff
"""
logger.debug("Exchange object destroyed, closing async loop")
if self._api_async and inspect.iscoroutinefunction(self._api_async.close):
asyncio.get_event_loop().run_until_complete(self._api_async.close())
def _init_ccxt(self, exchange_config: dict, ccxt_module=ccxt,
ccxt_kwargs: dict = None) -> ccxt.Exchange:
2018-06-17 11:09:23 +00:00
"""
Initialize ccxt with given config and return valid
ccxt instance.
"""
# Find matching class for the given exchange name
name = exchange_config['name']
2019-09-30 21:33:33 +00:00
if not is_exchange_known_ccxt(name, ccxt_module):
2019-06-11 10:43:29 +00:00
raise OperationalException(f'Exchange {name} is not supported by ccxt')
ex_config = {
'apiKey': exchange_config.get('key'),
'secret': exchange_config.get('secret'),
'password': exchange_config.get('password'),
'uid': exchange_config.get('uid', ''),
}
if ccxt_kwargs:
logger.info('Applying additional ccxt config: %s', ccxt_kwargs)
ex_config.update(ccxt_kwargs)
try:
api = getattr(ccxt_module, name.lower())(ex_config)
except (KeyError, AttributeError) as e:
raise OperationalException(f'Exchange {name} is not supported') from e
2019-07-03 02:13:41 +00:00
except ccxt.BaseError as e:
raise OperationalException(f"Initialization of ccxt failed. Reason: {e}") from e
2018-06-17 11:09:23 +00:00
self.set_sandbox(api, exchange_config, name)
2018-07-27 08:55:36 +00:00
2018-06-17 11:09:23 +00:00
return api
@property
def name(self) -> str:
"""exchange Name (from ccxt)"""
2018-06-18 20:07:15 +00:00
return self._api.name
@property
def id(self) -> str:
"""exchange ccxt id"""
2018-06-18 20:07:15 +00:00
return self._api.id
2017-10-06 10:22:04 +00:00
@property
def timeframes(self) -> List[str]:
return list((self._api.timeframes or {}).keys())
2019-03-04 22:59:08 +00:00
@property
def markets(self) -> Dict:
"""exchange ccxt markets"""
2019-03-06 21:57:31 +00:00
if not self._api.markets:
logger.warning("Markets were not loaded. Loading them now..")
self._load_markets()
2019-03-04 22:59:08 +00:00
return self._api.markets
def get_markets(self, base_currencies: List[str] = None, quote_currencies: List[str] = None,
pairs_only: bool = False, active_only: bool = False) -> Dict:
"""
Return exchange ccxt markets, filtered out by base currency and quote currency
if this was requested in parameters.
TODO: consider moving it to the Dataprovider
"""
markets = self.markets
if not markets:
raise OperationalException("Markets were not loaded.")
if base_currencies:
markets = {k: v for k, v in markets.items() if v['base'] in base_currencies}
if quote_currencies:
markets = {k: v for k, v in markets.items() if v['quote'] in quote_currencies}
if pairs_only:
markets = {k: v for k, v in markets.items() if symbol_is_pair(v['symbol'])}
if active_only:
markets = {k: v for k, v in markets.items() if market_is_active(v)}
return markets
def klines(self, pair_interval: Tuple[str, str], copy=True) -> DataFrame:
if pair_interval in self._klines:
return self._klines[pair_interval].copy() if copy else self._klines[pair_interval]
2018-12-11 18:47:48 +00:00
else:
2018-12-29 12:00:50 +00:00
return DataFrame()
2018-12-11 18:47:48 +00:00
def set_sandbox(self, api, exchange_config: dict, name: str):
if exchange_config.get('sandbox'):
if api.urls.get('test'):
api.urls['api'] = api.urls['test']
logger.info("Enabled Sandbox API on %s", name)
else:
2018-08-05 13:08:07 +00:00
logger.warning(name, "No Sandbox URL in CCXT, exiting. "
2018-07-29 08:10:55 +00:00
"Please check your config.json")
raise OperationalException(f'Exchange {name} does not provide a sandbox api')
2019-03-06 21:48:04 +00:00
def _load_async_markets(self, reload=False) -> None:
2018-08-10 11:04:43 +00:00
try:
if self._api_async:
2019-03-06 21:48:04 +00:00
asyncio.get_event_loop().run_until_complete(
self._api_async.load_markets(reload=reload))
2018-08-10 11:04:43 +00:00
except ccxt.BaseError as e:
logger.warning('Could not load async markets. Reason: %s', e)
return
2019-03-12 15:35:32 +00:00
def _load_markets(self) -> None:
""" Initialize markets both sync and async """
try:
2019-03-12 15:35:32 +00:00
self._api.load_markets()
self._load_async_markets()
2019-03-10 12:30:45 +00:00
self._last_markets_refresh = arrow.utcnow().timestamp
except ccxt.BaseError as e:
logger.warning('Unable to initialize markets. Reason: %s', e)
2019-03-10 12:30:45 +00:00
def _reload_markets(self) -> None:
"""Reload markets both sync and async, if refresh interval has passed"""
# Check whether markets have to be reloaded
if (self._last_markets_refresh > 0) and (
self._last_markets_refresh + self.markets_refresh_interval
> arrow.utcnow().timestamp):
return None
2019-03-10 15:36:25 +00:00
logger.debug("Performing scheduled market reload..")
2019-04-24 19:56:24 +00:00
try:
self._api.load_markets(reload=True)
self._last_markets_refresh = arrow.utcnow().timestamp
except ccxt.BaseError:
2019-04-24 19:56:24 +00:00
logger.exception("Could not reload markets.")
2018-06-17 10:41:33 +00:00
def validate_pairs(self, pairs: List[str]) -> None:
"""
Checks if all given pairs are tradable on the current exchange.
Raises OperationalException if one pair is not available.
:param pairs: list of pairs
:return: None
"""
2017-10-06 10:22:04 +00:00
if not self.markets:
logger.warning('Unable to validate pairs (assuming they are correct).')
return
2018-06-17 10:41:33 +00:00
for pair in pairs:
# Note: ccxt has BaseCurrency/QuoteCurrency format for pairs
# TODO: add a support for having coins in BTC/USDT format
if self.markets and pair not in self.markets:
2018-06-17 10:41:33 +00:00
raise OperationalException(
2019-03-05 18:45:42 +00:00
f'Pair {pair} is not available on {self.name}. '
f'Please remove {pair} from your whitelist.')
elif self.markets[pair].get('info', {}).get('IsRestricted', False):
# Warn users about restricted pairs in whitelist.
# We cannot determine reliably if Users are affected.
logger.warning(f"Pair {pair} is restricted for some users on this exchange."
f"Please check if you are impacted by this restriction "
f"on the exchange and eventually remove {pair} from your whitelist.")
2018-06-17 10:41:33 +00:00
2019-07-07 04:36:35 +00:00
def get_valid_pair_combination(self, curr_1, curr_2) -> str:
"""
2019-07-07 04:36:35 +00:00
Get valid pair combination of curr_1 and curr_2 by trying both combinations.
"""
2019-07-07 04:36:35 +00:00
for pair in [f"{curr_1}/{curr_2}", f"{curr_2}/{curr_1}"]:
2019-07-03 18:20:12 +00:00
if pair in self.markets and self.markets[pair].get('active'):
return pair
2019-07-07 04:36:35 +00:00
raise DependencyException(f"Could not combine {curr_1} and {curr_2} to get a valid pair.")
def validate_timeframes(self, timeframe: Optional[str]) -> None:
"""
Checks if ticker interval from config is a supported timeframe on the exchange
"""
2019-07-02 22:03:38 +00:00
if not hasattr(self._api, "timeframes") or self._api.timeframes is None:
# If timeframes attribute is missing (or is None), the exchange probably
# has no fetchOHLCV method.
# Therefore we also show that.
raise OperationalException(
2019-07-02 22:03:38 +00:00
f"The ccxt library does not provide the list of timeframes "
f"for the exchange \"{self.name}\" and this exchange "
f"is therefore not supported. ccxt fetchOHLCV: {self.exchange_has('fetchOHLCV')}")
if timeframe and (timeframe not in self.timeframes):
2018-07-05 12:05:31 +00:00
raise OperationalException(
f"Invalid ticker interval '{timeframe}'. This exchange supports: {self.timeframes}")
def validate_ordertypes(self, order_types: Dict) -> None:
"""
Checks if order-types configured in strategy/config are supported
"""
if any(v == 'market' for k, v in order_types.items()):
if not self.exchange_has('createMarketOrder'):
raise OperationalException(
f'Exchange {self.name} does not support market orders.')
2019-02-24 18:35:29 +00:00
if (order_types.get("stoploss_on_exchange")
and not self._ft_has.get("stoploss_on_exchange", False)):
2019-02-24 19:18:41 +00:00
raise OperationalException(
f'On exchange stoploss is not supported for {self.name}.'
2019-02-24 19:18:41 +00:00
)
2018-11-25 20:09:35 +00:00
def validate_order_time_in_force(self, order_time_in_force: Dict) -> None:
"""
Checks if order time in force configured in strategy/config are supported
"""
if any(v not in self._ft_has["order_time_in_force"]
for k, v in order_time_in_force.items()):
2019-03-21 18:12:15 +00:00
raise OperationalException(
f'Time in force policies are not supported for {self.name} yet.')
2018-11-25 20:09:35 +00:00
def validate_required_startup_candles(self, startup_candles) -> None:
"""
Checks if required startup_candles is more than ohlcv_candle_limit.
2019-10-27 09:56:38 +00:00
Requires a grace-period of 5 candles - so a startup-period up to 494 is allowed by default.
"""
if startup_candles + 5 > self._ft_has['ohlcv_candle_limit']:
raise OperationalException(
f"This strategy requires {startup_candles} candles to start. "
f"{self.name} only provides {self._ft_has['ohlcv_candle_limit']}.")
2018-06-17 10:41:33 +00:00
def exchange_has(self, endpoint: str) -> bool:
"""
Checks if exchange implements a specific API endpoint.
Wrapper around ccxt 'has' attribute
:param endpoint: Name of endpoint (e.g. 'fetchOHLCV', 'fetchTickers')
:return: bool
"""
2018-06-18 20:07:15 +00:00
return endpoint in self._api.has and self._api.has[endpoint]
2018-06-17 10:41:33 +00:00
def symbol_amount_prec(self, pair, amount: float):
'''
Returns the amount to buy or sell to a precision the Exchange accepts
Rounded down
'''
if self.markets[pair]['precision']['amount']:
symbol_prec = self.markets[pair]['precision']['amount']
big_amount = amount * pow(10, symbol_prec)
amount = floor(big_amount) / pow(10, symbol_prec)
return amount
def symbol_price_prec(self, pair, price: float):
'''
Returns the price buying or selling with to the precision the Exchange accepts
Rounds up
'''
if self.markets[pair]['precision']['price']:
symbol_prec = self.markets[pair]['precision']['price']
big_price = price * pow(10, symbol_prec)
price = ceil(big_price) / pow(10, symbol_prec)
return price
def dry_run_order(self, pair: str, ordertype: str, side: str, amount: float,
rate: float, params: Dict = {}) -> Dict[str, Any]:
order_id = f'dry_run_{side}_{randint(0, 10**6)}'
_amount = self.symbol_amount_prec(pair, amount)
dry_order = {
"id": order_id,
'pair': pair,
'price': rate,
'amount': _amount,
"cost": _amount * rate,
'type': ordertype,
2019-03-08 20:17:12 +00:00
'side': side,
'remaining': _amount,
'datetime': arrow.utcnow().isoformat(),
'status': "closed" if ordertype == "market" else "open",
2019-02-23 15:03:15 +00:00
'fee': None,
"info": {}
}
2019-02-23 15:28:13 +00:00
self._store_dry_order(dry_order)
# Copy order and close it - so the returned order is open unless it's a market order
return dry_order
2019-02-23 15:28:13 +00:00
def _store_dry_order(self, dry_order: Dict) -> None:
2019-02-23 15:03:15 +00:00
closed_order = dry_order.copy()
if closed_order["type"] in ["market", "limit"]:
closed_order.update({
"status": "closed",
"filled": closed_order["amount"],
"remaining": 0
})
if closed_order["type"] in ["stop_loss_limit"]:
closed_order["info"].update({"stopPrice": closed_order["price"]})
2019-02-23 15:03:15 +00:00
self._dry_run_open_orders[closed_order["id"]] = closed_order
def create_order(self, pair: str, ordertype: str, side: str, amount: float,
rate: float, params: Dict = {}) -> Dict:
2018-06-06 18:18:16 +00:00
try:
# Set the precision for amount and price(rate) as accepted by the exchange
amount = self.symbol_amount_prec(pair, amount)
needs_price = (ordertype != 'market'
or self._api.options.get("createMarketBuyOrderRequiresPrice", False))
rate = self.symbol_price_prec(pair, rate) if needs_price else None
return self._api.create_order(pair, ordertype, side,
2019-02-17 22:34:15 +00:00
amount, rate, params)
2018-06-17 10:41:33 +00:00
except ccxt.InsufficientFunds as e:
raise DependencyException(
f'Insufficient funds to create {ordertype} {side} order on market {pair}.'
f'Tried to {side} amount {amount} at rate {rate}.'
f'Message: {e}') from e
2018-06-17 10:41:33 +00:00
except ccxt.InvalidOrder as e:
raise DependencyException(
f'Could not create {ordertype} {side} order on market {pair}.'
f'Tried to {side} amount {amount} at rate {rate}.'
f'Message: {e}') from e
2018-06-06 18:18:16 +00:00
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not place {side} order due to {e.__class__.__name__}. Message: {e}') from e
2018-06-06 18:18:16 +00:00
except ccxt.BaseError as e:
raise OperationalException(e) from e
2017-10-06 10:22:04 +00:00
def buy(self, pair: str, ordertype: str, amount: float,
rate: float, time_in_force) -> Dict:
2019-02-28 23:13:16 +00:00
if self._config['dry_run']:
dry_order = self.dry_run_order(pair, ordertype, "buy", amount, rate)
2019-02-23 15:03:15 +00:00
return dry_order
2017-10-06 10:22:04 +00:00
params = self._params.copy()
if time_in_force != 'gtc' and ordertype != 'market':
params.update({'timeInForce': time_in_force})
return self.create_order(pair, ordertype, 'buy', amount, rate, params)
2019-02-17 22:34:15 +00:00
def sell(self, pair: str, ordertype: str, amount: float,
rate: float, time_in_force='gtc') -> Dict:
2019-02-28 23:13:16 +00:00
if self._config['dry_run']:
dry_order = self.dry_run_order(pair, ordertype, "sell", amount, rate)
2019-02-23 15:03:15 +00:00
return dry_order
params = self._params.copy()
if time_in_force != 'gtc' and ordertype != 'market':
params.update({'timeInForce': time_in_force})
return self.create_order(pair, ordertype, 'sell', amount, rate, params)
2017-10-06 10:22:04 +00:00
2018-11-22 15:24:40 +00:00
def stoploss_limit(self, pair: str, amount: float, stop_price: float, rate: float) -> Dict:
"""
creates a stoploss limit order.
Since ccxt does not unify stoploss-limit orders yet, this needs to be implemented in each
exchange's subclass.
The exception below should never raise, since we disallow
starting the bot in validate_ordertypes()
Note: Changes to this interface need to be applied to all sub-classes too.
"""
2018-11-22 15:24:40 +00:00
raise OperationalException(f"stoploss_limit is not implemented for {self.name}.")
2018-06-17 10:41:33 +00:00
@retrier
def get_balance(self, currency: str) -> float:
2019-02-28 23:13:16 +00:00
if self._config['dry_run']:
2019-12-15 08:22:15 +00:00
return self._config['dry_run_wallet']
2018-04-15 17:39:11 +00:00
2018-06-17 10:41:33 +00:00
# ccxt exception is already handled by get_balances
balances = self.get_balances()
balance = balances.get(currency)
if balance is None:
raise TemporaryError(
f'Could not get {currency} balance due to malformed exchange response: {balances}')
return balance['free']
2018-04-15 17:39:11 +00:00
2018-06-17 10:41:33 +00:00
@retrier
def get_balances(self) -> dict:
2019-02-28 23:13:16 +00:00
if self._config['dry_run']:
2018-06-17 10:41:33 +00:00
return {}
2018-06-17 10:41:33 +00:00
try:
2018-06-18 20:07:15 +00:00
balances = self._api.fetch_balance()
2018-06-17 10:41:33 +00:00
# Remove additional info from ccxt results
balances.pop("info", None)
balances.pop("free", None)
balances.pop("total", None)
balances.pop("used", None)
return balances
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not get balance due to {e.__class__.__name__}. Message: {e}') from e
2018-06-17 10:41:33 +00:00
except ccxt.BaseError as e:
raise OperationalException(e) from e
2018-06-17 10:41:33 +00:00
@retrier
def get_tickers(self) -> Dict:
try:
2018-06-18 20:07:15 +00:00
return self._api.fetch_tickers()
2018-06-17 10:41:33 +00:00
except ccxt.NotSupported as e:
raise OperationalException(
2018-06-18 20:07:15 +00:00
f'Exchange {self._api.name} does not support fetching tickers in batch.'
f'Message: {e}') from e
2018-06-17 10:41:33 +00:00
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not load tickers due to {e.__class__.__name__}. Message: {e}') from e
2018-06-17 10:41:33 +00:00
except ccxt.BaseError as e:
raise OperationalException(e) from e
2018-06-17 10:41:33 +00:00
@retrier
2019-12-18 15:34:30 +00:00
def fetch_ticker(self, pair: str, refresh: Optional[bool] = True) -> dict:
2018-06-18 20:09:46 +00:00
if refresh or pair not in self._cached_ticker.keys():
2018-06-17 10:41:33 +00:00
try:
if pair not in self._api.markets or not self._api.markets[pair].get('active'):
raise DependencyException(f"Pair {pair} not available")
2018-06-18 20:07:15 +00:00
data = self._api.fetch_ticker(pair)
2018-06-17 10:41:33 +00:00
try:
2018-06-18 20:09:46 +00:00
self._cached_ticker[pair] = {
2018-06-17 10:41:33 +00:00
'bid': float(data['bid']),
'ask': float(data['ask']),
}
except KeyError:
logger.debug("Could not cache ticker data for %s", pair)
return data
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not load ticker due to {e.__class__.__name__}. Message: {e}') from e
2018-06-17 10:41:33 +00:00
except ccxt.BaseError as e:
raise OperationalException(e) from e
2018-06-17 10:41:33 +00:00
else:
logger.info("returning cached ticker-data for %s", pair)
2018-06-18 20:09:46 +00:00
return self._cached_ticker[pair]
2018-06-17 10:41:33 +00:00
def get_historic_ohlcv(self, pair: str, timeframe: str,
since_ms: int) -> List:
2018-08-10 09:08:28 +00:00
"""
Gets candle history using asyncio and returns the list of candles.
Handles all async doing.
Async over one pair, assuming we get `_ohlcv_candle_limit` candles per call.
:param pair: Pair to download
:param timeframe: Ticker Timeframe to get
:param since_ms: Timestamp in milliseconds to get history from
:returns List of tickers
2018-08-10 09:08:28 +00:00
"""
return asyncio.get_event_loop().run_until_complete(
self._async_get_historic_ohlcv(pair=pair, timeframe=timeframe,
since_ms=since_ms))
2018-08-10 09:08:28 +00:00
async def _async_get_historic_ohlcv(self, pair: str,
timeframe: str,
since_ms: int) -> List:
2018-08-10 09:08:28 +00:00
one_call = timeframe_to_msecs(timeframe) * self._ohlcv_candle_limit
logger.debug(
"one_call: %s msecs (%s)",
one_call,
arrow.utcnow().shift(seconds=one_call // 1000).humanize(only_distance=True)
)
input_coroutines = [self._async_get_candle_history(
pair, timeframe, since) for since in
range(since_ms, arrow.utcnow().timestamp * 1000, one_call)]
2018-08-10 09:08:28 +00:00
tickers = await asyncio.gather(*input_coroutines, return_exceptions=True)
# Combine tickers
data: List = []
for p, timeframe, ticker in tickers:
if p == pair:
data.extend(ticker)
# Sort data again after extending the result - above calls return in "async order"
2018-08-18 19:08:59 +00:00
data = sorted(data, key=lambda x: x[0])
2018-08-10 09:08:28 +00:00
logger.info("downloaded %s with length %s.", pair, len(data))
return data
def refresh_latest_ohlcv(self, pair_list: List[Tuple[str, str]]) -> List[Tuple[str, List]]:
"""
2019-08-15 04:37:26 +00:00
Refresh in-memory ohlcv asynchronously and set `_klines` with the result
Loops asynchronously over pair_list and downloads all pairs async (semi-parallel).
:param pair_list: List of 2 element tuples containing pair, interval to refresh
:return: Returns a List of ticker-dataframes.
"""
logger.debug("Refreshing ohlcv data for %d pairs", len(pair_list))
input_coroutines = []
2019-02-20 21:46:35 +00:00
# Gather coroutines to run
for pair, timeframe in set(pair_list):
if (not ((pair, timeframe) in self._klines)
or self._now_is_time_to_refresh(pair, timeframe)):
input_coroutines.append(self._async_get_candle_history(pair, timeframe))
else:
logger.debug(
"Using cached ohlcv data for pair %s, timeframe %s ...",
pair, timeframe
)
2018-12-29 12:07:22 +00:00
tickers = asyncio.get_event_loop().run_until_complete(
asyncio.gather(*input_coroutines, return_exceptions=True))
# handle caching
2019-01-19 19:02:37 +00:00
for res in tickers:
if isinstance(res, Exception):
logger.warning("Async code raised an exception: %s", res.__class__.__name__)
continue
pair = res[0]
timeframe = res[1]
ticks = res[2]
# keeping last candle time as last refreshed time of the pair
if ticks:
self._pairs_last_refresh_time[(pair, timeframe)] = ticks[-1][0] // 1000
# keeping parsed dataframe in cache
self._klines[(pair, timeframe)] = parse_ticker_dataframe(
ticks, timeframe, pair=pair, fill_missing=True,
drop_incomplete=self._ohlcv_partial_candle)
2018-07-31 10:47:32 +00:00
return tickers
def _now_is_time_to_refresh(self, pair: str, timeframe: str) -> bool:
2019-02-20 22:20:24 +00:00
# Calculating ticker interval in seconds
interval_in_sec = timeframe_to_seconds(timeframe)
2019-02-20 22:20:24 +00:00
return not ((self._pairs_last_refresh_time.get((pair, timeframe), 0)
+ interval_in_sec) >= arrow.utcnow().timestamp)
2019-02-20 22:20:24 +00:00
2018-08-18 19:05:38 +00:00
@retrier_async
async def _async_get_candle_history(self, pair: str, timeframe: str,
since_ms: Optional[int] = None) -> Tuple[str, str, List]:
"""
2019-08-15 04:37:26 +00:00
Asynchronously gets candle histories using fetch_ohlcv
returns tuple: (pair, timeframe, ohlcv_list)
"""
2018-07-31 10:47:32 +00:00
try:
# fetch ohlcv asynchronously
s = '(' + arrow.get(since_ms // 1000).isoformat() + ') ' if since_ms is not None else ''
logger.debug(
"Fetching pair %s, interval %s, since %s %s...",
pair, timeframe, since_ms, s
)
data = await self._api_async.fetch_ohlcv(pair, timeframe=timeframe,
since=since_ms)
# Because some exchange sort Tickers ASC and other DESC.
# Ex: Bittrex returns a list of tickers ASC (oldest first, newest last)
# when GDAX returns a list of tickers DESC (newest first, oldest last)
2018-11-25 14:00:50 +00:00
# Only sort if necessary to save computing time
2019-01-19 19:02:37 +00:00
try:
if data and data[0][0] > data[-1][0]:
data = sorted(data, key=lambda x: x[0])
except IndexError:
logger.exception("Error loading %s. Result was %s.", pair, data)
return pair, timeframe, []
logger.debug("Done fetching pair %s, interval %s ...", pair, timeframe)
return pair, timeframe, data
2018-07-31 10:47:32 +00:00
except ccxt.NotSupported as e:
raise OperationalException(
f'Exchange {self._api.name} does not support fetching historical candlestick data.'
f'Message: {e}') from e
2018-07-31 10:47:32 +00:00
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(f'Could not load ticker history due to {e.__class__.__name__}. '
f'Message: {e}') from e
2018-06-17 10:41:33 +00:00
except ccxt.BaseError as e:
raise OperationalException(f'Could not fetch ticker data. Msg: {e}') from e
2019-08-14 18:30:29 +00:00
@retrier_async
async def _async_fetch_trades(self, pair: str,
since: Optional[int] = None,
params: Optional[dict] = None) -> List[Dict]:
"""
Asyncronously gets trade history using fetch_trades.
Handles exchange errors, does one call to the exchange.
2019-08-14 18:30:29 +00:00
:param pair: Pair to fetch trade data for
:param since: Since as integer timestamp in milliseconds
returns: List of dicts containing trades
2019-08-14 18:30:29 +00:00
"""
try:
# fetch trades asynchronously
if params:
logger.debug("Fetching trades for pair %s, params: %s ", pair, params)
trades = await self._api_async.fetch_trades(pair, params=params, limit=1000)
else:
logger.debug(
"Fetching trades for pair %s, since %s %s...",
pair, since,
'(' + arrow.get(since // 1000).isoformat() + ') ' if since is not None else ''
)
trades = await self._api_async.fetch_trades(pair, since=since, limit=1000)
return trades
except ccxt.NotSupported as e:
raise OperationalException(
f'Exchange {self._api.name} does not support fetching historical trade data.'
f'Message: {e}') from e
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(f'Could not load trade history due to {e.__class__.__name__}. '
f'Message: {e}') from e
except ccxt.BaseError as e:
raise OperationalException(f'Could not fetch trade data. Msg: {e}') from e
async def _async_get_trade_history_id(self, pair: str,
2019-08-29 11:01:44 +00:00
until: int,
2019-08-14 18:30:29 +00:00
since: Optional[int] = None,
from_id: Optional[str] = None) -> Tuple[str, List[Dict]]:
2019-08-14 18:30:29 +00:00
"""
Asyncronously gets trade history using fetch_trades
2019-09-28 08:56:43 +00:00
use this when exchange uses id-based iteration (check `self._trades_pagination`)
2019-08-14 18:30:29 +00:00
:param pair: Pair to fetch trade data for
:param since: Since as integer timestamp in milliseconds
:param until: Until as integer timestamp in milliseconds
2019-08-16 08:51:04 +00:00
:param from_id: Download data starting with ID (if id is known). Ignores "since" if set.
returns tuple: (pair, trades-list)
2019-08-14 18:30:29 +00:00
"""
trades: List[Dict] = []
if not from_id:
# Fetch first elements using timebased method to get an ID to paginate on
# Depending on the Exchange, this can introduce a drift at the start of the interval
# of up to an hour.
2019-08-29 11:13:41 +00:00
# e.g. Binance returns the "last 1000" candles within a 1h time interval
# - so we will miss the first trades.
t = await self._async_fetch_trades(pair, since=since)
from_id = t[-1]['id']
trades.extend(t[:-1])
while True:
t = await self._async_fetch_trades(pair,
params={self._trades_pagination_arg: from_id})
if len(t):
# Skip last id since its the key for the next call
trades.extend(t[:-1])
2019-08-29 11:01:44 +00:00
if from_id == t[-1]['id'] or t[-1]['timestamp'] > until:
logger.debug(f"Stopping because from_id did not change. "
f"Reached {t[-1]['timestamp']} > {until}")
2019-09-28 11:35:25 +00:00
# Reached the end of the defined-download period - add last trade as well.
trades.extend(t[-1:])
2019-08-14 18:30:29 +00:00
break
from_id = t[-1]['id']
else:
break
return (pair, trades)
2019-08-14 18:30:29 +00:00
async def _async_get_trade_history_time(self, pair: str, until: int,
since: Optional[int] = None) -> Tuple[str, List]:
2019-08-14 18:30:29 +00:00
"""
2019-08-27 05:13:32 +00:00
Asyncronously gets trade history using fetch_trades,
2019-09-28 08:56:43 +00:00
when the exchange uses time-based iteration (check `self._trades_pagination`)
2019-08-14 18:30:29 +00:00
:param pair: Pair to fetch trade data for
:param since: Since as integer timestamp in milliseconds
:param until: Until as integer timestamp in milliseconds
returns tuple: (pair, trades-list)
2019-08-14 18:30:29 +00:00
"""
trades: List[Dict] = []
while True:
t = await self._async_fetch_trades(pair, since=since)
if len(t):
since = t[-1]['timestamp']
trades.extend(t)
# Reached the end of the defined-download period
if until and t[-1]['timestamp'] > until:
2019-08-29 11:01:44 +00:00
logger.debug(
f"Stopping because until was reached. {t[-1]['timestamp']} > {until}")
2019-08-14 18:30:29 +00:00
break
else:
break
return (pair, trades)
async def _async_get_trade_history(self, pair: str,
since: Optional[int] = None,
until: Optional[int] = None,
from_id: Optional[str] = None) -> Tuple[str, List[Dict]]:
"""
Async wrapper handling downloading trades using either time or id based methods.
"""
2019-08-14 18:30:29 +00:00
2019-09-28 08:52:53 +00:00
if self._trades_pagination == 'time':
return await self._async_get_trade_history_time(
pair=pair, since=since,
until=until or ccxt.Exchange.milliseconds())
elif self._trades_pagination == 'id':
return await self._async_get_trade_history_id(
pair=pair, since=since,
until=until or ccxt.Exchange.milliseconds(), from_id=from_id
)
else:
raise OperationalException(f"Exchange {self.name} does use neither time, "
f"nor id based pagination")
2019-08-14 18:30:29 +00:00
def get_historic_trades(self, pair: str,
since: Optional[int] = None,
until: Optional[int] = None,
from_id: Optional[str] = None) -> Tuple[str, List]:
2019-08-14 18:30:29 +00:00
"""
Gets candle history using asyncio and returns the list of candles.
Handles all async doing.
Async over one pair, assuming we get `_ohlcv_candle_limit` candles per call.
:param pair: Pair to download
2019-08-16 08:51:04 +00:00
:param since: Timestamp in milliseconds to get history from
:param until: Timestamp in milliseconds. Defaults to current timestamp if not defined.
:param from_id: Download data starting with ID (if id is known)
2019-08-14 18:30:29 +00:00
:returns List of tickers
"""
if not self.exchange_has("fetchTrades"):
raise OperationalException("This exchange does not suport downloading Trades.")
return asyncio.get_event_loop().run_until_complete(
self._async_get_trade_history(pair=pair, since=since,
until=until, from_id=from_id))
2019-08-14 18:30:29 +00:00
2018-06-17 10:41:33 +00:00
@retrier
def cancel_order(self, order_id: str, pair: str) -> None:
2019-02-28 23:13:16 +00:00
if self._config['dry_run']:
2018-06-17 10:41:33 +00:00
return
try:
2018-06-18 20:07:15 +00:00
return self._api.cancel_order(order_id, pair)
2018-06-17 10:41:33 +00:00
except ccxt.InvalidOrder as e:
2019-04-02 16:45:18 +00:00
raise InvalidOrderException(
f'Could not cancel order. Message: {e}') from e
2018-06-17 10:41:33 +00:00
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not cancel order due to {e.__class__.__name__}. Message: {e}') from e
2018-06-17 10:41:33 +00:00
except ccxt.BaseError as e:
raise OperationalException(e) from e
2018-06-17 10:41:33 +00:00
@retrier
def get_order(self, order_id: str, pair: str) -> Dict:
2019-02-28 23:13:16 +00:00
if self._config['dry_run']:
try:
order = self._dry_run_open_orders[order_id]
return order
except KeyError as e:
# Gracefully handle errors with dry-run orders.
raise InvalidOrderException(
f'Tried to get an invalid dry-run-order (id: {order_id}). Message: {e}') from e
2018-06-17 10:41:33 +00:00
try:
2018-06-18 20:07:15 +00:00
return self._api.fetch_order(order_id, pair)
2018-06-17 10:41:33 +00:00
except ccxt.InvalidOrder as e:
raise InvalidOrderException(
f'Tried to get an invalid order (id: {order_id}). Message: {e}') from e
2018-06-17 10:41:33 +00:00
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not get order due to {e.__class__.__name__}. Message: {e}') from e
2018-06-17 10:41:33 +00:00
except ccxt.BaseError as e:
raise OperationalException(e) from e
2017-11-11 18:20:16 +00:00
2018-08-05 04:41:06 +00:00
@retrier
def get_order_book(self, pair: str, limit: int = 100) -> dict:
2018-08-07 10:29:37 +00:00
"""
get order book level 2 from exchange
Notes:
20180619: bittrex doesnt support limits -.-
"""
2018-08-05 04:41:06 +00:00
try:
return self._api.fetch_l2_order_book(pair, limit)
except ccxt.NotSupported as e:
raise OperationalException(
f'Exchange {self._api.name} does not support fetching order book.'
f'Message: {e}') from e
2018-08-05 04:41:06 +00:00
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not get order book due to {e.__class__.__name__}. Message: {e}') from e
2018-08-05 04:41:06 +00:00
except ccxt.BaseError as e:
raise OperationalException(e) from e
2018-08-05 04:41:06 +00:00
2018-06-17 10:41:33 +00:00
@retrier
def get_trades_for_order(self, order_id: str, pair: str, since: datetime) -> List:
"""
Fetch Orders using the "fetch_my_trades" endpoint and filter them by order-id.
The "since" argument passed in is coming from the database and is in UTC,
as timezone-native datetime object.
From the python documentation:
> Naive datetime instances are assumed to represent local time
Therefore, calling "since.timestamp()" will get the UTC timestamp, after applying the
transformation from local timezone to UTC.
This works for timezones UTC+ since then the result will contain trades from a few hours
instead of from the last 5 seconds, however fails for UTC- timezones,
since we're then asking for trades with a "since" argument in the future.
:param order_id order_id: Order-id as given when creating the order
:param pair: Pair the order is for
:param since: datetime object of the order creation time. Assumes object is in UTC.
"""
2019-02-28 23:13:16 +00:00
if self._config['dry_run']:
2018-06-17 10:41:33 +00:00
return []
if not self.exchange_has('fetchMyTrades'):
return []
try:
2018-09-15 18:28:36 +00:00
# Allow 5s offset to catch slight time offsets (discovered in #1185)
# since needs to be int in milliseconds
my_trades = self._api.fetch_my_trades(
pair, int((since.replace(tzinfo=timezone.utc).timestamp() - 5) * 1000))
2018-06-17 10:41:33 +00:00
matched_trades = [trade for trade in my_trades if trade['order'] == order_id]
2017-11-11 18:20:16 +00:00
2018-06-17 10:41:33 +00:00
return matched_trades
2018-06-17 10:41:33 +00:00
except ccxt.NetworkError as e:
raise TemporaryError(
f'Could not get trades due to networking error. Message: {e}') from e
2018-06-17 10:41:33 +00:00
except ccxt.BaseError as e:
raise OperationalException(e) from e
2018-06-17 10:41:33 +00:00
@retrier
2019-12-14 12:22:42 +00:00
def get_fee(self, symbol, type='', side='', amount=1,
2018-06-17 10:41:33 +00:00
price=1, taker_or_maker='maker') -> float:
try:
# validate that markets are loaded before trying to get fee
2018-06-18 20:07:15 +00:00
if self._api.markets is None or len(self._api.markets) == 0:
self._api.load_markets()
2018-04-15 17:39:11 +00:00
2018-06-18 20:07:15 +00:00
return self._api.calculate_fee(symbol=symbol, type=type, side=side, amount=amount,
2018-06-17 10:41:33 +00:00
price=price, takerOrMaker=taker_or_maker)['rate']
except (ccxt.NetworkError, ccxt.ExchangeError) as e:
raise TemporaryError(
f'Could not get fee info due to {e.__class__.__name__}. Message: {e}') from e
2018-06-17 10:41:33 +00:00
except ccxt.BaseError as e:
raise OperationalException(e) from e
2019-08-22 17:01:41 +00:00
def is_exchange_bad(exchange_name: str) -> bool:
return exchange_name in BAD_EXCHANGES
2019-08-13 06:20:35 +00:00
2019-08-22 17:01:41 +00:00
def get_exchange_bad_reason(exchange_name: str) -> str:
return BAD_EXCHANGES.get(exchange_name, "")
2019-06-11 10:18:35 +00:00
2019-09-30 21:33:33 +00:00
def is_exchange_known_ccxt(exchange_name: str, ccxt_module=None) -> bool:
return exchange_name in ccxt_exchanges(ccxt_module)
2019-06-11 10:18:35 +00:00
2019-08-22 17:01:41 +00:00
def is_exchange_officially_supported(exchange_name: str) -> bool:
return exchange_name in ['bittrex', 'binance']
2019-09-30 21:33:33 +00:00
def ccxt_exchanges(ccxt_module=None) -> List[str]:
"""
Return the list of all exchanges known to ccxt
"""
2019-04-10 21:07:27 +00:00
return ccxt_module.exchanges if ccxt_module is not None else ccxt.exchanges
2019-09-30 21:33:33 +00:00
def available_exchanges(ccxt_module=None) -> List[str]:
"""
Return exchanges available to the bot, i.e. non-bad exchanges in the ccxt list
"""
exchanges = ccxt_exchanges(ccxt_module)
return [x for x in exchanges if not is_exchange_bad(x)]
def timeframe_to_seconds(timeframe: str) -> int:
"""
Translates the timeframe interval value written in the human readable
form ('1m', '5m', '1h', '1d', '1w', etc.) to the number
of seconds for one timeframe interval.
"""
return ccxt.Exchange.parse_timeframe(timeframe)
def timeframe_to_minutes(timeframe: str) -> int:
"""
2019-08-12 14:07:19 +00:00
Same as timeframe_to_seconds, but returns minutes.
"""
return ccxt.Exchange.parse_timeframe(timeframe) // 60
def timeframe_to_msecs(timeframe: str) -> int:
"""
2019-08-12 14:07:19 +00:00
Same as timeframe_to_seconds, but returns milliseconds.
"""
return ccxt.Exchange.parse_timeframe(timeframe) * 1000
2019-08-12 14:07:19 +00:00
2019-08-12 14:17:06 +00:00
def timeframe_to_prev_date(timeframe: str, date: datetime = None) -> datetime:
2019-08-12 14:11:43 +00:00
"""
Use Timeframe and determine last possible candle.
2019-08-12 14:17:06 +00:00
:param timeframe: timeframe in string format (e.g. "5m")
:param date: date to use. Defaults to utcnow()
:returns: date of previous candle (with utc timezone)
2019-08-12 14:11:43 +00:00
"""
if not date:
date = datetime.now(timezone.utc)
new_timestamp = ccxt.Exchange.round_timeframe(timeframe, date.timestamp() * 1000,
ROUND_DOWN) // 1000
2019-08-12 14:11:43 +00:00
return datetime.fromtimestamp(new_timestamp, tz=timezone.utc)
2019-08-12 14:17:06 +00:00
def timeframe_to_next_date(timeframe: str, date: datetime = None) -> datetime:
2019-08-12 14:07:19 +00:00
"""
Use Timeframe and determine next candle.
2019-08-12 14:17:06 +00:00
:param timeframe: timeframe in string format (e.g. "5m")
:param date: date to use. Defaults to utcnow()
:returns: date of next candle (with utc timezone)
2019-08-12 14:07:19 +00:00
"""
if not date:
date = datetime.now(timezone.utc)
new_timestamp = ccxt.Exchange.round_timeframe(timeframe, date.timestamp() * 1000,
ROUND_UP) // 1000
2019-08-12 14:07:19 +00:00
return datetime.fromtimestamp(new_timestamp, tz=timezone.utc)
def symbol_is_pair(market_symbol: str, base_currency: str = None, quote_currency: str = None):
"""
Check if the market symbol is a pair, i.e. that its symbol consists of the base currency and the
quote currency separated by '/' character. If base_currency and/or quote_currency is passed,
it also checks that the symbol contains appropriate base and/or quote currency part before
and after the separating character correspondingly.
"""
symbol_parts = market_symbol.split('/')
return (len(symbol_parts) == 2 and
(symbol_parts[0] == base_currency if base_currency else len(symbol_parts[0]) > 0) and
(symbol_parts[1] == quote_currency if quote_currency else len(symbol_parts[1]) > 0))
def market_is_active(market):
"""
Return True if the market is active.
"""
# "It's active, if the active flag isn't explicitly set to false. If it's missing or
# true then it's true. If it's undefined, then it's most likely true, but not 100% )"
# See https://github.com/ccxt/ccxt/issues/4874,
# https://github.com/ccxt/ccxt/issues/4075#issuecomment-434760520
return market.get('active', True) is not False