def update_fees(self):
feeInfo = run_function_safe(self.api.fetch_trading_fees)
for market in run_function_safe(self.api.fetch_markets):
pair = market['symbol']
self.fees[pair] = Fees(maker=feeInfo['maker'],
taker=feeInfo['taker'])
def fetch_open_orders(self, symbols):
if(symbols is None):
return run_function_safe(self.api.fetch_open_orders)
else:
orders=[]
for symbol in symbols:
orders+=run_function_safe(self.api.fetch_open_orders,symbol)
return orders
def get_balances(self, balanceDict=None):
coins = run_function_safe(self.api.fetchCurrencies).keys()
balances = run_function_safe(self.api.fetch_balance)
for coin in coins:
if coin not in balances:
balances[coin] = {'total': 0, 'used': 0, 'free': 0}
balances['total'][coin] = 0
balances['used'][coin] = 0
balances['free'][coin] = 0
if (balanceDict is None):
return balances
else:
balanceDict[self.exchange_name.lower()] = balances
def get_past_trades(self, startTime, endTime, marketSymbols, inclusive=False):
allTrades = []
startTime=startTime.timestamp()*1000
endTime=endTime.timestamp()*1000
for marketSymbol in marketSymbols:
marketSymStartTime=startTime
fetchMoreTrades=True
while(fetchMoreTrades):
#get tradebatch
tradeBatch=run_function_safe(self.api.fetchMyTrades, marketSymbol, marketSymStartTime)
tradeBatch=pd.DataFrame(tradeBatch)
if(len(tradeBatch) == 0):
break
if(not(inclusive) or marketSymStartTime != startTime):
tradeBatch = tradeBatch[tradeBatch['timestamp'] > marketSymStartTime]
if (len(tradeBatch) == 0):
break
if(tradeBatch['timestamp'].max() < endTime):
self.log_it('info', 'Fetched {} {} trades since {}.'.format(len(tradeBatch),
marketSymbol,
pd.Timestamp(marketSymStartTime,unit='ms')))
marketSymStartTime=tradeBatch['timestamp'].max()
else:
fetchMoreTrades=False
if(not inclusive):
tradeBatch=tradeBatch[tradeBatch['timestamp']<endTime]
else:
tradeBatch=tradeBatch[tradeBatch['timestamp']<=endTime]
self.log_it('info', 'Fetched {} {} trades since {}.'.format(len(tradeBatch),
marketSymbol,
pd.Timestamp(marketSymStartTime,
unit='ms')))
#store tradebatch
temp = []
for i,trade in tradeBatch.iterrows():
trade = trade.to_dict()
temp.append(trade)
allTrades += temp
return allTrades
def get_real_order_info(self, order):
aggregate=0
allTrades=[]
tries=0
curTimestamp = order['timestamp']
while(order['filled'] != 0 and abs(order['filled']-aggregate)/order['filled']>.00001):
tries+=1
pastTrades = run_function_safe(self.api.fetchMyTrades, order['symbol'], curTimestamp)
timestampsFromOrder = []
allTimestamps = []
for trade in pastTrades:
if(trade['order'] == order['id']):
timestampsFromOrder.append(trade['timestamp'])
aggregate+=trade['amount']
allTrades.append(trade)
allTimestamps.append(trade['timestamp'])
if(len(timestampsFromOrder)>0):
curTimestamp=max(timestampsFromOrder)+1
elif(len(allTimestamps)>0):
curTimestamp = max(allTimestamps)+1
else:
break
return self.trades_to_order(allTrades,order)
def get_order_stats(self, order_id, timestamp=None, marketSym=None):
return run_function_safe(self.api.fetch_order ,order_id, marketSym)
def get_ob(self, market, depth=100):
obUnformatted = run_function_safe(self.api.fetch_order_book, market)
obs = OrderBook(obUnformatted['bids'], obUnformatted['asks'])
return obs
def fetch_closed_orders(self, symbols):
orders=[]
for symbol in symbols:
orders+=run_function_safe(self.api.fetchClosedOrders, symbol)
return orders
def cancel_order(self, order_id, symbol):
return run_function_safe(self.api.cancel_order, order_id, symbol)
def limit_buy(self, market, amount, highest_rate, *args):
return run_function_safe(self.api.create_limit_buy_order, market, amount, highest_rate, *args)
def fetch_closed_orders(self, symbols=None):
return run_function_safe(self.api.fetchClosedOrders)
def fetch_open_orders(self, symbols=None):
return run_function_safe(self.api.fetch_open_orders)
def get_past_trades(self,
startTime,
endTime,
marketSymbols,
inclusive=False):
allTrades = pd.DataFrame()
moreTrades = True
# convert datetime to unix timestamp (seconds)
startTime = startTime.timestamp()
endTime = endTime.timestamp()
temp = startTime
startTime = endTime
endTime = temp
while moreTrades:
endTime = allTrades['time'].min() - 1 if len(
allTrades) else endTime
self.log_it('info', "Loaded All trades since: {}".format(endTime))
# get trade data + reformat to dataframe
tradesRaw = run_function_safe(self.api.privatePostLedgers, {
'type': 'trade',
'end': endTime
})
curTrades = []
for key, value in tradesRaw['result']['ledger'].items():
if (value['asset'] not in self.ledgerCodeToCommonCode):
continue
value['ledgerid'] = key
value['amount'] = float(value['amount'])
value['asset'] = self.ledgerCodeToCommonCode[value['asset']]
curTrades.append(value)
curTrades = pd.DataFrame(curTrades)
if (len(curTrades) == 0):
break
# check if trades are out of time range
if (curTrades['time'].min() <= startTime):
if (inclusive):
curTrades = curTrades[curTrades['time'] >= startTime]
else:
curTrades = curTrades[curTrades['time'] > startTime]
moreTrades = False
# accumulate trades
allTrades = allTrades.append(curTrades, ignore_index=True)
if (len(allTrades) == 0):
return []
# convert timestamp to datetime
allTrades['time'] = pd.to_datetime(allTrades['time'], unit='s')
# rename columns (ccxt trade format)
allTrades = allTrades.rename(columns={
'time': 'datetime',
'amount': 'filled',
'asset': 'symbol'
})
# list of dicts
temp = []
for i, trade in allTrades.iterrows():
trade = trade.to_dict()
temp.append(trade)
allTrades = temp
marketNames = self.get_tickers_safe().keys()
# match ledger entries to make trades
matchedTrades = []
matchedRefIds = set([])
for trade0 in allTrades:
for trade1 in allTrades:
# same refid/ diff symbol/ hasn't been matched yet
if (trade0['refid'] == trade1['refid']
and trade0['refid'] not in matchedRefIds
and trade0['symbol'] != trade1['symbol']):
matchedRefIds.add(trade0['refid'])
matchedTrade = {}
if ('{}/{}'.format(trade0['symbol'], trade1['symbol'])
in marketNames):
baseTrade = trade0
quoteTrade = trade1
elif ('{}/{}'.format(trade1['symbol'], trade0['symbol'])
in marketNames):
baseTrade = trade1
quoteTrade = trade0
else:
raise NameError('Market does not exist: {}, {}'.format(
trade0['symbol'], trade1['symbol']))
# symbol, datetime, filled, cost, fee, side, id
symbol = '{}/{}'.format(baseTrade['symbol'],
quoteTrade['symbol'])
if (marketSymbols is None or symbol in marketSymbols):
matchedTrade['symbol'] = symbol
if (baseTrade['datetime'] > quoteTrade['datetime']):
matchedTrade['datetime'] = baseTrade['datetime']
else:
matchedTrade['datetime'] = quoteTrade['datetime']
if (float(quoteTrade['fee']) > 0):
matchedTrade['fee'] = {
'cost': float(quoteTrade['fee']),
'currency': quoteTrade['symbol']
}
else:
matchedTrade['fee'] = {
'cost': float(baseTrade['fee']),
'currency': baseTrade['symbol']
}
if (quoteTrade['filled'] > 0):
matchedTrade['side'] = 'sell'
else:
matchedTrade['side'] = 'buy'
matchedTrade['filled'] = abs(baseTrade['filled'])
matchedTrade['cost'] = abs(quoteTrade['filled'])
matchedTrade['id'] = baseTrade['refid']
matchedTrades.append(matchedTrade)
return matchedTrades
def get_ledger_items(self, startTime, endTime, itemType, inclusive=False):
allItems = pd.DataFrame()
moreItems = True
# convert datetime to unix timestamp (seconds)
startTime = startTime.timestamp()
endTime = endTime.timestamp()
while moreItems:
endTime = allItems['time'].min() - 1 if len(allItems) else endTime
self.log_it('info', "Loaded items since: {}".format(endTime))
# get ledger data + reformat to dataframe
rawItems = run_function_safe(self.api.privatePostLedgers, {
'type': itemType,
'end': endTime
})
reformattedItems = []
for key, value in rawItems['result']['ledger'].items():
if (value['asset'] not in self.ledgerCodeToCommonCode):
self.log_it(
'error',
'Kraken ledger asset not recognized: {}'.format(
str(value)))
continue
value['ledgerid'] = key
value['amount'] = float(value['amount'])
value['fee'] = float(value['fee'])
value['asset'] = self.ledgerCodeToCommonCode[value['asset']]
reformattedItems.append(value)
reformattedItems = pd.DataFrame(reformattedItems)
if (len(reformattedItems) == 0):
break
# check if data is out of time range
if (reformattedItems['time'].min() <= startTime):
if (inclusive):
reformattedItems = reformattedItems[
reformattedItems['time'] >= startTime]
else:
reformattedItems = reformattedItems[
reformattedItems['time'] > startTime]
moreItems = False
# accumulate trades
allItems = allItems.append(reformattedItems, ignore_index=True)
if (len(allItems) == 0):
return []
# convert timestamp to datetime
allItems['time'] = pd.to_datetime(allItems['time'], unit='s')
# rename columns (ccxt trade format)
allItems = allItems.rename(columns={
'time': 'datetime',
'asset': 'symbol'
})
# list of dicts
temp = []
for i, item in allItems.iterrows():
item = item.to_dict()
temp.append(item)
allItems = temp
return allItems
def get_fees(self, _):
feeInfo = run_function_safe(self.api.fetch_trading_fees)
return Fees(maker=feeInfo['maker'], taker=feeInfo['taker'])
def update_fees(self):
for market in run_function_safe(self.api.fetch_markets):
pair = market['symbol']
self.fees[pair] = Fees()
def get_balances(self, balanceDict = None):
if(balanceDict is None):
return run_function_safe(self.api.fetch_balance)
else:
balanceDict[self.exchange_name.lower()] = run_function_safe(self.api.fetch_balance)
def limit_sell(self, market, amount, lowest_rate, *args):
return run_function_safe(self.api.create_limit_sell_order, market, amount, lowest_rate, *args)
def market_sell(self, market, amount, req=None):
return run_function_safe(self.api.create_market_sell_order, market, amount)
def market_buy(self, market, amount, req=None):
return run_function_safe(self.api.create_market_buy_order,
market,
amount,
params=req)
