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 convert_data_readable(code, past_data):
converted_data = []
avg_prices = np.array([])
trend_prices = np.array([])
for p in past_data:
converted = dt.cybos_stock_day_tick_convert(p)
converted['code'] = code
avg_prices = np.append(avg_prices,
np.array([converted['close_price']]))
trend_prices = np.append(trend_prices,
np.array([converted['close_price']]))
if len(avg_prices) == days_for_ranking:
converted['moving_average'] = avg_prices.mean()
avg_prices = avg_prices[1:]
else:
converted['moving_average'] = 0
if len(trend_prices) == 5: # Fixed
converted['trend_moving_average'] = trend_prices.mean()
trend_prices = trend_prices[1:]
else:
converted['trend_moving_average'] = 0
converted_data.append(converted)
return converted_data
def _convert_data_readable(code, past_data):
converted_data = []
avg_prices = np.array([])
avg_volumes = np.array([])
yesterday_close = 0
for p in past_data:
converted = dt.cybos_stock_day_tick_convert(p)
converted['code'] = code
converted['date'] = time_converter.intdate_to_datetime(converted['0'])
avg_prices = np.append(avg_prices,
np.array([converted['close_price']]))
avg_volumes = np.append(avg_volumes, np.array([converted['volume']]))
if yesterday_close == 0:
yesterday_close = converted['close_price']
converted['yesterday_close'] = yesterday_close
else:
converted['yesterday_close'] = yesterday_close
yesterday_close = converted['close_price']
if len(avg_prices) == MAVG:
converted['moving_average'] = avg_prices.mean()
avg_prices = avg_prices[1:]
converted['volume_average'] = avg_volumes.mean()
avg_volumes = avg_volumes[1:]
else:
converted['moving_average'] = 0
converted['avg_volumes'] = 0
converted_data.append(converted)
return converted_data
def convert_data_readable(code, past_data):
converted_data = []
for p in past_data:
converted = dt.cybos_stock_day_tick_convert(p)
converted['code'] = code
converted_data.append(converted)
return converted_data
def _convert_min_data_readable(code, min_data):
converted_data = []
for md in min_data:
converted = dt.cybos_stock_day_tick_convert(md)
converted['code'] = code
converted_data.append(converted)
return converted_data
def get_today_min_data(code, from_date):
today_min_data = stock_api.request_stock_minute_data(
message_reader, code, from_date, from_date)
if len(today_min_data) == 0:
print('NO MIN DATA', code, from_date)
return []
today_min_data_c = []
for tm in today_min_data:
today_min_data_c.append(dt.cybos_stock_day_tick_convert(tm))
return today_min_data_c
def get_future_data(reader, code, from_date):
past_data = stock_api.request_stock_day_data(reader, code, from_date, from_date + timedelta(days=int(future_day*2)))
if len(past_data) < future_day:
return []
past_data_c = []
for data in past_data[:future_day+1]:
past_data_c.append(dt.cybos_stock_day_tick_convert(data))
start_price = past_data_c[0]['close_price']
profits = []
for data in past_data_c[1:]:
profits.append((data['close_price'] - start_price) / start_price * 100)
return profits
def convert_data_readable(code, past_data):
converted_data = []
avg_prices = np.array([])
avg_volumes = np.array([])
yesterday_close = 0
for p in past_data:
converted = dt.cybos_stock_day_tick_convert(p)
if yesterday_close == 0:
yesterday_close = converted['close_price']
continue
converted['code'] = code
converted['yesterday_close'] = yesterday_close
converted_data.append(converted)
yesterday_close = converted['close_price']
return converted_data
def convert_data_readable(code, past_data):
converted_data = []
avg_prices = np.array([])
for p in past_data:
converted = dt.cybos_stock_day_tick_convert(p)
converted['code'] = code
avg_prices = np.append(avg_prices, np.array([converted['close_price']]))
if len(avg_prices) == MAVG:
converted['moving_average'] = avg_prices.mean()
avg_prices = avg_prices[1:]
else:
converted['moving_average'] = 0
converted_data.append(converted)
return converted_data
def add_watcher(reader, code, code_info, today, state, is_simulation):
tt = None
if not is_simulation:
tt = TodayTrader(code, code_info, today, state)
stock_api.subscribe_stock(reader, code, tt.tick_handler)
tt.start_timer()
else:
tt = TodayTrader(code, code_info, today, state)
today_data = stock_api.request_stock_minute_data(reader, code, today, today)
today_min_data = []
for td in today_data:
today_min_data.append(dt.cybos_stock_day_tick_convert(td))
#print('data len', len(today_min_data))
tt.set_simulation_data(today_min_data)
tt.start()
today_traders.append(tt)
def get_window_data(reader, code, until_date):
past_data = stock_api.request_stock_day_data(reader, code, until_date - timedelta(days=int(window_size*2)), until_date)
if window_size > len(past_data):
return [], [], [], [], []
elif past_data[-1]['0'] != time_converter.datetime_to_intdate(until_date):
return [], [], [], [], []
past_data_c = []
for data in past_data[-90:]:
past_data_c.append(dt.cybos_stock_day_tick_convert(data))
close_datas = [d['close_price'] for d in past_data_c]
amount_datas = [d['amount'] for d in past_data_c]
close_datas_recent = close_datas[-30:]
amount_datas_recent = amount_datas[-30:]
return past_data_c, close_datas, amount_datas, close_datas_recent, amount_datas_recent
while from_date <= until_date:
if holidays.is_holidays(from_date):
from_date += timedelta(days=1)
continue
#print('RUN', from_date)
candidates = []
for i, code in enumerate(market_code):
today_min_data = stock_api.request_stock_minute_data(
message_reader, code, from_date, from_date)
if len(today_min_data) == 0:
continue
today_min_data_c = []
for tm in today_min_data:
today_min_data_c.append(dt.cybos_stock_day_tick_convert(tm))
candidates.append({
'code': code,
'data': today_min_data_c,
'start_price': today_min_data_c[0]['start_price']
})
#print(f'Collect {i}/{len(market_code)}', end='\r')
print('Start Best Candidates')
best_candidates = find_best(candidates, det)
final_candidates = best_candidates[:5]
start_trade_simulation(final_candidates, det, from_date)
from_date += timedelta(days=1)
print(
det,
def save(message_reader, peak_data, data, start_time, until_time,
matched_data):
price_array, date_array, volume_array_old, price_average = data
code = peak_data['code']
volume_array = []
matched_data_price_array = []
matched_data_date_array = []
matched_data_volume_array = []
titles = ['comparision', peak_data['code']]
current_volume = 0
for v in volume_array_old:
volume_array.append(v - current_volume)
current_volume = v
for m in matched_data:
current_volume = 0
min_data = stock_api.request_stock_minute_data(message_reader,
m['code'],
m['from_date'].date(),
m['until_date'].date())
if len(min_data) == 0:
print('SAVE NO MIN DATA', code, m['from_date'], m['until_date'])
continue
min_data_c = []
for md in min_data:
min_data_c.append(dt.cybos_stock_day_tick_convert(md))
min_data_price_array = [
int((mdata['lowest_price'] + mdata['close_price'] +
mdata['highest_price']) / 3) for mdata in min_data_c
]
min_data_date_array = []
min_data_volume_array = []
for mdata in min_data_c:
min_data_volume_array.append(mdata['volume'])
tc = time_converter.intdate_to_datetime(mdata['0']).date()
if tc == m['from_date'].date():
min_data_date_array.append(date_array[0].replace(
hour=int(mdata['time'] / 100),
minute=int(mdata['time'] % 100)))
else:
min_data_date_array.append(date_array[-1].replace(
hour=int(mdata['time'] / 100),
minute=int(mdata['time'] % 100)))
matched_data_price_array.append(min_data_price_array)
matched_data_date_array.append(min_data_date_array)
matched_data_volume_array.append(min_data_volume_array)
titles.append(m['code'] + '_' + m['from_date'].strftime('%Y%m%d-') +
m['until_date'].strftime('%Y%m%d'))
fig = make_subplots(rows=len(matched_data_price_array) + 2,
cols=1,
shared_xaxes=True,
specs=[[{
"secondary_y": True
}]] * (len(matched_data_price_array) + 2),
subplot_titles=titles)
fig.add_trace(go.Scatter(x=date_array,
y=profit_price(price_array),
line=dict(color='black', width=2)),
row=1,
col=1)
for i, data in enumerate(matched_data_price_array):
fig.add_trace(go.Scatter(x=matched_data_date_array[i],
y=profit_price(matched_data_price_array[i]),
line=dict(width=1),
opacity=0.8),
row=1,
col=1)
fig.update_xaxes(type='category', tickformat='%H%M', row=1, col=1)
fig.add_trace(go.Scatter(x=date_array,
y=price_array,
name=code,
line=dict(color='black', width=1)),
secondary_y=False,
row=2,
col=1)
fig.add_trace(go.Scatter(x=date_array,
y=price_average,
line=dict(color='green')),
secondary_y=False,
row=2,
col=1)
fig.add_trace(go.Bar(x=date_array, y=volume_array),
row=2,
col=1,
secondary_y=True)
fig.update_xaxes(type='category', tickformat='%H%M', row=2, col=1)
fig.update_yaxes(title_text='price', secondary_y=False, row=2, col=1)
fig.update_yaxes(title_text='volume', secondary_y=True, row=2, col=1)
for i, data in enumerate(matched_data_price_array):
fig.add_trace(go.Scatter(x=matched_data_date_array[i], y=data),
row=i + 3,
col=1,
secondary_y=False)
fig.add_trace(go.Bar(x=matched_data_date_array[i],
y=matched_data_volume_array[i]),
row=i + 3,
col=1,
secondary_y=True)
fig.update_xaxes(type='category', tickformat='%H%M', row=i + 3, col=1)
shapes = [
dict(x0=until_time,
x1=until_time,
y0=0,
y1=1,
xref='x',
yref='paper',
line_width=2)
]
annotations = []
for p in peak_data['peak'][1:]:
annotations.append(
go.layout.Annotation(x=p['time'],
y=p['price'],
text=('t' if p['type'] == 1 else 'b'),
xref='x2',
yref='y3',
showarrow=True,
arrowhead=7))
fig.update_layout(title=code + '_' + start_time.strftime('%Y%m%d'),
shapes=shapes,
annotations=annotations,
yaxis_tickformat='d',
autosize=True,
width=1920,
height=(len(matched_data_price_array) + 2) * 300)
fig.write_html(code + '_' + until_time.strftime('%Y%m%d%H%M_') +
str(len(peak_data['peak'])) + '.html',
auto_open=False)
print(
'save done', code + '_' + until_time.strftime('%Y%m%d%H%M_') +
str(len(peak_data['peak'])) + '.html')
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
