forked from hellobiek/smart_deal_tool
-
Notifications
You must be signed in to change notification settings - Fork 0
/
data_manager.py
462 lines (416 loc) · 20.1 KB
/
data_manager.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
#coding=utf-8
from gevent import monkey
monkey.patch_all()
import os
import time
import json
import copy
import datetime
import traceback
import const as ct
import numpy as np
import pandas as pd
from log import getLogger
from cstock import CStock
from cindex import CIndex
from climit import CLimit
from functools import partial
from datetime import datetime
from rstock import RIndexStock
from ccalendar import CCalendar
from animation import CAnimation
from index_info import IndexInfo
from ticks import download, unzip
from cstock_info import CStockInfo
from combination import Combination
from industry_info import IndustryInfo
from datamanager.margin import Margin
from datamanager.emotion import Emotion
from datamanager.hgt import StockConnect
from datamanager.sexchange import StockExchange
from rindustry import RIndexIndustryInfo
from combination_info import CombinationInfo
from futuquant.common.constant import SubType
from subscriber import Subscriber, StockQuoteHandler, TickerHandler
from common import is_trading_time, delta_days, create_redis_obj, add_prifix, add_index_prefix, kill_process, concurrent_run, get_day_nday_ago, get_dates_array, process_concurrent_run
pd.options.mode.chained_assignment = None #default='warn'
pd.set_option('display.max_columns', None)
pd.set_option('display.max_rows', None)
class DataManager:
def __init__(self, dbinfo = ct.DB_INFO, redis_host = None):
self.dbinfo = dbinfo
self.logger = getLogger(__name__)
self.index_objs = dict()
self.stock_objs = dict()
self.combination_objs = dict()
self.cal_client = CCalendar(dbinfo, redis_host)
self.index_info_client = IndexInfo()
self.comb_info_client = CombinationInfo(dbinfo, redis_host)
self.stock_info_client = CStockInfo(dbinfo, redis_host)
self.rindex_stock_data_client = RIndexStock(dbinfo, redis_host)
self.industry_info_client = IndustryInfo(dbinfo, redis_host)
self.rindustry_info_client = RIndexIndustryInfo(dbinfo, redis_host)
self.limit_client = CLimit(dbinfo, redis_host)
self.animation_client = CAnimation(dbinfo, redis_host)
self.subscriber = Subscriber()
self.quote_handler = StockQuoteHandler()
self.ticker_handler = TickerHandler()
self.connect_client = StockConnect(market_from = ct.SH_MARKET_SYMBOL, market_to = ct.HK_MARKET_SYMBOL, dbinfo = dbinfo, redis_host = redis_host)
self.margin_client = Margin(dbinfo = dbinfo, redis_host = redis_host)
self.emotion_client = Emotion(dbinfo = dbinfo, redis_host = redis_host)
self.sh_exchange_client = StockExchange(ct.SH_MARKET_SYMBOL)
self.sz_exchange_client = StockExchange(ct.SZ_MARKET_SYMBOL)
def is_collecting_time(self, now_time = datetime.now()):
_date = now_time.strftime('%Y-%m-%d')
y,m,d = time.strptime(_date, "%Y-%m-%d")[0:3]
aft_open_hour,aft_open_minute,aft_open_second = (19,00,00)
aft_open_time = datetime(y,m,d,aft_open_hour,aft_open_minute,aft_open_second)
aft_close_hour,aft_close_minute,aft_close_second = (23,59,59)
aft_close_time = datetime(y,m,d,aft_close_hour,aft_close_minute,aft_close_second)
return aft_open_time < now_time < aft_close_time
def is_morning_time(self, now_time = datetime.now()):
_date = now_time.strftime('%Y-%m-%d')
y,m,d = time.strptime(_date, "%Y-%m-%d")[0:3]
mor_open_hour,mor_open_minute,mor_open_second = (0,0,0)
mor_open_time = datetime(y,m,d,mor_open_hour,mor_open_minute,mor_open_second)
mor_close_hour,mor_close_minute,mor_close_second = (6,30,0)
mor_close_time = datetime(y,m,d,mor_close_hour,mor_close_minute,mor_close_second)
return mor_open_time < now_time < mor_close_time
def collect_combination_runtime_data(self):
def _combination_run(code_id):
self.combination_objs[code_id].run()
return (code_id, True)
todo_iplist = list(self.combination_objs.keys())
return concurrent_run(_combination_run, todo_iplist, num = 10)
def collect_stock_runtime_data(self):
if self.ticker_handler.empty(): return
datas = self.ticker_handler.getQueue()
while not datas.empty():
df = datas.get()
df = df.set_index('time')
df.index = pd.to_datetime(df.index)
for code_str in set(df.code):
code_id = code_str.split('.')[1]
self.stock_objs[code_id].run(df.loc[df.code == code_str])
def init_real_stock_info(self):
concerned_list = self.comb_info_client.get_concerned_list()
prefix_concerned_list = [add_prifix(code) for code in concerned_list]
ret = self.subscriber.subscribe(prefix_concerned_list, SubType.TICKER, self.ticker_handler)
if 0 == ret:
for code in concerned_list:
if code not in self.stock_objs:
self.stock_objs[code] = CStock(code, self.dbinfo, should_create_influxdb = True, should_create_mysqldb = True)
return ret
def init_index_info(self):
index_list = ct.INDEX_DICT.keys()
prefix_index_list = [add_index_prefix(code) for code in index_list]
ret = self.subscriber.subscribe(prefix_index_list, SubType.QUOTE, self.quote_handler)
if 0 != ret:
self.logger.error("subscribe for index list failed")
return ret
for code in index_list:
if code not in self.index_objs:
self.index_objs[code] = CIndex(code, should_create_influxdb = True, should_create_mysqldb = True)
def collect_index_runtime_data(self):
if self.quote_handler.empty(): return
datas = self.quote_handler.getQueue()
while not datas.empty():
df = datas.get()
df['time'] = df.data_date + ' ' + df.data_time
df = df.drop(['data_date', 'data_time'], axis = 1)
df = df.set_index('time')
df.index = pd.to_datetime(df.index)
for code_str in set(df.code):
code_id = code_str.split('.')[1]
self.index_objs[code_id].run(df.loc[df.code == code_str])
def run(self, sleep_time):
while True:
try:
if self.cal_client.is_trading_day():
if is_trading_time():
sleep_time = 1
if not self.subscriber.status():
self.subscriber.start()
if 0 == self.init_index_info() and 0 == self.init_real_stock_info():
self.init_combination_info()
else:
self.logger.debug("enter stop dict time")
self.subscriber.stop()
else:
self.collect_stock_runtime_data()
self.collect_combination_runtime_data()
self.collect_index_runtime_data()
self.animation_client.collect()
else:
sleep_time = 60
if self.subscriber.status():
self.subscriber.stop()
except Exception as e:
traceback.print_exc()
self.logger.error(e)
time.sleep(sleep_time)
def set_update_info(self, step_length, exec_date, cdate = None, filename = ct.STEPFILE):
step_info = dict()
if cdate is None: cdate = 'none'
step_info[cdate] = dict()
step_info[cdate]['step'] = step_length
step_info[cdate]['date'] = exec_date
with open(filename, 'w') as f:
json.dump(step_info, f)
self.logger.info("finish step :%s" % step_length)
def get_update_info(self, cdate = None, exec_date = None, filename = ct.STEPFILE):
if cdate is None: cdate = 'none'
if not os.path.exists(filename): return (0, exec_date)
with open(filename, 'r') as f: step_info = json.load(f)
if cdate not in step_info: return (0, exec_date)
return (step_info[cdate]['step'], step_info[cdate]['date'])
def bootstrap(self, cdate = None, exec_date = datetime.now().strftime('%Y-%m-%d')):
finished_step, exec_date = self.get_update_info(cdate, exec_date)
self.logger.info("enter updating.%s" % finished_step)
if finished_step < 1:
if not self.cal_client.init():
self.logger.error("cal_client init failed")
return False
self.set_update_info(1, exec_date, cdate)
if finished_step < 2:
if not self.index_info_client.update():
self.logger.error("index_info init failed")
return False
self.set_update_info(2, exec_date, cdate)
if finished_step < 3:
if not self.stock_info_client.update():
self.logger.error("stock_info init failed")
return False
self.set_update_info(3, exec_date, cdate)
if finished_step < 4:
if not self.comb_info_client.update():
self.logger.error("comb_info init failed")
return False
self.set_update_info(4, exec_date, cdate)
if finished_step < 5:
if not self.industry_info_client.update():
self.logger.error("industry_info init failed")
return False
self.set_update_info(5, exec_date, cdate)
if finished_step < 6:
if not self.download_and_extract(exec_date):
self.logger.error("download_and_extract failed")
return False
self.set_update_info(6, exec_date, cdate)
if finished_step < 7:
if not self.init_tdx_index_info(cdate):
self.logger.error("init_tdx_index_info failed")
return False
self.set_update_info(7, exec_date, cdate)
if finished_step < 8:
if not self.sh_exchange_client.update(exec_date, num = 30):
self.logger.error("sh exchange update failed")
return False
self.set_update_info(8, exec_date, cdate)
if finished_step < 9:
if not self.sz_exchange_client.update(exec_date, num = 30):
self.logger.error("sz exchange update failed")
return False
self.set_update_info(9, exec_date, cdate)
if finished_step < 10:
if not self.init_index_components_info(exec_date):
self.logger.error("init index components info failed")
return False
self.set_update_info(10, exec_date, cdate)
if finished_step < 11:
if not self.init_industry_info(cdate):
self.logger.error("init_industry_info failed")
return False
self.set_update_info(11, exec_date, cdate)
if finished_step < 12:
if not self.rindustry_info_client.update(exec_date):
self.logger.error("init %s rindustry info failed" % exec_date)
return False
self.set_update_info(12, exec_date, cdate)
if finished_step < 13:
if not self.limit_client.update(exec_date):
self.logger.error("init_limit_info failed")
return False
self.set_update_info(13, exec_date, cdate)
if finished_step < 14:
if not self.init_yesterday_hk_info(exec_date):
self.logger.error("init_yesterday_hk_info failed")
return False
self.set_update_info(14, exec_date, cdate)
if finished_step < 15:
if not self.margin_client.update(exec_date):
self.logger.error("init_yesterday_margin failed")
return False
self.set_update_info(15, exec_date, cdate)
if finished_step < 16:
if not self.init_stock_info(cdate):
self.logger.error("init_stock_info set failed")
return False
self.set_update_info(16, exec_date, cdate)
if finished_step < 17:
if not self.init_base_float_profit():
self.logger.error("init base float profit for all stock")
return False
self.set_update_info(17, exec_date, cdate)
if finished_step < 18:
if not self.rindex_stock_data_client.update(exec_date, num = 300):
self.logger.error("rindex_stock_data set failed")
return False
self.set_update_info(18, exec_date, cdate)
self.logger.info("updating succeed")
return True
def update(self, sleep_time):
while True:
self.logger.info("enter daily update process. %s" % datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
try:
if self.cal_client.is_trading_day():
self.logger.info("is trading day. %s" % datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
if self.is_collecting_time():
self.logger.info("is collecting time. %s" % datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
self.bootstrap(cdate = datetime.now().strftime('%Y-%m-%d'))
except Exception as e:
kill_process("google-chrome")
kill_process("renderer")
kill_process("Xvfb")
kill_process("zygote")
kill_process("defunct")
kill_process("show-component-extension-options")
self.logger.error(e)
time.sleep(sleep_time)
def init_combination_info(self):
trading_info = self.comb_info_client.get()
for _, code_id in trading_info['code'].iteritems():
if str(code_id) not in self.combination_objs:
self.combination_objs[str(code_id)] = Combination(code_id, self.dbinfo)
def init_base_float_profit(self):
def _set_base_float_profit(code_id):
return (code_id, True) if CStock(code_id).set_base_floating_profit() else (code_id, False)
failed_list = self.stock_info_client.get().code.tolist()
return process_concurrent_run(_set_base_float_profit, failed_list, num = 500)
def init_stock_info(self, cdate = None):
def _set_stock_info(_date, bonus_info, index_info, code_id):
try:
if CStock(code_id).set_k_data(bonus_info, index_info, _date):
self.logger.info("%s set k data success" % code_id)
return (code_id, True)
else:
self.logger.error("%s set k data failed" % code_id)
return (code_id, False)
except Exception as e:
self.logger.error("%s set k data exception:%s" % (code_id, e))
return (code_id, False)
#get stock bonus info
bonus_info = pd.read_csv("/data/tdx/base/bonus.csv", sep = ',',
dtype = {'code' : str, 'market': int, 'type': int, 'money': float, 'price': float, 'count': float, 'rate': float, 'date': int})
index_info = CIndex('000001').get_k_data()
if index_info is None or index_info.empty: return False
df = self.stock_info_client.get()
failed_list = df.code.tolist()
if cdate is None:
cfunc = partial(_set_stock_info, cdate, bonus_info, index_info)
return process_concurrent_run(cfunc, failed_list, num = 5)
else:
succeed = True
start_date = get_day_nday_ago(cdate, num = 10, dformat = "%Y-%m-%d")
for mdate in get_dates_array(start_date, cdate, asending = True):
if self.cal_client.is_trading_day(mdate):
cfunc = partial(_set_stock_info, mdate, bonus_info, index_info)
if not process_concurrent_run(cfunc, failed_list, num = 500):
succeed = False
return succeed
def init_industry_info(self, cdate):
def _set_industry_info(cdate, code_id):
return (code_id, CIndex(code_id).set_k_data(cdate))
df = self.industry_info_client.get()
if cdate is None:
cfunc = partial(_set_industry_info, cdate)
return concurrent_run(cfunc, df.code.tolist(), num = 5)
else:
succeed = True
start_date = get_day_nday_ago(cdate, num = 30, dformat = "%Y-%m-%d")
for mdate in get_dates_array(start_date, cdate, asending = True):
if self.cal_client.is_trading_day(mdate):
cfunc = partial(_set_industry_info, mdate)
if not concurrent_run(cfunc, df.code.tolist(), num = 5):
succeed = False
return succeed
def init_yesterday_hk_info(self, cdate):
succeed = True
for data in ((ct.SH_MARKET_SYMBOL, ct.HK_MARKET_SYMBOL), (ct.SZ_MARKET_SYMBOL, ct.HK_MARKET_SYMBOL)):
if not self.connect_client.set_market(data[0], data[1]):
self.logger.error("connect_client for %s failed" % data)
succeed = False
continue
if not self.connect_client.update(cdate):
succeed = False
self.connect_client.close()
self.connect_client.quit()
kill_process("zygote")
kill_process("defunct")
kill_process("show-component-extension-options")
return succeed
def init_index_components_info(self, cdate = None):
if cdate is None: cdate = datetime.now().strftime('%Y-%m-%d')
def _set_index_info(code_id):
_obj = self.index_objs[code_id] if code_id in self.index_objs else CIndex(code_id)
return (code_id, _obj.set_components_data(cdate))
return concurrent_run(_set_index_info, list(ct.INDEX_DICT.keys()), num = 10)
def init_tdx_index_info(self, cdate = None):
def _set_index_info(cdate, code_id):
try:
_obj = self.index_objs[code_id] if code_id in self.index_objs else CIndex(code_id)
return (code_id, _obj.set_k_data(cdate))
except Exception as e:
self.logger.error(e)
return (code_id, False)
if cdate is None:
cfunc = partial(_set_index_info, cdate)
return concurrent_run(cfunc, list(ct.TDX_INDEX_DICT.keys()), num = 5)
else:
succeed = True
start_date = get_day_nday_ago(cdate, num = 30, dformat = "%Y-%m-%d")
for mdate in get_dates_array(start_date, cdate, asending = True):
if self.cal_client.is_trading_day(mdate):
cfunc = partial(_set_index_info, mdate)
if not concurrent_run(cfunc, list(ct.TDX_INDEX_DICT.keys()), num = 5):
succeed = False
return succeed
def download_and_extract(self, cdate):
try:
if not download(ct.ZIP_DIR, cdate): return False
list_files = os.listdir(ct.ZIP_DIR)
for filename in list_files:
if not filename.startswith('.'):
file_path = os.path.join(ct.ZIP_DIR, filename)
if os.path.exists(file_path):
unzip(file_path, ct.TIC_DIR)
return True
except Exception as e:
self.logger.error(e)
return False
if __name__ == '__main__':
#from cmysql import CMySQL
#mysql_client = CMySQL(dbinfo = ct.DB_INFO)
#mysql_client.delete_db(ct.RINDEX_STOCK_INFO_DB)
#mysql_client.delete_db(ct.RINDEX_INDUSTRY_INFO_DB)
#for code in IndustryInfo().get().code.tolist():
# print(code)
# mysql_client.delete_db('i%s' % code)
#for code in CStockInfo().get().code.tolist():
# print(code)
# mysql_client.delete_db('s%s' % code)
#import sys
#sys.exit(0)
kill_process("google-chrome")
kill_process("renderer")
kill_process("Xvfb")
kill_process("zygote")
kill_process("defunct")
kill_process("show-component-extension-options")
dm = DataManager()
dm.logger.info("start compute!")
#dm.init_stock_info(cdate = None)
#dm.init_base_float_profit()
#dm.bootstrap(exec_date = '2019-01-18')
dm.bootstrap(cdate='2019-01-18', exec_date = '2019-01-18')
dm.logger.info("end compute!")