def from_consumer_and_token(
oauth_consumer,
token=None,
callback=None,
verifier=None,
http_method=HTTP_METHOD,
http_url=None,
parameters=None,
):
if not parameters:
parameters = {}
defaults = {
"oauth_consumer_key": oauth_consumer.key,
"oauth_timestamp": generate_timestamp(),
"oauth_nonce": generate_nonce(),
"oauth_version": OAuthRequest.version,
}
defaults.update(parameters)
parameters = defaults
if token:
parameters["oauth_token"] = token.key
if token.callback:
parameters["oauth_callback"] = token.callback
# 1.0a support for verifier.
if verifier:
parameters["oauth_verifier"] = verifier
elif callback:
# 1.0a support for callback in the request token request.
parameters["oauth_callback"] = callback
return OAuthRequest(http_method, http_url, parameters)
def get_funds(self, logger):
funds = self.ws.funds()
logger.info("Funds: %s" % funds)
self.es.create(index='{}.funds'.format(self.index_prefix),
id=utils.generate_nonce(),
doc_type='funds',
body=funds)
async def on_orderbook_received(self, symbol, orderbook, es):
try:
logging.debug(orderbook)
es.create(index=self.products[symbol]['orderbook'], id=utils.generate_nonce(),
doc_type='orderbook', body=orderbook)
except Exception as e:
logging.warning('{}:{}'.format(str(e), orderbook))
async def on_ticker_received(self, symbol, ticker, es):
try:
logging.debug(ticker)
es.create(index=self.products[symbol]['ticker'], id=utils.generate_nonce(),
doc_type='ticker', body=ticker)
except Exception as e:
logging.warning('{}:{}'.format(str(e), ticker))
def record_ticker(self, es):
"""Record current tick"""
for product in self.products:
es_body=self.get_ticker(product)
if 'price' in es_body:
es.create(index=self.products[product], id=utils.generate_nonce(), doc_type='ticker', body=es_body)
else:
raise ValueError("Misformed Body for Elastic Search on " + self.exchange)
def record_ticker(self, es):
"""Record current tick"""
for product in self.products:
es_body=self.get_ticker(product)
if 'price' in es_body:
es.create(index=self.products[product], id=utils.generate_nonce(), doc_type='ticker', body=es_body)
else:
raise ValueError("Misformed Body for Elastic Search on " + self.exchange)
def generate_server_nonce(self):
self.server_nonce = binascii.hexlify(utils.generate_nonce())
def generate_client_nonce(self):
self.client_nonce = binascii.hexlify(utils.generate_nonce())
def tick(self):
logger = self.setup_logger('ES')
self.running_lock.acquire()
while self.running_lock.locked():
try:
self.current_tick = datetime.now(
pytz.utc).replace(microsecond=0)
if (self.current_tick.second != self.previous_tick.second):
self.data_lock.acquire()
try:
if self.ticker:
ticker = self.ticker.copy()
else:
ticker = None
# if self.trades:
# trades = self.trades.copy()
# else:
# trades = None
if self.instrument:
instrument = self.instrument.copy()
else:
instrument = None
asks = self.asks
bids = self.bids
finally:
self.data_lock.release(
) # release lock, no matter what
if asks is None or bids is None or ticker is None or instrument is None:
continue
logger.info(
'Ticker at timestamp.second {}: \033[94m{}\033[0m'.
format(self.current_tick.second, ticker))
ticker['timestamp'] = self.current_tick
self.es.create(index='{}.tickers'.format(
self.index_prefix),
id=utils.generate_nonce(),
doc_type='ticker',
body=ticker)
instrument['timestamp'] = self.current_tick
self.es.create(index='{}.instrument'.format(
self.index_prefix),
id=utils.generate_nonce(),
doc_type='instrument',
body=instrument)
# Calculate average volume
if instrument['volume'] != self.last_volume:
if instrument['volume'] < self.last_volume:
volume = instrument['volume']
self.last_volume = instrument['volume']
else:
volume = instrument['volume'] - self.last_volume
self.volume_pool.append(self.current_tick)
for timestamp in self.volume_pool:
self.es.create(index='{}.volumes'.format(
self.index_prefix),
id=utils.generate_nonce(),
doc_type='volume',
body={
'timestamp':
timestamp,
'volume':
volume / len(self.volume_pool)
})
self.volume_pool = []
else:
self.volume_pool.append(self.current_tick)
self.last_volume = instrument['volume']
for i in range(-1, -4, -1):
# последовательное уменьшение разрешения, L2->L1->L0
asks_frame = asks[-30 * (-i):]
bids_frame = bids[:30 * (-i)]
body = {
'timestamp': self.current_tick,
'bids': [tuple(x) for x in bids_frame.values],
'asks': [tuple(x) for x in asks_frame.values]
}
self.es.create(index='{}.orderbooks.l{}'.format(
self.index_prefix, -i - 1),
id=utils.generate_nonce(),
doc_type='orderbook',
body=body)
logger.info(
'Orderbook L{} at timestamp.second {}: ask \033[92m{}\033[0m, bid \033[91m{}\033[0m'
.format(-i - 1, self.current_tick.second,
body['asks'][-1], body['bids'][0]))
if self.current_tick.second % (10**(-i)) != 0:
break
bids['price'] = bids['price'].round(i)
asks['price'] = asks['price'].round(i)
asks = asks.groupby(['price']).agg({
'size': np.sum
}).reset_index()
bids = bids.groupby(['price']).agg({
'size': np.sum
}).reset_index()
self.previous_tick = self.current_tick
except:
logger.error('\033[91m{}\033[0m'.format(
traceback.format_exc()))
try:
self.setup_es()
except:
logger.error('Reloading ES')
