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)