def start_trader(ready_queue=None):
print('start trader', datetime.now())
market_code = []
kosdaq_code = morning_client.get_market_code()
kospi_code = morning_client.get_market_code(message.KOSPI)
market_code.extend(kosdaq_code)
market_code.extend(kospi_code)
market_code = list(dict.fromkeys(market_code))
market_code = list(
filter(lambda x: len(x) > 0 and x[1:].isdigit(), market_code))
yesterday_list = get_yesterday_data(datetime.now(), market_code)
yesterday_list = sorted(yesterday_list,
key=lambda x: x['amount'],
reverse=True)
yesterday_list = yesterday_list[:1000]
for yesterday_data in yesterday_list:
code = yesterday_data['code']
sf = StockFollower(morning_client.get_reader(), code, yesterday_data,
code in kospi_code)
sf.subscribe_at_startup()
followers.append(sf)
stock_api.subscribe_alarm(morning_client.get_reader(), vi_handler)
stock_api.subscribe_trade(morning_client.get_reader(), receive_result)
if ready_queue is not None:
ready_queue.put_nowait([yl['code'] for yl in yesterday_list])
gevent.joinall([gevent.spawn(heart_beat), gevent.spawn(data_process)])
def start_vi_follower():
global db_collection
slack.send_slack_message('START VI FOLLOWER')
db_collection = MongoClient(db.HOME_MONGO_ADDRESS).trade_alarm
market_code = morning_client.get_all_market_code()
for m in market_code: # for caching company name in server
morning_client.code_to_name(m)
yesterday = holidays.get_yesterday(datetime.now())
yesterday_date = yesterday.year * 10000 + yesterday.month * 100 + yesterday.day
ydata = list(db_collection['yamount'].find({'date': yesterday_date}))
if len(ydata) == 0:
yesterday_list = get_day_data(yesterday, market_code)
yesterday_list = sorted(yesterday_list,
key=lambda x: x['amount'],
reverse=True)
yesterday_list = yesterday_list[:1000]
codes = [c['code'] for c in yesterday_list]
db_collection['yamount'].insert_one({
'date': yesterday_list[0]['0'],
'codes': codes
})
else:
codes = ydata[0]['codes']
if len(codes) == 0:
print('Critical Error, No CODES')
sys.exit(0)
followers = []
for code in codes:
sf = stock_follower.StockFollower(morning_client.get_reader(),
db_collection, code)
sf.subscribe_at_startup()
followers.append(sf)
kosdaq_index = stock_follower.StockFollower(morning_client.get_reader(),
db_collection, 'U201')
kosdaq_index.subscribe_at_startup()
followers.append(kosdaq_index)
kospi_index = stock_follower.StockFollower(morning_client.get_reader(),
db_collection, 'U001')
kospi_index.subscribe_at_startup()
followers.append(kospi_index)
print('Start Listening...')
slack.send_slack_message('START LISTENING')
stock_api.subscribe_alarm(morning_client.get_reader(), vi_handler)
time_check_thread = gevent.spawn(check_time)
today_bull_record_thread = gevent.spawn(today_bull_record)
gevent.joinall([time_check_thread, today_bull_record_thread])
def start_by_excel(market_code):
alarm_datas = read_kosdaq_vi_excel(morning_client.get_reader(),
market_code)
success = 0
fail = 0
holding = 0
all_count = 0
for adata in alarm_datas:
code_dict = dict()
for code in market_code:
code_dict[code] = {
'state': STATE_NONE,
'yesterday_data': None,
'today_min_data': None,
'today_min_after_vi': None,
'vi_highest': 0,
'bottom_price': 0,
'buy_price': 0,
'target_gap': 0
}
target_date = adata['date']
alarm_data = adata['alarm_list']
s, f, h, a = iterate_alarm_data(alarm_data, code_dict, target_date)
success += s
fail += f
holding += h
all_count += a
print('SUCCESS', success, 'FAIL', fail, 'HOLDIONG', holding, 'ALL',
all_count)
def OrderStock(self, request, context):
ret = stock_api.order_stock(morning_client.get_reader(), request.code,
request.price, request.quantity,
request.is_buy)
_LOGGER.info('OrderStock %s, RET: %s', request, ret)
return stock_provider_pb2.CybosOrderReturn(result=ret['status'],
msg=ret['msg'])
def RequestCybosTickData(self, request, context):
global is_subscribe_tick
if request.code not in is_subscribe_tick:
stock_api.subscribe_stock(morning_client.get_reader(),
request.code, self.handle_stock_tick)
_LOGGER.info('Start SubscribeStock %s', request.code)
is_subscribe_tick[request.code] = True
else:
_LOGGER.info('Already SubscribeStock %s', request.code)
return Empty()
def RequestCybosTradeResult(self, request, context):
global is_subscribe_trade
if not is_subscribe_trade:
_LOGGER.info('Start Trade Result')
stock_api.subscribe_trade(morning_client.get_reader(),
self.handle_trade_result)
is_subscribe_trade = True
else:
_LOGGER.info('Already subscribe trade')
return Empty()
def RequestCybosAlarm(self, request, context):
global is_subscribe_alarm
if not is_subscribe_alarm:
stock_api.subscribe_alarm(morning_client.get_reader(),
self.handle_alarm_tick)
_LOGGER.info('Start Subscribe alarm')
is_subscribe_alarm = True
else:
_LOGGER.info('Already subscribe alarm')
return Empty()
def start_watch():
global subscribe_code
while True:
msg = tasks.get().split(':')
if msg[0] == 'alarm':
code = msg[1]
if code in subscribe_code:
pass
else:
if code in yesterday_data:
sf = stock_follower.StockFollower(morning_client.get_reader(), db_collection, code, yesterday_data[code])
else:
sf = stock_follower.StockFollower(morning_client.get_reader(), db_collection, code, None)
if sf.start_watch():
subscribe_code[code] = sf
else:
print('Failed to watch', code)
elif msg[0] == 'exit':
break
def CancelOrder(self, request, context):
try:
order_num = int(request.order_num)
ret = stock_api.cancel_order(morning_client.get_reader(),
order_num, request.code,
request.quantity)
_LOGGER.info('CancelOrder %s RET: %s', request, ret)
except ValueError as ve:
_LOGGER.warning('ValueError %s', ve)
return stock_provider_pb2.CybosOrderReturn(result=['result'],
msg='Value Error ' +
request.order_num)
return stock_provider_pb2.CybosOrderReturn(result=ret['result'])
def start_vi_follower():
global db_collection
market_code = morning_client.get_market_code()
today = datetime.now().date()
#if holidays.is_holidays(today):
# print('today is holiday')
# sys.exit(1)
yesterday = holidays.get_yesterday(today)
db_collection = MongoClient(db.HOME_MONGO_ADDRESS).trade_alarm
yesterday_list = []
for progress, code in enumerate(market_code):
print('collect yesterday data', f'{progress+1}/{len(market_code)}', end='\r')
data = morning_client.get_past_day_data(code, yesterday, yesterday)
if len(data) == 1:
data = data[0]
data['code'] = code
yesterday_data[code] = data
yesterday_list.append(data)
print('')
yesterday_list = sorted(yesterday_list, key=lambda x: x['amount'], reverse=True)
yesterday_list = yesterday_list[:100]
for ydata in yesterday_list:
code = ydata['code']
sf = stock_follower.StockFollower(morning_client.get_reader(), db_collection, code, yesterday_data[code])
sf.subscribe_at_startup()
subscribe_code[code] = sf
print('Start Listening...')
stock_api.subscribe_alarm(morning_client.get_reader(), vi_handler)
watch_thread = gevent.spawn(start_watch)
gevent.joinall([watch_thread])
def ChangeOrder(self, request, context):
try:
order_num = int(request.order_num)
ret = stock_api.modify_order(morning_client.get_reader(),
order_num, request.code,
request.price)
_LOGGER.info('ChangeOrder %s, RET: %s', request, ret)
except ValueError as ve:
_LOGGER.warning('ValueError %s', ve)
return stock_provider_pb2.CybosOrderReturn(order_num=0,
msg='Value Error ' +
str(request.order_num))
return stock_provider_pb2.CybosOrderReturn(
order_num=ret['order_number'])
from configs import db
from pymongo import MongoClient
from morning.pipeline.converter import dt
import numpy as np
from scipy.signal import find_peaks, peak_prominences
import pandas as pd
def wait_loop():
while True:
gevent.sleep(0.03)
def tick_data_handler(code, data):
if len(data) != 1:
return
print(data[0])
market_code = morning_client.get_market_code() # KOSDAQ
kospi_market_code = morning_client.get_market_code(message.KOSPI)
market_code.extend(kospi_market_code)
print('all', len(market_code))
for code in market_code:
stock_api.subscribe_stock(morning_client.get_reader(), code,
tick_data_handler)
gevent.joinall([gevent.spawn(wait_loop)])
