async def get_ticks(self):
ticks = pd.DataFrame(data=[], columns=formats.tick)
try:
request_url = 'public/Ticker'
stock_data = await self.rest_send(
request_url,
params={'pair':','.join(
self._get_markets().index.values.tolist())},)
current_date = datetime.datetime.now()
for market_name in stock_data['result'].keys():
market = self._get_markets().loc[market_name]
ticks = ticks.append(pd.Series(
data=[
self.name,
int(time.mktime(current_date.timetuple()))*1000,
'_'.join([market.at['base'], market.at['quot']]),
stock_data['result'][market_name]['c'][0],],
index=formats.tick,
name=current_date,))
Logger.log_info(ticks)
except Exception as e:
Logger.log_error(e)
finally:
return ticks
def __assume_tick(self, tick_data):
tick = None
try:
market = self._get_markets().loc[tick_data['params']['symbol']]
tick = pd.Series(
data=[
self.name,
int(
datetime.datetime.strptime(
tick_data['params']['timestamp'].split('.')[0],
'%Y-%m-%dT%H:%M:%S',
).timestamp() * 1000),
'_'.join([market.at['base'].lower(), market.at['quot']]),
tick_data['params']['last'],
],
index=formats.tick,
name=datetime.datetime.now(),
)
except Exception as e:
Logger.log_info(tick_data['params']['timestamp'].split('.')[0])
Logger.log_error(e)
finally:
return tick
async def get_ticks(self):
ticks = pd.DataFrame(data=[], columns=formats.tick)
try:
request_url = 'pairs'
stock_data = await self.rest_send(request_url)
current_date = datetime.datetime.now()
for market in stock_data['data']:
if market['last_price'] is not None:
ticks = ticks.append(
pd.Series(
data=[
self.name,
int(time.mktime(current_date.timetuple())) *
1000,
'_'.join([
market['base']['name'].lower(),
market['quote']['name'].lower()
]),
market['last_price'],
],
index=formats.tick,
name=current_date,
))
Logger.log_info(ticks)
except Exception as e:
Logger.log_error(e)
finally:
return ticks
async def get_ticks(self):
ticks = pd.DataFrame(data=[], columns=formats.tick)
try:
request_url = 'ticker.do'
stock_data = await self.rest_send(request_url, params={
'symbol': 'all'})
current_date = datetime.datetime.now()
for market in stock_data:
ticks = ticks.append(pd.Series(
data=[
self.name,
int(time.mktime(current_date.timetuple()))*1000,
market['symbol'],
market['ticker']['latest'],],
index=formats.tick,
name=current_date,))
Logger.log_info(ticks)
except Exception as e:
Logger.log_error(e)
finally:
return ticks
async def get_ticks(self):
ticks = pd.DataFrame(data=[], columns=formats.tick)
try:
request_url = 'ticker_utc'
stock_data = await self.rest_send(request_url,
params={
'currency': 'all',
'format': 'json',
})
current_date = datetime.datetime.now()
for market_name in stock_data.keys():
if isinstance(stock_data[market_name], dict):
ticks = ticks.append(
pd.Series(
data=[
self.name,
int(time.mktime(current_date.timetuple())) *
1000,
'_'.join([market_name, 'krw']),
stock_data[market_name]['last'],
],
index=formats.tick,
name=current_date,
))
Logger.log_info(ticks)
except Exception as e:
Logger.log_error(e)
finally:
return ticks
def __assume_tick(self, message):
tick = None
try:
current_date = datetime.datetime.now()
tick = pd.Series(
data=[
self.name,
int(time.mktime(current_date.timetuple())) * 1000,
'_'.join([
message['data']['symbol1'].lower(),
message['data']['symbol2'].lower(),
]),
message['data']['price'],
],
index=formats.tick,
name=current_date,
)
Logger.log_info(tick)
except Exception as e:
Logger.log_error(e)
finally:
return tick
async def get_ticks(self):
ticks = pd.DataFrame(data=[], columns=formats.tick)
try:
request_url = 'tickerall'
stock_data = await self.rest_send(request_url)
current_date = datetime.datetime.now()
for market_name in stock_data['data'].keys():
ticks = ticks.append(
pd.Series(
data=[
self.name,
int(time.mktime(current_date.timetuple())) * 1000,
market_name,
stock_data['data'][market_name]['last'],
],
index=formats.tick,
name=current_date,
))
Logger.log_info(ticks)
except Exception as e:
Logger.log_error(e)
finally:
return ticks
async def get_ticks(self):
ticks = pd.DataFrame(data=[], columns=formats.tick)
try:
request_url = 'v1/mdata'
stock_data = await self.rest_send(
request_url,
params={
'cmd': 'marketAll',
},
)
current_date = datetime.datetime.now()
for market_data in stock_data['result']:
market = self._get_markets().loc[market_data['id']]
ticks = ticks.append(
pd.Series(
data=[
self.name,
int(time.mktime(current_date.timetuple())) * 1000,
'_'.join([market.at['base'], market.at['quot']]),
market_data['last'],
],
index=formats.tick,
name=current_date,
))
Logger.log_info(ticks)
except Exception as e:
Logger.log_error(e)
finally:
return ticks
async def get_ticks(self):
ticks = pd.DataFrame(data=[], columns=formats.tick)
try:
request_url = 'Api_Market/getPriceList'
stock_data = await self.rest_send(request_url)
current_date = datetime.datetime.now()
for quot_name in stock_data.keys():
for market in stock_data[quot_name]:
ticks = ticks.append(
pd.Series(
data=[
self.name,
int(time.mktime(current_date.timetuple())) *
1000,
'_'.join(
[market['coin_from'], market['coin_to']]),
market['current'],
],
index=formats.tick,
name=current_date,
))
Logger.log_info(ticks)
except Exception as e:
Logger.log_error(e)
finally:
return ticks
def wrapped(*args, **kwargs):
Logger.log_info('in wrapped')
bad_args = []
args_start = 1 if hasattr(method, '__self__') else 0
if len(v_args) > args_start:
for idx in range(args_start, len(args)):
if idx < len(v_args) and v_args[idx] is not None:
if inspect.isfunction(v_args[idx]):
if not v_args[idx](args[idx]):
bad_args.append(idx)
elif not isinstance(args[idx], v_args[idx]):
bad_args.append(idx)
bad_kwargs = []
if len(v_kwargs) > 0:
for key in kwargs.keys():
if key in v_kwargs and v_kwargs[key] is not None:
if inspect.isfunction(v_kwargs[key]):
if not v_kwargs[key](kwargs[key]):
bad_kwargs.append(key)
elif not isinstance(kwargs[key], v_kwargs[key]):
bad_kwargs.append(key)
if len(bad_args) > 0 or len(bad_kwargs):
raise Warning(*[str(bad_args) + ' | ' + str(bad_kwargs)] * 2)
method_result = None
if inspect.iscoroutinefunction(method):
method_result = yield from method(*args, **kwargs)
else:
method_result = method(*args, **kwargs)
return method_result
def __pass(method):
Logger.log_info('pass')
def wrapped(*args, **kwargs):
Logger.log_info('pass wrap')
Logger.log_info(inspect.getsource(method))
return method(*args, **kwargs)
return wrapped
async def on_data(self, data):
if data.get('type', None) is not None:
Logger.log_info('message out')
Logger.log_info(data)
data = utils.stringify_data(data)
if isinstance(self.__websocket, web.WebSocketResponse):
await self.__websocket.send_str(data)
else:
await self.__websocket.send(data)
async def execute(self, action, *args, **kwargs):
result = None
try:
nonce = utils.get_nonce()
Logger.log_info('execute')
Logger.log_info(nonce)
self.__await_events[nonce] = asyncio.Event()
await self.push({
'type':'service',
'id': nonce,
'action':action,
'args':args,
'kwargs':kwargs,})
await self.__await_events[nonce].wait()
Logger.log_info('executed')
result = self.__events_results[nonce]
Logger.log_info(result)
del self.__events_results[nonce]
del self.__await_events[nonce]
except Exception as e:
Logger.log_error(e)
finally:
return result
def write_events_to_blob(blob_name, events: List[Event], currency_markup: MarkupCurrency,
timestamp: datetime.datetime,
logger: Logger):
first_read = False
logger.log_info("Write events to %s" % blob_name)
content = ["[\n"]
for event in events:
event = post_process_event(event, logger, currency_markup, timestamp)
if first_read:
content.append(",\n")
else:
first_read = True
content.append(json.dumps(event.to_json(), ensure_ascii=False, indent=4))
content.append('\n]')
content = "".join(content)
service.upload_blob(blob_name, content)
def __assume_tick(self, tick_data):
tick = None
try:
market = self._get_channel_market(tick_data['ch'])
tick = pd.Series(
data=[
self.name,
tick_data['ts'],
'_'.join([market.at['base'], market.at['quot']]),
tick_data['tick']['close'],
],
index=formats.tick,
name=datetime.datetime.now(),
)
Logger.log_info(tick)
except Exception as e:
Logger.log_error(e)
finally:
return tick
async def _data_recieved(self, data):
try:
action_result = await self.__assume_action(data)
if data.get('type', None) == 'service':
Logger.log_info('data_recieved')
Logger.log_info(self.__await_events.keys())
if action_result is not None:
await self.push(data=action_result)
elif (isinstance(data, dict)
and data.get('type', None) == 'service'
and data['id'] in self.__await_events.keys()):
pd_item = utils.dict_to_pandas(
data['action_result'])
result = (pd_item if pd_item is not None
else data['action_result'])
self.__events_results[data['id']] = result
self.__await_events[data['id']].set()
else:
await self.on_data(data)
except Exception as e:
Logger.log_error(e)
async def get(self):
ctx = decimal.Context()
ctx.prec = 10
exchanges_socket = Buffer('exchanges').connect()
price_frame_view = await exchanges_socket.execute(
'exchanges.get_price_frame')
Logger.log_info('price_frame recieved')
Logger.log_info(price_frame_view)
await exchanges_socket.close()
price_frame_view = price_frame_view.dropna()
price_frame_view['gap'] = (
price_frame_view.loc[:, 'gateio'].astype('float64') -
price_frame_view.loc[:, 'hitbtc'].astype('float64')).abs()
price_frame_view = price_frame_view.sort_values(by='gap',
ascending=False)
price_frame_view['gap'] = price_frame_view['gap'].apply(
lambda x: format(ctx.create_decimal(repr(x)), 'f'))
return {'grid': utils.pandas_to_dict(price_frame_view)}
async def get_ticks(self):
ticks = pd.DataFrame(data=[], columns=formats.tick)
try:
current_idx = 0
markets = self._get_markets()
while current_idx < self._get_markets().shape[0]:
to_idx = current_idx + 30
request_url = '3/ticker/%s' % ('-'.join([
mkt for mkt in markets.index.values.tolist()
[current_idx:to_idx]
]))
stock_data = await self.rest_send(request_url,
params={'ignore_invalid': 1})
current_date = datetime.datetime.now()
for market_name in stock_data.keys():
market = self._get_markets().loc[market_name]
ticks = ticks.append(
pd.Series(
data=[
self.name,
int(time.mktime(current_date.timetuple())) *
1000,
'_'.join(
[market.at['base'], market.at['quot']]),
stock_data[market_name]['last'],
],
index=formats.tick,
name=current_date,
))
current_idx = to_idx
Logger.log_info(ticks)
except Exception as e:
Logger.log_error(e)
finally:
return ticks
async def __assume_tick_package(self, message):
tick_package = pd.DataFrame (data=[], columns=formats.tick)
try:
tick_package_data = self.__decompress_data(message['A'][0])
for tick_data in tick_package_data['D']:
tick = self.__assume_tick(tick_data)
if tick is not None:
tick_package = tick_package.append(tick)
Logger.log_info(tick_package)
except Exception as e:
Logger.log_error(e)
finally:
if tick_package.shape[0] == 0:
tick_package = None
elif tick_package.shape[0] == 1:
tick_package = tick_package.iloc[0]
return tick_package
def __assume_tick(self, message):
tick = None
try:
current_date = datetime.datetime.now()
market = self._get_markets().loc[message['product_id'].lower()]
tick = pd.Series(
data=[
self.name,
int(time.mktime(current_date.timetuple())) * 1000,
'_'.join([market.at['base'], market.at['quot']]),
message['price'],
],
index=formats.tick,
name=current_date,
)
Logger.log_info(tick)
except Exception as e:
Logger.log_error(e)
finally:
return tick
def __assume_tick(self, tick_data):
tick = None
try:
current_date = datetime.datetime.now()
market = self._get_markets().loc[tick_data['channel'].split('_')
[0]]
tick = pd.Series(
data=[
self.name,
int(time.mktime(current_date.timetuple())) * 1000,
'_'.join([market.at['base'], market.at['quot']]),
tick_data['ticker']['last'],
],
index=formats.tick,
name=current_date,
)
Logger.log_info(tick)
except Exception as e:
Logger.log_error(e)
finally:
return tick
async def get_ticks(self):
ticks = pd.DataFrame(data=[], columns=formats.tick)
try:
request_url = 'open/tick'
stock_data = await self.rest_send(request_url)
current_date = datetime.datetime.now()
for market in stock_data['data']:
ticks = ticks.append(pd.Series(
data=[
self.name,
int(time.mktime(current_date.timetuple()))*1000,
market['symbol'].replace('-', '_').lower(),
market['lastDealPrice'],],
index=formats.tick,
name=current_date,))
Logger.log_info(ticks)
except Exception as e:
Logger.log_error(e)
finally:
return ticks
async def get_ticks(self):
ticks = pd.DataFrame(data=[], columns=formats.tick)
try:
request_url = 'public/ticker/all'
stock_data = await self.rest_send(request_url)
current_date = datetime.datetime.now()
for base_name in stock_data['data'].keys():
if isinstance(stock_data['data'][base_name], dict):
tick = pd.Series(
data=[
self.name,
int(time.mktime(current_date.timetuple())) * 1000,
'_'.join([base_name.lower(), 'krw']),
stock_data['data'][base_name]['closing_price'],
],
index=formats.tick,
name=current_date,
)
ticks = ticks.append(tick)
if self.__currency_rate is not None:
usd_tick = tick.copy()
usd_tick.at['market'] = '%s_usd' % (base_name.lower())
usd_tick.at['price'] = round(
(float(usd_tick.at['price']) *
self.__currency_rate), 2)
ticks = ticks.append(usd_tick)
Logger.log_info(ticks)
except Exception as e:
Logger.log_error(e)
finally:
return ticks
async def get_ticks(self):
ticks = pd.DataFrame(data=[], columns=formats.tick)
try:
request_url = 'market/ticker'
stock_data = await self.rest_send(request_url,
params={'symbol': 'all'})
current_date = datetime.datetime.now()
for market in stock_data['ticker']:
base = None
quot = None
if market['symbol'][-3:] in ('BTC', 'ETH'):
quot = market['symbol'][-3:].lower()
base = market['symbol'][:-3].lower()
else:
quot = market['symbol'][-4:].lower()
base = market['symbol'][:-4].lower()
ticks = ticks.append(
pd.Series(
data=[
self.name,
int(time.mktime(current_date.timetuple())) * 1000,
'_'.join([base, quot]),
market['last'],
],
index=formats.tick,
name=current_date,
))
Logger.log_info(ticks)
except Exception as e:
Logger.log_error(e)
finally:
return ticks
async def listen(self):
try:
async for message in self.__websocket:
if isinstance(self.__websocket, web.WebSocketResponse):
if message.type == WSMsgType.TEXT:
if message.data == 'close':
message = None
else:
message = message.data
elif msg.type == WSMsgType.ERROR:
message = None
if message is not None:
message = utils.parse_data(message)
if message.get('type', None) is not None:
Logger.log_info('message')
Logger.log_info(message)
if (message.get('type', None) == 'service'
and message.get('action', None) is not None):
Logger.log_info('action accepted, trying to pass')
result = await self.execute(
message.get('action', None),
*message.get('args', []),
**message.get('kwargs', {}),)
response = {
'type':'service',
'id':message['id'],
'action_result':utils.pandas_to_dict(result),}
Logger.log_info('action resolved, trying to response')
await self.on_data(response)
else:
await self.push(message)
except Exception as e:
Logger.log_error(e)
finally:
await self.close()
async def __assume_action(self, data):
response = None
try:
if (self.owner is not None
and data.get('type', None) == 'service'
and data.get('action', None) is not None
and data['action'].split('.')[0] == self.owner.name):
if not hasattr(self.owner, data['action'].split('.')[1]):
raise Warning('%s have not action %s'%(
data['action'].split('.')[0],
data['action'].split('.')[1],))
Logger.log_info('accepted_action')
action = getattr(self.owner, data['action'].split('.')[1])
if inspect.iscoroutinefunction(action):
action_result = await action(
*data.get('args', []),
**data.get('kwargs', {}),)
elif inspect.ismethod(action):
action_result = action(
*data.get('args', []),
**data.get('kwargs', {}),)
else:
action_result = action
Logger.log_info('action produced')
response = {
'type':'service',
'id':data['id'],
'action_result':action_result,}
Logger.log_info(response)
except Exception as e:
response = {
'type':'service',
'id':data['id'],
'action_result':{'error':str(e)},}
finally:
return response
