def _correct_date(d, now):
if d > now.date():
d = now.date()
if is_holidays(d):
d = get_yesterday(d)
if d == now.date() and now.hour < 18:
d = get_yesterday(d)
return d
def start_today_trading(reader, market_code, today, choosers):
code_dict = dict()
yesterday = holidays.get_yesterday(today)
for progress, code in enumerate(market_code):
print('collect past data',
today,
f'{progress+1}/{len(market_code)}',
end='\r')
past_data = get_past_data(reader, code,
yesterday - timedelta(days=MAVG * 3),
yesterday)
if len(past_data) == 0:
continue
past_data = convert_data_readable(code, past_data)
yesterday_data = past_data[-1]
code_dict[code] = {'past_data': past_data}
print('')
for c in choosers:
new_code_dict = dict()
result = c(reader, today, code_dict)
for r in result:
new_code_dict[r] = code_dict[r]
code_dict = new_code_dict
return list(code_dict.keys())
def get_past_datas(code, today, t, code_dict):
yesterday = holidays.get_yesterday(today)
data = morning_client.get_past_day_data(code, yesterday, yesterday)
if len(data) != 1:
print('Cannot get yesterday data', code, yesterday)
return
code_dict[code]['yesterday_data'] = data[0]
min_data = morning_client.get_minute_data(code, today, today)
hour = int(t / 10000)
minute = int((t % 10000) / 100)
vi_datetime = datetime.combine(today, time(hour, minute))
before_vi_datetime = vi_datetime - timedelta(seconds=60)
after_vi_datetime = vi_datetime + timedelta(seconds=120)
before_datas = []
after_datas = []
for mdata in min_data:
if mdata[
'time'] <= before_vi_datetime.hour * 100 + before_vi_datetime.minute:
before_datas.append(mdata)
elif mdata[
'time'] >= after_vi_datetime.hour * 100 + after_vi_datetime.minute:
after_datas.append(mdata)
code_dict[code]['today_min_data'] = before_datas
code_dict[code]['today_min_after_vi'] = after_datas[:-1]
for mdata in code_dict[code]['today_min_data']:
if mdata['highest_price'] > code_dict[code]['vi_highest']:
code_dict[code]['vi_highest'] = mdata['highest_price']
"""
def GetPastMinuteData(self, request, context):
_LOGGER.info('GetPastMinuteData %s', request)
today = request.today.ToDatetime()
yesterday = holidays.get_yesterday(today)
from_date = holidays.get_date_by_previous_working_day_count(
yesterday, request.count_of_days - 1)
minute_datas = morning_client.get_minute_data(request.code, from_date,
yesterday)
protoc_converted = []
for m in minute_datas:
protoc_converted.append(
stock_provider_pb2.CybosDayData(
date=m['0'],
time=m['time'],
start_price=int(m['start_price']),
highest_price=int(m['highest_price']),
lowest_price=int(m['lowest_price']),
close_price=int(m['close_price']),
volume=m['volume'],
amount=m['amount'],
cum_sell_volume=m['cum_sell_volume'],
cum_buy_volume=m['cum_buy_volume'],
foreigner_hold_volume=m['foreigner_hold_volume'],
foreigner_hold_rate=m['foreigner_hold_rate'],
institution_buy_volume=m['institution_buy_volume'],
institution_cum_buy_volume=m['institution_cum_buy_volume'])
)
return stock_provider_pb2.CybosDayDatas(day_data=protoc_converted)
def start_validation(codes=[]):
global db_collection
send_slack_message('START VALIDATION')
if len(codes) > 0:
market_code = codes
else:
market_code = morning_client.get_all_market_code()
today = datetime.now().date()
yesterday = holidays.get_yesterday(today)
db_collection = MongoClient(db.HOME_MONGO_ADDRESS).trade_alarm
failed_tick_codes = []
for code in market_code:
if not validate_tick_data(code, today):
failed_tick_codes.append(code)
if len(failed_tick_codes) > 0:
send_slack_message('FAILED TICK ' + str(len(failed_tick_codes)) + '/' +
str(len(market_code)))
print('FAILED TICK', len(failed_tick_codes), len(market_code))
else:
send_slack_message('TICK ALL SUCCESS')
print('TICK ALL SUCCESS')
sys.exit(0)
def _search_day_data(self, codes):
yesterday = get_yesterday(self.from_date)
print('yesterday', yesterday)
self.codes = self._search_from_database(yesterday, self.max_count,
self.institution_buy_days)
if len(self.codes):
print('found pass')
pass
else:
datas = []
for code in codes:
data = get_day_period_data(code, yesterday, yesterday)
if len(data) > 0:
data[0]['code'] = code
datas.append(data[0])
datas = sorted(datas, key=lambda i: i['7'], reverse=True)
self.codes = [d['code'] for d in datas]
if self.institution_buy_days > 0:
self._filter_consecutive_buy_days(yesterday)
self.codes = self.codes[:self.max_count]
db_insert_data = {
'date': datetime(yesterday.year, yesterday.month,
yesterday.day),
'count': self.max_count,
'institution_buy_days': self.institution_buy_days
}
for i, code in enumerate(self.codes):
db_insert_data[str(i)] = code
self.stock[self.code_bull_name].insert_one(db_insert_data)
print('OK insert')
def load_data(self, code, target_date):
yesterday = holidays.get_yesterday(target_date)
print('target_date', target_date, 'yesterday', yesterday)
yesterday_min_data = stock_api.request_stock_minute_data(message_reader, code, yesterday, yesterday)
if len(yesterday_min_data) <= 10:
print('NO or LESS YESTERDAY MIN DATA', code, yesterday)
return
today_min_data = stock_api.request_stock_minute_data(message_reader, code, target_date, target_date)
if len(today_min_data) <= 10:
print('NO or LESS TODAY MIN DATA', code, target_date)
return
past_datas = stock_api.request_stock_day_data(message_reader, code, yesterday - timedelta(days=30), yesterday)
if len(past_datas) <= 10:
print('NO or LESS PAST DATA', code, yesterday - timedelta(days=30), yesterday)
return
self.yesterday = yesterday
self.today = target_date
vol = 0
for d in past_datas:
vol += d['6']
self.volume_average = int(vol / len(past_datas))
self.clear_datas()
yesterday_min_close = yesterday_min_data[-1]['5']
self.price_range[0] = yesterday_min_close - int(yesterday_min_close * 0.1)
self.price_range[1] = yesterday_min_close + int(yesterday_min_close * 0.1)
for ym in yesterday_min_data:
if ym['4'] < self.price_range[0]:
self.price_range[0] = ym['4']
if ym['3'] > self.price_range[1]:
self.price_range[1] = ym['3']
self.yesterday_min_data_c.append(dt.cybos_stock_day_tick_convert(ym))
for tm in today_min_data:
if tm['4'] < self.price_range[0]:
self.price_range[0] = tm['4']
if tm['3'] > self.price_range[1]:
self.price_range[1] = tm['3']
self.today_min_data_c.append(dt.cybos_stock_day_tick_convert(tm))
self.calc_moving_average(self.yesterday_min_data_c, self.today_min_data_c)
ef = edgefinder.EdgeFinder(self.moving_average)
self.edges.extend(ef.get_peaks(True))
self.edges.extend(ef.get_peaks(False))
self.edges = sorted(self.edges, key=lambda x: x[0])
yesterday_average = self.create_average_data(yesterday, self.yesterday_min_data_c)
today_average = self.create_average_data(target_date, self.today_min_data_c)
self.average_data.extend(yesterday_average)
self.average_data.extend(today_average)
self.up_to = datetime.combine(yesterday, time(12))
self.set_figure_data(self.up_to)
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_today_trading(reader, market_code, today):
for code in market_code:
data = get_past_data(reader, code, holidays.get_yesterday(today), today)
data = convert_data_readable(code, data)
if len(data) != 1:
#print('no data')
continue
data = data[0]
state = code_dict[code]['state']
if state == STATE_NONE:
profit = (data['close_price'] - data['start_price']) / data['start_price'] * 100
if profit > 10:
past_data = get_past_data(reader, code, today - timedelta(days=12), holidays.get_yesterday(today))
past_data = convert_data_readable(code, past_data)
if len(past_data) < 5:
print(today, 'short data')
continue
past_data = past_data[-5:]
past_profits = [abs((d['close_price'] - d['yesterday_close']) / d['yesterday_close'] * 100) <= 3. for d in past_data]
max_amount = max([d['amount'] for d in past_data])
if all(past_profits) and data['amount'] > max_amount * 2 and data['amount'] > 1000000000:
code_dict[code]['state'] = STATE_BULL
code_dict[code]['count'] = 0
code_dict[code]['bull_profit'] = profit
print_code_dict(code, today)
elif state == STATE_BULL:
code_dict[code]['count'] += 1
if code_dict[code]['count'] >= 3:
future_data = get_past_data(reader, code, today, today + timedelta(days=15))
future_data = convert_data_readable(code, future_data)
is_success = False
for f in future_data:
if (f['close_price'] - f['yesterday_close']) / f['yesterday_close'] * 100 > 5:
is_success = True
break
print(today, code, ('SUCCESS' if is_success else 'failed'))
code_dict[code]['state'] = STATE_NONE
elif abs((data['close_price'] - data['yesterday_close']) / data['yesterday_close'] * 100) > 3:
code_dict[code]['state'] = STATE_NONE
def get_yesterday_data(today, market_code):
yesterday = holidays.get_yesterday(today)
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_list.append(data)
print('')
return yesterday_list
def get_yesterday_top_amount(dt):
if dt.hour >= 18:
tday = dt
today_date = tday.year * 10000 + tday.month * 100 + tday.day
codes = stock_api.request_yesterday_top_amount(get_reader(),
today_date)
if len(codes) > 0:
return codes, True, today_date
yday = holidays.get_yesterday(dt)
yesterday_date = yday.year * 10000 + yday.month * 100 + yday.day
codes = stock_api.request_yesterday_top_amount(get_reader(),
yesterday_date)
return codes, False, yesterday_date
def info_changed(self, code, d):
if holidays.is_holidays(d):
from PyQt5.QtWidgets import QMessageBox
QMessageBox.warning(self.get_figure(), 'Not available', 'Holiday')
if self.current_code == code and self.current_dt == d:
return
self.current_code = code
self.current_dt = d
if len(code) == 0:
self.codes = code_chooser.get_candidate_code(message.KOSDAQ, holidays.get_yesterday(d), message_reader)
self.current_code = random.choice(self.codes)
if len(self.current_code) > 0:
self.load_data(self.current_code, d)
def start_trading(tdate, codes):
print('Start', tdate, len(codes))
yesterday = holidays.get_yesterday(tdate)
start_time = datetime.now()
yesterday_uni_data = get_yesterday_uni_day_data(yesterday, codes)
print('Uni data count', len(yesterday_uni_data))
yesterday_uni_data = sorted(yesterday_uni_data,
key=lambda x: x['market_close_profit'],
reverse=True)
codes = [d['code'] for d in yesterday_uni_data]
yesterday_dict = get_yesterday_day_data(yesterday, codes)
result = []
for ud in yesterday_uni_data:
tdata = morning_client.get_minute_data(ud['code'], tdate, tdate)
highest = 0
amount = 0
highest_time = None
open_price = 0
for d in tdata:
if open_price == 0:
open_price = d['start_price']
if d['time'] > 931:
break
if d['highest_price'] > highest:
highest = d['highest_price']
highest_time = d['time']
amount += d['amount']
if highest_time is not None:
if ud['market_close'] == 0:
print('close 0', ud)
continue
ud['date'] = d['0']
ud['today_open_price'] = open_price
ud['today_open_profit'] = get_profit(open_price,
ud['market_close'])
ud['today_highest_time'] = highest_time
ud['today_highest_price'] = highest
ud['today_max_profit'] = get_profit(highest, ud['market_close'])
ud['today_amount'] = amount
ud['yesterday_amount'] = yesterday_dict[ud['code']]['amount']
result.append(ud)
return result
def get_bull_codes_by_manual(my_date, count, code_collection):
from morning.back_data.fetch_stock_data import get_day_period_data
stock = MongoClient(db.HOME_MONGO_ADDRESS)['stock']
codes = list(stock[code_collection].find())
remote_codes = []
for code in codes:
remote_codes.append(code['code'])
yesterday = get_yesterday(my_date)
datas = []
for code in remote_codes:
data = get_day_period_data(code, yesterday, yesterday)
if len(data) > 0:
data[0]['code'] = code
datas.append(data[0])
datas = sorted(datas, key=lambda i: i['7'], reverse=True)
codes = [d['code'] for d in datas]
return codes[:count]
def get_yesterday_amount_rank(today):
market_code = morning_client.get_market_code()
yesterday = holidays.get_yesterday(today)
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_list.append(data)
print('')
yesterday_list = sorted(yesterday_list,
key=lambda x: x['amount'],
reverse=True)
# For testing
yesterday_list = yesterday_list[:100]
return yesterday_list
def tick_data():
code = 'A290720'
from_datetime = datetime(2020, 2, 27, 8, 0, 0)
until_datetime = datetime(2020, 2, 27, 10, 0, 0)
trade_start_time = datetime(2020, 2, 27, 9, 0, 3)
yesterday = holidays.get_yesterday(from_datetime.date())
yesterday_data = morning_client.get_past_day_data(code, yesterday,
yesterday)[0]
yesterday_data['code'] = code
print('call fixture')
db_collection = MongoClient(db.HOME_MONGO_ADDRESS).trade_alarm
all_tick = []
tick = get_tick_data(code, from_datetime, until_datetime, db_collection,
False)
all_tick.extend(tick)
ba_tick = get_tick_data(code + '_BA', trade_start_time, until_datetime,
db_collection, True)
all_tick.extend(ba_tick)
all_tick = sorted(all_tick, key=lambda x: x['date'])
return code, all_tick, yesterday_data
def start_preload(dt, skip_ydata, skip_uni):
global _market_codes, loading, _yesterday
_LOGGER.info('Start Loading %s', dt)
if len(_market_codes) == 0:
# load infomration here, not depend on date
_market_codes = morning_client.get_all_market_code()
code_info.load_code_info(_market_codes)
if not skip_uni:
uni_current.load_uni_data(_market_codes)
_yesterday_minute_data.clear()
_yesterday_day_data.clear()
yesterday = holidays.get_yesterday(dt)
_yesterday = time_converter.datetime_to_intdate(yesterday)
_LOGGER.info('Yesterday: %s', yesterday)
if not skip_ydata:
_get_yesterday_day_data(yesterday, _market_codes)
#_get_yesterday_min_data(yesterday, _market_codes)
loading = False
def get_yesterday_data(today, market_code):
yesterday = holidays.get_yesterday(today)
one_week_before = holidays.get_date_by_previous_working_day_count(today, 5)
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
min_data = morning_client.get_minute_data(code, one_week_before,
yesterday)
if len(min_data) > 0:
data['minute_max_volume'] = max(
[d['volume'] for d in min_data])
else:
data['minute_max_volume'] = 0
yesterday_list.append(data)
print('')
return yesterday_list
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])
sock.connect(server_address)
message_reader = stream_readwriter.MessageReader(sock)
message_reader.start()
market_code = stock_api.request_stock_code(message_reader, message.KOSDAQ)
from_date = date(2018, 1, 1)
until_date = date(2019, 12, 31)
while from_date <= until_date:
if holidays.is_holidays(from_date):
from_date += timedelta(days=1)
continue
yesterday = holidays.get_yesterday(from_date)
tomorrow = holidays.get_tomorrow(from_date)
candidates = []
for code in market_code:
past_data = stock_api.request_stock_day_data(
message_reader, code, from_date - timedelta(days=MAVG * 2),
from_date)
if MAVG * 2 * 0.6 > len(past_data):
#print('PAST DATA too short', len(past_data), code)
continue
today_day_data = past_data[-1]
past_data = past_data[:-1]
past_data_c = convert_data_readable(code, past_data)
/ code_dict[code]['buy_price'] * 100, 'time',
tick['time'])
break
if __name__ == '__main__':
db_collection = MongoClient(db.HOME_MONGO_ADDRESS).trade_alarm
alarm_data = list(db_collection['alarm'].find({
'date': {
'$gte': target_date,
'$lte': target_date + timedelta(days=1)
}
}))
alarm_data = sorted(alarm_data, key=lambda x: x['date'])
market_code = morning_client.get_market_code()
yesterday = holidays.get_yesterday(target_date.date())
done_codes = []
#alarm_data = list(filter(lambda x: x['3'] == 'A017890', alarm_data))
print(len(market_code))
for code in market_code:
code_dict[code] = {
'state': STATE_NONE,
'yesterday_data': None,
'today_min_data': None,
'vi': True,
'today_tick_data': None,
'vi_highest': 0,
'bottom_price': 0,
'buy_price': 0,
'target_gap': 0
def start_today_trading(reader, market_code, today):
for code in market_code:
data = get_past_data(reader, code, today, today)
data = convert_data_readable(code, data)
if len(data) != 1:
continue
data = data[0]
if data['close_price'] < 900:
continue
state = code_dict[code]['state']
if state == STATE_NONE:
profit = (data['close_price'] -
data['start_price']) / data['start_price'] * 100
if profit > 25 and data['amount'] > 10000000000:
past_data = get_past_data(reader, code,
today - timedelta(days=90),
holidays.get_yesterday(today))
past_data = convert_data_readable(code, past_data)
if len(past_data) < 60:
#print(today, 'short data')
continue
past_data = past_data[-60:]
past_max_amount = max([d['amount'] for d in past_data])
past_max_price = max([d['highest_price'] for d in past_data])
#print(past_max_price, past_max_amount, data['highest_price'], data['amount'])
if data['highest_price'] > past_max_price and data[
'amount'] >= past_max_amount * 5:
code_dict[code]['state'] = STATE_BULL
code_dict[code]['amount'] = data['amount']
code_dict[code]['count'] = 0
code_dict[code]['buy_price'] = data['close_price']
code_dict[code]['cut_price'] = (
data['close_price'] -
data['start_price']) / 3 + data['start_price']
print_code_dict(code, today)
elif state == STATE_BULL:
#print(data['close_price'], code_dict[code]['buy_price'])
if data['lowest_price'] < code_dict[code]['cut_price']:
code_dict[code]['state'] = STATE_NONE
print_code_dict(code, today)
elif code_dict[code]['count'] > 3 and code_dict[code][
'buy_price'] < data['close_price']:
#elif code_dict[code]['count'] >= 5:
code_dict[code]['state'] = STATE_BUY
code_dict[code]['bought_price'] = data['close_price']
print_code_dict(code, today)
else:
code_dict[code]['count'] += 1
elif state == STATE_BUY:
if data['highest_price'] - data['start_price'] == 0:
body_ratio = 1
else:
body_ratio = (data['close_price'] - data['start_price']) / (
data['highest_price'] - data['start_price'])
#print(body_ratio, data['close_price'] > data['start_price'])
if data['close_price'] > data['start_price'] and body_ratio < 0.5:
profit = (data['close_price'] - code_dict[code]['bought_price']
) / code_dict[code]['bought_price'] * 100
print(code, today, 'OK', profit)
code_dict[code]['state'] = STATE_NONE
print_code_dict(code, today)
elif data['close_price'] < data['start_price']:
profit = (data['close_price'] - code_dict[code]['bought_price']
) / code_dict[code]['bought_price'] * 100
print(code, today, 'CUT', profit)
code_dict[code]['state'] = STATE_NONE
print_code_dict(code, today)
def start_today_trading(reader, market_code, today):
code_dict = dict()
yesterday = holidays.get_yesterday(today)
for progress, code in enumerate(market_code):
print('collect past data',
today,
f'{progress+1}/{len(market_code)}',
end='\r')
past_data = get_past_data(reader, code,
yesterday - timedelta(days=MAVG * 4),
yesterday)
if len(past_data) < MAVG:
continue
past_data = convert_data_readable(code, past_data)
yesterday_data = past_data[-1]
code_dict[code] = {'past_data': past_data}
print('')
candidates = []
for progress, (code, v) in enumerate(code_dict.items()):
past_data = v['past_data']
last_mavg = [d['moving_average'] for d in past_data[-MAVG:]]
X = np.arange(len(last_mavg)).reshape((-1, 1))
reg = LinearRegression().fit(X, np.array(last_mavg))
if reg.coef_[0] > 0:
candidates.append(code)
skip_count = 0
for code in candidates:
past_data = code_dict[code]['past_data']
#print([d['moving_average'] for d in past_data], [d['moving_average'] for d in past_data[-MAVG:]])
if not all([d['close_price'] for d in past_data[-MAVG:]]) or not all(
[d['moving_average'] for d in past_data[-MAVG:]]):
#print('SKIP')
skip_count += 1
continue
past_mavg_data = np.array(
[d['moving_average'] for d in past_data[-MAVG:]])
past_close_data = np.array(
[d['close_price'] for d in past_data[-MAVG:]])
std_from_mavg = ((past_close_data - past_mavg_data) / past_mavg_data *
100).std()
mean_from_mavg = ((past_close_data - past_mavg_data) / past_mavg_data *
100).mean()
avg_amount = np.array([d['amount'] for d in past_data[-MAVG:]]).mean()
if avg_amount == 0:
continue
future_data = get_past_data(reader, code, today,
today + timedelta(days=90))
if len(future_data) < 90 * 0.6:
continue
future_data = convert_data_readable(code, future_data)
today_data = future_data[0]
future_data = future_data[1:]
future_close_price = (
np.array([d['close_price'] for d in future_data]) -
today_data['close_price']) / today_data['close_price'] * 100
X = np.arange(len(future_close_price)).reshape((-1, 1))
reg = LinearRegression().fit(X, future_close_price)
slope = reg.coef_[0]
future_avg_amount = np.array([d['amount'] for d in future_data]).mean()
if future_avg_amount == 0:
continue
future_high = max([d['highest_price'] for d in future_data])
future_low = max([d['lowest_price'] for d in future_data])
report.append({
'code':
code,
'date':
today,
'today_close':
today_data['close_price'],
'mean_from_mavg':
mean_from_mavg,
'std_from_mavg':
std_from_mavg,
'past_amount_avg':
avg_amount,
'future_amount_avg':
future_avg_amount,
'future_profit_slope':
slope,
'future_high':
future_high,
'future_low':
future_low,
'max_profit': (future_high - today_data['close_price']) /
today_data['close_price'] * 100,
'min_profit': (future_low - today_data['close_price']) /
today_data['close_price'] * 100
})
print('SKIP COUNT', skip_count, 'candidate', len(candidates))
def start_trading(tdate, codes):
print('Start', tdate, len(codes))
yesterday = holidays.get_yesterday(tdate)
get_day_data(yesterday, codes)
for progress, code in enumerate(codes):
if code not in yesterday_data or yesterday_data[code]['amount'] == 0:
continue
tdata = morning_client.get_minute_data(code, tdate, tdate)
amount = 0
start_watch = False
found_point = None
previous_data = None
start_data = None
report = {
'date': tdate.year * 10000 + tdate.month * 100 + tdate.day,
'code': code,
'amount': 0,
'yesterday_amount': 0,
'open_profit': 0,
'pre_highest': 0,
'amount_x': 0,
'catch_highest_time': 0,
'buy_price': 0,
'highest_price': 0,
'over_time': 0,
'low_price': 0,
'low_time': 0
}
for data in tdata:
if start_data is None:
start_data = data
if data['time'] <= 930:
amount += data['amount']
if data['highest_price'] > report['pre_highest']:
report['pre_highest'] = data['highest_price']
continue
elif not start_watch and data[
'time'] > 930 and amount > yesterday_data[code][
'amount'] and data['highest_price'] < report[
'pre_highest']:
start_watch = True
report['amount'] = amount
report['yesterday_amount'] = yesterday_data[code]['amount']
report['over_time'] = data['time']
print('found 1', code)
if not start_watch:
break
if found_point is None:
if data['time'] >= 1449:
break
else:
if data['start_price'] > report['pre_highest']:
print('found 2', code)
report['catch_highest_time'] = data['time']
report['open_profit'] = float("{0:.2f}".format(
(data['start_price'] - start_data['start_price']) /
start_data['start_price'] * 100.0))
report['amount_x'] = float("{0:.2f}".format(
amount / yesterday_data[code]['amount']))
report['buy_price'] = data['start_price']
found_point = datetime(tdate.year, tdate.month,
tdate.day,
int(data['time'] / 100),
int(data['time'] % 100), 0)
else:
dt = datetime(tdate.year, tdate.month, tdate.day,
int(data['time'] / 100), int(data['time'] % 100),
0)
if dt - found_point >= timedelta(minutes=30):
report['high_profit'] = float("{0:.2f}".format(
(report['highest_price'] - report['buy_price']) /
report['buy_price'] * 100.0))
report['low_profit'] = float("{0:.2f}".format(
(report['low_price'] - report['buy_price']) /
report['buy_price'] * 100.0))
result.append(report)
print('report len', len(result))
break
else:
if data['highest_price'] > report['highest_price']:
report['highest_price'] = data['highest_price']
report['post_high_time'] = data['time']
if report['low_price'] == 0 or data[
'lowest_price'] < report['low_price']:
report['low_price'] = data['lowest_price']
report['low_time'] = data['time']
"""
def start_today_trading(reader, market_code, today, choosers):
code_dict = dict()
yesterday = holidays.get_yesterday(today)
by_amounts = []
for progress, code in enumerate(market_code):
print('collect past data',
today,
f'{progress+1}/{len(market_code)}',
end='\r')
yesterday_data = stock_api.request_stock_day_data(
reader, code, yesterday, yesterday)
if len(yesterday_data) != 1:
continue
elif yesterday_data[0]['5'] < 900:
continue
code_dict[code] = {
'code': code,
'past_min_data': [],
'today_min_data': None,
'time': 0,
'yesterday_close': yesterday_data[0]['5'],
'today_gap': 0,
'until_now_profit': 0
}
min_req_from = today - timedelta(days=10)
min_req_until = today
while min_req_from <= min_req_until:
if holidays.is_holidays(min_req_from):
min_req_from += timedelta(days=1)
continue
min_data = stock_api.request_stock_minute_data(
reader, code, min_req_from, min_req_from)
if len(min_data) > 0:
min_data_c = []
for md in min_data:
min_data_c.append(dt.cybos_stock_day_tick_convert(md))
code_dict[code]['past_min_data'].append(min_data_c)
min_req_from += timedelta(days=1)
if len(code_dict[code]['past_min_data']) > 5:
code_dict[code]['today_min_data'] = code_dict[code][
'past_min_data'][-1]
code_dict[code]['today_gap'] = (
code_dict[code]['today_min_data'][0]['start_price'] -
code_dict[code]['yesterday_close']
) / code_dict[code]['yesterday_close'] * 100
code_dict[code]['past_min_data'] = code_dict[code][
'past_min_data'][:-1]
else:
#print('not enough data', code)
code_dict.pop(code, None)
print('')
for c in choosers:
new_code_dict = dict()
result = c(reader, code_dict)
for r in result:
new_code_dict[r] = code_dict[r]
code_dict = new_code_dict
return code_dict
price = int(sys.argv[3])
qty = int(sys.argv[4])
# 나노메딕스, 2020/02/26 14:29
# 미코, 2020/02/26 14:48
search_time = datetime.strptime(search_time, '%Y-%m-%d %H:%M')
db_collection = MongoClient(db.HOME_MONGO_ADDRESS).trade_alarm
tick_data = get_tick_data(target_code, search_time.date(), db_collection)
if len(tick_data) == 0:
print('No Tick Data for', target_code, search_time.date())
sys.exit(1)
print('Tick Data len', len(tick_data), tick_data[0])
market_code = morning_client.get_market_code()
yesterday = holidays.get_yesterday(search_time.date())
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_list.append(data)
print('')
yesterday_list = sorted(yesterday_list,
key=lambda x: x['amount'],
reverse=True)
yesterday_list = yesterday_list[:300]
def start_validation(codes=[]):
global db_collection
if len(codes) > 0:
market_code = codes
else:
market_code = morning_client.get_market_code()
today = datetime.now().date()
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[:1000]
failed_tick_codes = []
failed_ba_tick_codes = []
# 1. validate yesterday_list :100's today tick data
for ydata in yesterday_list:
if not validate_tick_data(ydata['code'], today):
failed_tick_codes.append(ydata['code'])
if not validate_ba_tick_data(ydata['code'], today):
failed_ba_tick_codes.append(ydata['code'])
if len(failed_tick_codes) > 0:
print('FAILED TICK', failed_tick_codes)
else:
print('TICK ALL SUCCESS')
if len(failed_ba_tick_codes) > 0:
print('FAILED BA TICK', failed_ba_tick_codes)
else:
print('TICK BA ALL SUCCESS')
# 2. validate today alarm tick data
alarm_list = get_alarm_list(today)
alarm_failed_codes = []
if len(alarm_list) > 0:
for ac in alarm_list:
if len(codes) > 0 and ac['3'] not in codes:
continue
if not validate_alarm_data(ac['3'], today, ac['date']):
alarm_failed_codes.append(ac['3'])
if len(alarm_failed_codes) > 0:
print('FAILED ALARM CODES', alarm_failed_codes,
len(alarm_failed_codes), '/', len(alarm_list))
else:
print('ALARM ALL SUCCESS', len(alarm_list))
else:
print('NO ALARM TODAY')
return past_data_c, close_datas, amount_datas, close_datas_recent, amount_datas_recent
if __name__ == '__main__':
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_address = (message.SERVER_IP, message.CLIENT_SOCKET_PORT)
sock.connect(server_address)
message_reader = stream_readwriter.MessageReader(sock)
message_reader.start()
market_code = stock_api.request_stock_code(message_reader, message.KOSDAQ)
target_code = ['A034230']
search_from = date(2019, 1, 2)
search_until = date(2019, 12, 30)
for code in target_code:
today = datetime.now().date()
yesterday = holidays.get_yesterday(today)
yesterday = holidays.get_yesterday(yesterday)
past_data, prices, amounts, recent_prices, recent_amounts = get_window_data(message_reader, code, yesterday)
average_amount = np.array(recent_amounts).mean()
while search_from <= search_until:
if holidays.is_holidays(search_from):
search_from += timedelta(days=1)
continue
for mcode in market_code:
mpast_data, mprices, mamounts, recent_mprices, recent_mamounts = get_window_data(message_reader, mcode, search_from)
if len(mpast_data) == 0:
continue
recent_amount_average = np.array(recent_mamounts).mean()
if (average_amount * 0.7 > recent_amount_average or
average_amount * 1.3 < recent_amount_average):
def start_trading(tdate, codes):
print('Start', tdate, len(codes))
yesterday = holidays.get_yesterday(tdate)
start_time = datetime.now()
yesterday_data = get_yesterday_day_data(yesterday, codes)
amount_passed = []
for data in yesterday_data:
code = data['code']
if data['amount'] >= 3000000000:
yesterday_close[code] = data['close_price']
yesterday_amount[code] = data['amount']
amount_passed.append(code)
print('amount passed', len(amount_passed))
range_passed = []
for code in amount_passed:
if is_price_in_range(yesterday, code):
range_passed.append(code)
print('range passed', len(range_passed))
meet_codes = []
for code in range_passed:
state = STATE_START
highest_in_today[code] = 0
tdata = morning_client.get_minute_data(code, tdate, tdate)
ydata = morning_client.get_minute_data(code, yesterday, yesterday)
if len(tdata) == 0:
print(code, 'Today Min DATA is empty')
continue
current_data = []
current_data.extend(ydata)
today_open_price[code] = tdata[0]['start_price']
today_amount = 0
for data in tdata:
current_data.append(data)
if data['time'] <= 930:
today_amount += data['amount']
if data['highest_price'] > highest_in_today[code]:
highest_in_today[code] = data['highest_price']
continue
else:
if yesterday_amount[code] > today_amount:
break
mavg = statistics.mean(
[d['close_price'] for d in current_data[-60:]])
if state == STATE_START:
if mavg < data['highest_price']:
if data['highest_price'] > highest_in_today[code]:
highest_in_today[code] = data['highest_price']
else:
state = STATE_UNDER_MAVG
if state == STATE_UNDER_MAVG:
if data['close_price'] >= mavg * 1.01:
state = STATE_MEET_MAVG
if state == STATE_MEET_MAVG:
meet_codes.append({
'code':
code,
'date':
data['0'],
'time':
data['time'],
'open profit':
get_profit(today_open_price[code],
yesterday_close[code]),
'current profit:':
get_profit(data['close_price'], yesterday_close[code]),
'mavg':
mavg,
'current_close':
data['close_price'],
'current_highest':
data['highest_price'],
'yesterday_amount':
yesterday_amount[code],
'today_930_amount':
today_amount
})
print(meet_codes)
break
# calculate target price
# or cut when meet under mavg / 0 % cut
return meet_codes
def start_today_trading(reader, market_code, today):
code_dict = dict()
# starting point for the loop of simulation
yesterday = holidays.get_yesterday(today)
get_long_list(reader, code_dict, today)
candidate_over_avg = []
for progress, code in enumerate(market_code):
print('over avg', today, f'{progress+1}/{len(market_code)}', end='\r')
past_data = get_past_data(
reader, code, yesterday - timedelta(days=trader_env.MAVG * 3),
yesterday)
if len(past_data) == 0:
continue
past_data = convert_data_readable(code, past_data)
yesterday_data = past_data[-1]
if code in code_dict:
code_dict[code].yesterday_data = yesterday_data
#print(yesterday_data['moving_average'], yesterday_data['close_price'])
continue
if yesterday_data['moving_average'] < yesterday_data['close_price']:
candidate_over_avg.append(code)
code_dict[code] = CodeInfo(state=trader_env.STATE_NONE,
buy_price=0,
sell_available=0,
yesterday_data=yesterday_data,
past_data=None,
cut=0,
cross_data=None,
before_cross_data=None,
mavg_data=past_data,
loss_cut=0)
print('')
candidate_cross_data = []
for progress, code in enumerate(candidate_over_avg):
not_cross, cross_data = find_first_cross_data(
code_dict[code].mavg_data[-1::-1])
if 2 <= len(cross_data) <= 10:
increase_candle = cross_data[0]['start_price'] < cross_data[0][
'close_price'] and cross_data[1]['start_price'] < cross_data[
1]['close_price']
if increase_candle:
code_dict[code].cross_data = cross_data
code_dict[code].before_cross_data = not_cross
#code_dict[code].cut = max([cross_data[0]['highest_price'], cross_data[1]['highest_price']])
candidate_cross_data.append(code)
for progress, code in enumerate(candidate_cross_data):
#print('get past data', today, f'{progress+1}/{len(candidate_cross_data)}', end='\r')
past_data = get_past_data(reader, code,
yesterday - timedelta(days=365), yesterday)
if len(past_data) == 0:
continue
past_data_c = convert_data_readable(code, past_data)
code_dict[code].past_data = past_data_c
#print('\nget past data done')
over_profit_check_data = []
# when cross mavg, check whether over profit(> 20%)
for progress, code in enumerate(candidate_cross_data):
over_profit_array = [
code_dict[code].before_cross_data['close_price'],
code_dict[code].cross_data[0]['close_price'],
code_dict[code].cross_data[1]['close_price']
]
if ((over_profit_array[2] - over_profit_array[1]) /
over_profit_array[1] * 100 < 20
and (over_profit_array[1] - over_profit_array[0]) /
over_profit_array[0] * 100 < 20):
over_profit_check_data.append(code)
over_days_profit_check_data = []
for progress, code in enumerate(over_profit_check_data):
cross_data = code_dict[code].cross_data
passed = True
for i in range(2, len(cross_data)):
if (cross_data[i]['highest_price'] -
cross_data[i - 1]['close_price']
) / cross_data[i - 1]['close_price'] * 100 >= 10:
passed = False
break
if passed:
cut, loss_cut = find_previous_cross_highest(
code_dict[code].past_data[-1::-1])
if cut == 0 or loss_cut == 0:
print('cut / loss_cut zero', code)
continue
over_days_profit_check_data.append(code)
code_dict[code].cut = cut
code_dict[code].loss_cut = loss_cut
print(today, 'over avg', len(candidate_over_avg), '\tcross over',
len(candidate_cross_data), '\tover profit',
len(over_profit_check_data), '\tover days',
len(over_days_profit_check_data))
for code in over_days_profit_check_data:
code_dict[code].state = trader_env.STATE_OVER_AVG
for k, v in code_dict.items():
if v.state != trader_env.STATE_NONE:
today_watcher.add_watcher(reader, k, v, today, v.state,
trader_env.RUNNING_SIMULATION)
