def display_order_book(pair):
client = Client("", "", "")
# get order book
stdscr = curses.initscr()
curses.curs_set(0)
stdscr.addstr(0, 0, str("Pair: " + pair))
stdscr.addstr(5, 0, "------------------------------------------------")
stdscr.addstr(6, 0, "Ask Price")
stdscr.addstr(6, 14, "Ask Size")
stdscr.addstr(6, 27, "Bid Price")
stdscr.addstr(6, 40, "Bid Size")
while True:
try:
orderbook = client.get_order_book(pair)
depth = min(20, (min(len(orderbook["asks"]), len(orderbook["bids"]))))
ask_prices, ask_sizes, bid_prices, bid_sizes = [], [], [], []
mid_price = str((float(orderbook["asks"][0][0]) + float(orderbook["bids"][0][0])) / 2.0)
total_ask_volume = 0.0
total_bid_volume = 0.0
spread = float(orderbook["asks"][0][0]) - float(orderbook["bids"][0][0])
stdscr.addstr(2, 0, "Spread: " + str(spread))
for i in range(depth):
total_ask_volume += float(orderbook["asks"][i][1])
total_bid_volume += float(orderbook["bids"][i][1])
stdscr.addstr(1, 0, "Mid Price: " + mid_price)
stdscr.addstr(i+7, 0, str(orderbook["asks"][i][0]))
stdscr.addstr(i+7, 14, str(orderbook["asks"][i][1]))
stdscr.addstr(i+7, 27, str(orderbook["bids"][i][0]))
stdscr.addstr(i+7, 40, str(orderbook["bids"][i][1]))
stdscr.refresh()
stdscr.addstr(3, 0, "Ask Volume: " + str(total_ask_volume))
stdscr.addstr(4, 0, "Bid Volume: " + str(total_bid_volume))
stdscr.refresh()
time.sleep(2)
stdscr.refresh()
except KeyboardInterrupt:
curses.curs_set(1)
curses.endwin()
break
curses.curs_set(1)
curses.endwin()
w2 = avolume / mid_volume
return sum([(w1 * aprice), (w2 * bprice)])
client = Client(api_key='5b35631b09e5a168abec621a',
api_secret='d564e70a-f45e-49cd-b13c-a31fa5bbbb9d')
starttime = datetime.datetime.now(
datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f%Z")
hist_bestBid, hist_bestAsk, hist_spread, hist_midpoint, hist_volume, hist_midpointVolume, hist_gravity = [], [], [], [], [], [], []
n = 60
while (1):
time = datetime.datetime.now(
datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f%Z")
market_data = client.get_order_book('OMX-BTC', limit=9999)
recent_orders = client.get_recent_orders('OMX-BTC', limit=9999)
print(recent_orders)
break
buys, sells = market_data['BUY'], market_data['SELL']
hist_bestBid.append(buys[0][0])
hist_bestAsk.append(sells[0][0])
hist_midpoint.append(np.mean([hist_bestAsk[-1], hist_bestBid[-1]]))
hist_spread.append(hist_bestAsk[-1] - hist_bestBid[-1])
hist_volume.append(
sum([order[2] for order in buys]) + sum([order[2] for order in sells]))
hist_midpointVolume.append(sum([buys[0][2], sells[0][2]]))
hist_gravity.append(
gravity(buys[0][2], sells[0][2], buys[0][0], sells[0][0]))
buy_cnt, sell_cnt = 0, 0
exec_orderVol = []
# continue
#
# for market in sorted_markets[base]:
# if market_data[market]['bid'] <= 0:
# del sorted_markets[base]
# break
# client = ccxt.binance({
# 'apiKey': 'BewB2ElWDT8E6ujjvLFaaWoKHcpdBauHMM8MGdLN5GAmGcSnYB95cMu8ZJB6RYVW',
# 'secret': 'eIwUpHArqkyQaKY66Is8L1YrPXNpZFu1LK4mqdt6mWgG1mBwl58CpE6QDtgPl6NT',
# 'enableRateLimit': True,
# })
# client = ccxt.kucoin({
# 'apiKey': '5b35631b09e5a168abec621a',
# 'secret': 'd564e70a-f45e-49cd-b13c-a31fa5bbbb9d'
#
# })
client = Client(api_key='5b35631b09e5a168abec621a',
api_secret='d564e70a-f45e-49cd-b13c-a31fa5bbbb9d')
#currencies = client.fetch_markets()
#print(currencies)
#market_data = client.fetch_ticker("ETH/BTC")
#market_data = client.fetch_closed_orders("ETH/BTC")
#market_data = client.fetch_balance()
market_data = client.get_order_book('KCS-BTC', limit=50)
#market_data = client.fetch_orde
print(market_data)
print("Kucoin scraper 1.1 aggregating data to ", filename, " and ",
filename1)
with open(filepath, 'r') as f:
data = f.read()
if data == "":
data = {}
else:
data = json.loads(data)
data1 = {}
timeStr = datetime.datetime.now(
datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f%Z")
orders = client.get_order_book(ticker, limit=999999)
#print("Orders:", orders)
recent_orders = client.get_recent_orders(ticker, limit=99999)
#print("recent orders", recent_orders)
#print(recent_orders)
data[timeStr] = {"buys": orders['BUY'], "sells": orders['SELL']}
data1[timeStr] = np.array(recent_orders)
#print(f'DEBUG writing data: {data} \n data1: {data1}')
with open(filepath, 'w') as f:
f.write(json.dumps(data))
f.close()
class KuCoin:
lastTimestamp = None
def __init__(self, Config):
self.publicKey = Config.getPublicKey()
self.secretKey = Config.getSecretKey()
self.client = Client(self.publicKey, self.secretKey)
def checkKeys(self):
try:
b = self.client.get_api_keys()
if 'code' not in b: # If code is there, it means an error code so wrong.
return True
#else:
# self.errorMessage(b)
# return False
except (Exception): #TO DO: extract kucoin exception message directly
self.errorMessage("KuCoin API error.")
return False
def getBalance(self, limit=None, page=None):
try:
jsonD = self.client.get_all_balances()
except Exception as e:
print("Error getting balance.")
return
balances = []
for x in jsonD:
if x['balance'] != 0.0:
balances.append(x) #TO DO, MAKE IT SAME NAMES AS HITBTC
for b in balances:
for key in b.keys():
if (key == "coinType"):
newKey = key.replace("coinType", "currency")
b[newKey] = b[key]
del b[key]
if (key == "balanceStr"):
newKey = key.replace("balanceStr", "available")
b[newKey] = b[key]
del b[key]
return balances
def getSymbols(self):
jsonD = self.client.get_trading_symbols()
symbols = []
for x in jsonD:
symbols.append(x['symbol'])
return symbols
def getOrderHistory(self, Config):
try:
orders = self.client.get_dealt_orders(symbol=Config.getCurrency())
return orders
except Exception as e:
print("ERROR GETTING ORDER HISTORY:")
print(e)
return None
def getActiveOrders(self, Config):
try:
orders = self.client.get_active_orders(symbol=Config.getCurrency())
return orders
except Exception as e:
print("ERROR GETTING ACTIVE ORDERS")
print(e)
return None
def getOrderBook(self, Config, request):
try:
orders = self.client.get_order_book(Config.getCurrency())
if (request == 'SELL'):
return orders['SELL']
if (request == 'BUY'):
return orders['BUY']
except Exception as e:
print(e)
return None
def cancelBuyOrders(self, Config):
try:
cancelAttempt = self.client.cancel_all_orders(
Config.getCurrency(), 'BUY')
if cancelAttempt is None:
return True
except Exception as e:
print(e)
return False
def cancelSellOrders(self, Config):
try:
cancelAttempt = self.client.cancel_all_orders(
Config.getCurrency(), 'SELL')
if cancelAttempt is None:
return True
except Exception as e:
print(e)
return False
def cancelOrders(self, Config):
try:
cancelAttempt = self.client.cancel_all_orders(
Config.getCurrency(), 'BUY')
cancelAttempt = self.client.cancel_all_orders(
Config.getCurrency(), 'SELL')
if cancelAttempt is None:
return True
except Exception as e:
print(e)
return False
def createOrder(self, symbol, side, price, amount):
try:
#sellPrice = str(round(float(price), 6))
transaction = self.client.create_order(symbol, side.upper(), price,
amount)
return transaction # returns orderOid
except Exception as e:
print("Took too long.. mismatch I think??")
print(e)
def errorMessage(self, b):
print(
'\n =================== CyrCraft - Errrr Errorrrrrr ======================= \n'
)
print(b)
print(
'Keys are wrong..\nType 1 to set your keys.. or else any key to go Configuration Menu..'
)
print(
'\n ======================================================================= \n'
)
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import NoSuchElementException
from appium.webdriver.common.touch_action import TouchAction
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.keys import Keys
import sys
import time
from kucoin.client import Client
api_key = '5da8173338300c5593ce60cb'
api_secret = '1656f653-6d7e-483f-8360-4e9df8d43d2d'
api_passphrase = 'qwerasdf1234!'
client = Client(api_key, api_secret, api_passphrase)
depth = client.get_order_book('ETH-BTC')
driver = webdriver.Remote(
command_executor='http://127.0.0.1:4723/wd/hub',
desired_capabilities={
"platformName": "iOS",
"platformVersion": "<iOS 버전>",
"deviceName": "<디바이스 이름>",
"app": "/Users/xxx/xxx_internal.ipa",
"automationName": "XCUITest",
"bundleId": "com.ozys.xxx.internal",
"udid": "<udid 기입>",
"noReset": "true",
"appActivity": "com.xxx.SplashActivity",
"newCommandTimeout": 7200,
class KucoinApi(PyexAPI):
"""kucoin API interface.
"""
logger = logging.getLogger()
def __init__(self,
api_server: str,
api_key: str,
secret_key: str,
api_passphrase: str,
timeout: float,
requests_params=None):
assert (isinstance(api_server, str))
assert (isinstance(api_key, str))
assert (isinstance(secret_key, str))
assert (isinstance(api_passphrase, str))
assert (isinstance(timeout, float))
self.api_server = api_server
self.api_key = api_key
self.secret_key = secret_key
self.timeout = timeout
self.client = Client(api_key, secret_key, api_passphrase)
def get_symbols(self):
return self.client.get_symbols()
def ticker(self, pair: str):
assert (isinstance(pair, str))
return self.client.get_ticker(pair)
def get_balances(self):
return self.client.get_accounts()
def get_coin_info(self, coin: str):
assert (isinstance(coin, str))
return self.client.get_currency(coin)
def order_book(self, pair: str, limit=None):
assert (isinstance(pair, str))
return self.client.get_order_book(pair)
def get_orders(self, pair: str) -> List[Order]:
assert (isinstance(pair, str))
orders = self.client.get_orders(pair, 'active')
return list(
map(lambda item: Order.to_order(item, pair), orders['items']))
def place_order(self, pair: str, is_sell: bool, price: Wad,
amount: Wad) -> str:
assert (isinstance(pair, str))
assert (isinstance(is_sell, bool))
assert (isinstance(price, Wad))
assert (isinstance(amount, Wad))
side = self.client.SIDE_SELL if is_sell else self.client.SIDE_BUY
self.logger.info(f"Placing order ({side}, amount {amount} of {pair},"
f" price {price})...")
result = self.client.create_limit_order(pair, side, str(price),
str(amount))
order_id = result['orderId']
self.logger.info(f"Placed order as #{order_id}")
return order_id
def cancel_order(self, order_id: str, is_sell: bool, pair: str):
assert (isinstance(order_id, str))
assert (isinstance(is_sell, bool))
assert (isinstance(pair, str))
side = self.client.SIDE_SELL if is_sell else self.client.SIDE_BUY
self.logger.info(f"Cancelling order #{order_id} of type {side}...")
try:
self.client.cancel_order(order_id)
self.logger.info(f"Canceled order #{order_id}...")
return True
except Exception as e:
self.logger.error(f"Failed to cancel order #{order_id}... {e}")
return False
def get_trades(self, pair: str, page_number: int = 1) -> List[Trade]:
assert (isinstance(pair, str))
assert (isinstance(page_number, int))
page_number = page_number - 1
limit = 100
result = self.client.get_fills(symbol=pair,
page=page_number,
page_size=limit)
return list(
map(lambda item: Trade.from_dict(pair, item), result['items']))
def get_all_trades(self, pair: str, page_number: int = 1) -> List[Trade]:
assert (isinstance(pair, str))
assert (page_number == 1)
result = self.client.get_trade_histories(pair)
return list(map(lambda item: Trade.from_list(pair, item), result))
def calcSpread( bid, ask):
return ((ask - bid) / bid) * 100
# "sign-in"
client = Client('key1', 'key2')
# set runtime vars manually
pair = "ETH-BTC"
minSpread = 0.3 # %age
disp = 0.000001 # amount to undercut or outbid
orderSize = 0.00001 # quoted in first currency in pair
# loop to keep bot running
while True:
# get orderbook to check bid-ask
orderBook = client.get_order_book(pair, limit=1)
bid = orderBook["BUY"][0][0]
ask = orderBook["SELL"][0][0]
spread = calcSpread(bid, ask)
print("SPREAD: " + str(spread) + "%")
if spread > minSpread:
# get our active orders to check quantity and price points
orders = client.get_active_orders(pair)
noBuys = len(orders["BUY"]) == 0
noSells = len(orders["SELL"]) == 0
if noBuys and noSells:
# place orders
print("Placing new set of orders...")
client.create_buy_order(pair, bid + disp, orderSize)
try:
while len(
client.get_active_orders(symbol)['SELL'] > 0
and client.get_active_orders(symbol)['BUY']) > 0:
print 'Waiting for order to fill...'
print 'Filled'
except:
wait_until_filled(symbol)
# Dumb loop to keep running
while True:
# Pull order book data
print 'Pulling data...'
try:
eth_btc_orders = client.get_order_book('ETH-BTC', limit=1)
rpx_eth_orders = client.get_order_book('RPX-ETH', limit=1)
rpx_btc_orders = client.get_order_book('RPX-BTC', limit=1)
except:
eth_btc_orders = client.get_order_book('ETH-BTC', limit=1)
rpx_eth_orders = client.get_order_book('RPX-ETH', limit=1)
rpx_btc_orders = client.get_order_book('RPX-BTC', limit=1)
eth_btc_bid = eth_btc_orders['BUY'][0][0]
eth_btc_ask = eth_btc_orders['SELL'][0][0]
rpx_eth_bid = rpx_eth_orders['BUY'][0][0]
rpx_eth_ask = rpx_eth_orders['SELL'][0][0]
rpx_btc_bid = rpx_btc_orders['BUY'][0][0]
rpx_btc_ask = rpx_btc_orders['SELL'][0][0]
class KucoinWrapper(BaseExchangeWrapper):
INTERVAL_MAP = {
CandleTicks.one_minute : Client.RESOLUTION_1MINUTE,
CandleTicks.five_minutes : Client.RESOLUTION_5MINUTES,
CandleTicks.thirty_minutes : Client.RESOLUTION_30MINUTES,
CandleTicks.one_hour : Client.RESOLUTION_1HOUR,
CandleTicks.one_day : Client.RESOLUTION_1DAY,
}
TIME_SINCE_MAP = {
CandleTicks.one_minute : "1 hour ago",
CandleTicks.five_minutes : "5 hours ago",
CandleTicks.thirty_minutes : "26 hours ago",
CandleTicks.one_hour : "52 hours ago",
CandleTicks.one_day : "60 days ago",
}
ORDER_TYPE_MAPPINGS = {
'BUY' : OrderType.limit_buy,
'SELL' : OrderType.limit_sell,
}
def __init__(self, api_key, api_secret):
BaseExchangeWrapper.__init__(self)
self._handle = Client(api_key, api_secret)
self._filters = {}
self._load_markets()
def _perform_request(self, request_lambda):
try:
return request_lambda()
except KucoinAPIException as ex:
raise ExchangeAPIException('Failed to perform request: {0}'.format(ex.message))
def _load_currencies(self):
result = self._perform_request(lambda: self._handle.get_coin_list())
for coin in result:
self.add_currency(
Currency(
coin['coin'],
coin['name'],
coin['confirmationCount'],
coin['withdrawFeeRate'] # check if this is right
)
)
def _load_markets(self):
self._load_currencies()
result = self._perform_request(lambda: self._handle.get_trading_symbols())
for market in result:
self.add_market(market['coinTypePair'], market['coinType'])
def _make_symbol(self, base_currency_code, market_currency_code):
return '{0}-{1}'.format(market_currency_code, base_currency_code)
def _process_paged_request(self, make_request, callback):
page = 1
limit = 50
data = self._perform_request(lambda: make_request(limit=limit, page=page))
while len(data['datas']) > 0:
for entry in data['datas']:
callback(entry)
page += 1
data = make_request(limit=limit, page=page)
def get_market_state(self, base_currency_code, market_currency_code):
symbol = self._make_symbol(base_currency_code, market_currency_code)
data = self._perform_request(lambda: self._handle.get_tick(symbol))
return MarketState(data['sell'], data['buy'], data['lastDealPrice'])
def get_orderbook(self, base_currency_code, market_currency_code):
symbol = self._make_symbol(base_currency_code, market_currency_code)
data = self._perform_request(lambda: self._handle.get_order_book(symbol))
buy_orderbook = Orderbook()
sell_orderbook = Orderbook()
for item in data['BUY']:
buy_orderbook.add_order(Order(item[0], item[1]))
for item in data['SELL']:
sell_orderbook.add_order(Order(item[0], item[1]))
return (buy_orderbook, sell_orderbook)
def get_candles(self, base_currency_code, market_currency_code, interval, limit):
symbol = self._make_symbol(base_currency_code, market_currency_code)
since = KucoinWrapper.TIME_SINCE_MAP[interval]
kucoin_interval = KucoinWrapper.INTERVAL_MAP[interval]
data = self._perform_request(
lambda: self._handle.get_historical_klines_tv(symbol, kucoin_interval, since)
)
output = []
for i in data:
output.append(Candle(
i[3], # Low
i[2], # High
i[1], # Open
i[4], # Close
dateparser.parse(str(i[0]))
))
return output
def get_wallets(self):
output = []
self._process_paged_request(
self._handle.get_all_balances,
lambda entry: output.append(Wallet(
entry['coinType'],
entry['balance'],
entry['balance'] - entry['freezeBalance'],
entry['freezeBalance']
))
)
return output
def get_wallet(self, currency_code):
self.check_valid_currency(currency_code)
data = self._perform_request(lambda: self._handle.get_coin_balance(currency_code))
return Wallet(
self._currencies[currency_code],
data['balance'],
data['balance'] - data['freezeBalance'],
data['freezeBalance']
)
def get_deposit_history(self, currency_code):
request = lambda limit, page: self._handle.get_deposits(
currency_code,
limit=limit,
page=page
)
output = []
self._process_paged_request(
request,
lambda entry: output.append(Transfer(
self._currencies[entry['coinType']],
entry['amount'],
entry['outerWalletTxid'], # is this right?
1 if entry['status'] == 'FINISHED' else 0,
0, # cost
entry['status'] == 'CANCEL',
dataparser.parse(str(entry['createdAt']))
))
)
return output
def get_withdrawal_history(self, currency_code):
request = lambda limit, page: self._handle.get_withdrawals(
currency_code,
limit=limit,
page=page
)
output = []
self._process_paged_request(
request,
lambda entry: output.append(Transfer(
self._currencies[entry['coinType']],
entry['amount'],
entry['outerWalletTxid'], # is this right?
0,
entry['fee'],
entry['status'] == 'CANCEL',
dataparser.parse(str(entry['createdAt']))
))
)
return output
def get_open_orders(self):
raise ExchangeAPIException('Not implemented')
def get_order_history(self):
output = []
self._process_paged_request(
self._handle.get_dealt_orders,
lambda entry: output.append(TradeOrder(
data['orderOid'],
self._currencies[base_currency],
self._currencies[market_currency],
None, # Date open
dateparser.parse(str(data['createdAt'])),
data['amount'],
0, # Amount remaining
data['dealPrice'],
data['dealPrice'],
KucoinWrapper.ORDER_TYPE_MAPPINGS[data['direction']]
))
)
return output
def buy(self, base_currency_code, market_currency_code, amount, rate):
symbol = self._make_symbol(base_currency_code, market_currency_code)
result = self._perform_request(lambda: self._handle.create_buy_order(symbol, rate, amount))
return result['orderOid']
def sell(self, base_currency_code, market_currency_code, amount, rate):
symbol = self._make_symbol(base_currency_code, market_currency_code)
result = self._perform_request(lambda: self._handle.create_sell_order(symbol, rate, amount))
return result['orderOid']
def cancel_order(self, base_currency_code, market_currency_code, order_id):
self._perform_request(lambda: self._handle.cancel_order(order_id, None))
def withdraw(self, currency_code, amount, address, address_tag):
if address_tag:
raise ExchangeAPIException('Address tag not supported')
self._perform_request(
lambda: self._handle.create_withdrawal(currency_code, amount, address)
)
def get_deposit_address(self, currency_code):
result = self._perform_request(lambda: self._handle.get_deposit_address(currency_code))
return CryptoAddress(
currency_code,
result['address'],
None
)
def transfers_needs_asset(self):
return True
class KucoinClient(AbstractClient):
def __init__(self, listener):
self.exchange = 'kucoin'
self.trade_fee = Decimal(0.001)
self.client = Client(api_keys.kucoin[0], api_keys.kucoin[1])
super(KucoinClient, self).__init__(listener)
self.get_all_balances()
def _buy(self, symbol, price, amount):
result = self.client.create_buy_order(symbol, price, amount)
self.open_orders[symbol] = [str(result['orderOid']), 'BUY', symbol]
def _sell(self, symbol, price, amount):
result = self.client.create_sell_order(symbol, price, amount)
self.open_orders[symbol] = [str(result['orderOid']), 'SELL', symbol]
def _cancel(self, symbol):
order = self.open_orders.pop(symbol)
self.client.cancel_order(order[0], order[1], symbol=order[2])
time.sleep(1)
if not self.is_order_fulfilled(order[0]):
raise Exception("cancelled order not fulfilled!")
def is_order_fulfilled(self, orderOid):
try:
for data in self.client.get_dealt_orders()['datas']:
if data['orderOid'] == orderOid:
return True
except (KucoinRequestException, KucoinAPIException) as e:
print datetime.now(), "[Kucoin] is order fulfilled error", str(
e).replace('\r\n', '')
self.errors += 1
return False
def get_all_balances(self):
# Kucoin paginates the coin balances and we can only retrieve 20 coins per page
page = 1
while True:
try:
result = self.client.get_all_balances_paged(limit=20,
page=page)
for balance in result['datas']:
self.coin_balances[str(balance['coinType'])] = Decimal(
str(balance['balance'])
) # + Decimal(balance['freezeBalance'])
page = result['currPageNo'] + 1
if page > result['pageNos']:
break
except (KucoinRequestException, KucoinAPIException) as e:
print datetime.now(), "[Kucoin] get all balances error:", str(
e).replace('\r\n', '')
self.errors += 1
break
return self.coin_balances
# Gets the buy/sell price and amount for one symbol at a time (inefficient).
def _market_poll(self):
result = {'success': False}
result['client'] = self
result['timestamp'] = int(time.time() * 1000)
result['coinpairs'] = {}
threads = []
for symbol in self.exchange_symbols:
thread = threading.Thread(target=self._symbol_poll,
args=[symbol, result])
thread.start()
threads.append(thread)
for thread in threads:
thread.join()
if len(result['coinpairs']) > 0:
result['success'] = True
return result
def _symbol_poll(self, symbol, result):
try:
data = self.client.get_order_book(symbol, limit=1)
if data['BUY'] is not None and data['SELL'] is not None:
result['coinpairs'][self._get_arbitrager_coinpair(symbol)] = {
'buy': Decimal(str(data['BUY'][0][0])),
'buyAmount': Decimal(str(data['BUY'][0][1])),
'sell': Decimal(str(data['SELL'][0][0])),
'sellAmount': Decimal(str(data['SELL'][0][1]))
}
except (KucoinRequestException, KucoinAPIException) as e:
print datetime.now(), "[Kucoin] market poll error", str(e).replace(
'\r\n', '')
self.errors += 1
# Gets the buy/sell price for all the symbols with one query but does not contain buy/sell amount (useless).
@DeprecationWarning
def market_poll_no_amount(self):
threading.Timer(Consts.POLL_INTERVAL,
self.market_poll_no_amount).start()
timestamp = int(time.time() * 1000)
try:
coins = self.client.get_trading_symbols()
if self.verbose:
now = int(time.time() * 1000)
print datetime.now(
), "[Kucoin] market_poll took", now - timestamp, "ms."
except (KucoinRequestException, KucoinAPIException) as e:
print datetime.now(), "[Kucoin] market poll error", str(e).replace(
'\r\n', ' ')
result = {'success': False}
result['client'] = self
return result
result = {'success': True}
result['client'] = self
result['timestamp'] = timestamp
result['coinpairs'] = {}
for coin in coins:
symbol = coin['symbol']
if symbol in self.exchange_symbols:
result['coinpairs'][self._get_arbitrager_coinpair(symbol)] = {
'buy': Decimal(str(coin['buy'])),
'sell': Decimal(str(coin['sell']))
}
# result['timestamp'] = coin['datetime']
if self.callback is None:
print result
else:
self.callback(result)
