def start(self, codes, time0, kline=None, Base=None, Rice=None):
print("子进程启动:", self.cindex, codes, kline)
# 主力合约
self.codes = codes
self.code, self.mCode = codes[0], codes[0] + '88'
self.mCodes = mCodes = [n + '88' for n in codes]
# 查询获得配置 - 费率和每手单量
self.Base = future_baseInfo()
self.BS = {}
for doc in self.Base.getInfo(codes):
self.BS[doc["code"]] = self.BS[doc["code"] + '88'] = doc
cs = [self.BS[m] for m in self.mCodes]
self.klineType = self.BS[
self.code]['quickkline'] if kline is None else kline
# 子进程共享类
self.Rice = Rice if Rice is not None else interface_Rice()
self.Rice.setTimeArea(cs[0]["nightEnd"])
self.Train = train_future()
self.Total = train_total()
self.Total.tablename = self.total_tablename
self.Train.tablename = self.detail_tablename
if len(self.indexCodeList) > 0:
self.Rice.setIndexList(self.indexCodeList)
self.adjustDates = self.Rice.getAdjustDate(self.code,
start=self.startDate)
print(codes, self.adjustDates)
# 查询获得N分钟K线
dfs = self.Rice.kline(mCodes,
period=self.klineType,
start=self.startDate,
end=self.endDate,
pre=1)
print('kline load:', mCodes, [len(dfs[m]) for m in mCodes])
# 根据配置文件获取最佳交易手数对
self.iniVolume = round(
self.iniAmount / cs[0]["lastPrice"] / cs[0]["contract_multiplier"],
0)
if self.iniVolume == 0: self.iniVolume = 1
# 分参数执行
docs = self.total(dfs, period=self.periodwidth)
if docs is None or len(docs) == 0: return
logger.info((self.codes, self.klineType, len(docs), " time:",
time.time() - time0))
self.Total.insertAll(docs)
def start(self, codes, time0, kt):
print("子进程启动:", self.cindex, codes, kt, time.time() - time0)
self.klineType = kt
# 主力合约
self.codes = codes
self.mCodes = mCodes = [n + '88' for n in codes]
self.baseInfo = {}
self.Rice = interface_Rice()
# 查询获得配置 - 费率和每手单量
self.Base = future_baseInfo()
for doc in self.Base.getInfo(codes):
self.baseInfo[doc["code"] + '88'] = doc
cs0, cs1 = self.baseInfo[mCodes[0]], self.baseInfo[mCodes[1]]
# 子进程共享类
self.Rice.setTimeArea(cs0["nightEnd"])
self.Total = stock_uniform()
self.Total.tablename = self.total_tablename
if kt[-1]=='m':
self.startDate = public.getDate(diff=-200)
# 查询获得N分钟K线
dfs = self.Rice.kline(mCodes, period=self.klineType, start=self.startDate, end=self.endDate, pre=60)
doc = self.total(dfs, kt)
if doc is not None :
self.Total.insert(doc)
def getDf(self, codes, period='1d'):
Rice = interface_Rice()
Rice.setIndexList(self.indexCodeList)
Base = future_baseInfo()
BI = BaseInfo([])
if len(codes) == 0:
codes = Base.getUsedMap(hasIndex=True)
mCodes = Rice.getMain(codes)
dfs = Rice.kline(mCodes,
period=period,
start=public.getDate(diff=-10),
pre=200)
i = 0
for mcode in mCodes:
c = codes[i]
last = BI.att(c, 'nightEnd')[0:6].replace(':', '')
file = Rice.basePath + 'future_%s_%s_%s.csv' % (
mcode, last, public.getDatetime(style='%Y%m%d_%H%M%S'))
print(mcode, last)
df = dfs[mcode]
df['datetime'] = df.index
df0 = df[df['datetime'] > '2019-01-17 13:47:40.000']
print(df0.index, len(df0))
#df.to_csv(file, index=0)
i += 1
break
def seperate(self):
Base = future_baseInfo()
codes = Base.getUsedMap(hasIndex=True, isquick=True)
dd = str(public.getTime(style='%H:%M:%S'))
maps = {}
# 按结束时间分组分进程
for doc in Base.getInfo(codes):
if doc['code'] in self.banCodeList: continue
uid = self.uidStyle % (doc['code'], doc['quickkline'][:-1],
self.methodName)
self.future_Map.append(uid.split("_"))
key = doc['nightEnd']
if '03:00:00' < key < dd: continue
if key not in maps.keys():
maps[key] = []
maps[key].append(doc['code'])
for key in maps.keys():
if len(maps[key]) < 10:
yield maps[key]
else:
l, t = len(maps[key]), len(maps[key]) // 10
for i in range(t):
s, e = i * 10, l if (i + 1) * 10 > l else (i + 1) * 10
yield maps[key][s:e]
def Pool(self):
time0 = time.time()
pool = Pool(processes=5)
self.empty()
Base = future_baseInfo()
# 交易量大的，按价格排序, 类型:turple,第二位为夜盘收盘时间
lists = Base.all(vol=120)
pool.apply_async(self.start, (codes, time0, kt))
for rs in list(itertools.combinations(lists, 2)):
# 检查时间匹配
codes = [rs[0][0], rs[1][0]]
#if 'SC' not in codes: continue
for kt in self.klineTypeList:
#self.start(codes, time0, kt)
try:
pool.apply_async(self.start, (codes, time0, kt))
pass
except Exception as e:
print(e)
continue
#break
pool.close()
pool.join()
def start(self, codes, time0, kt, shareDict):
print("子进程启动:", self.cindex, codes, time.time() - time0)
self.klineType = kt
# 主力合约
self.codes = codes
self.mCodes = mCodes = [n + '88' for n in codes]
# 查询获得配置 - 费率和每手单量
self.Base = future_baseInfo()
for doc in self.Base.getInfo(codes):
self.baseInfo[doc["code"] + '88'] = doc
cs0, cs1 = self.baseInfo[mCodes[0]], self.baseInfo[mCodes[1]]
if cs0["nightEnd"] != cs1["nightEnd"]: return None
# 计算tick 导致的滑点
sh = [self.baseInfo[d + '88']['tick_size'] for d in codes]
# 子进程共享类
self.Rice = tick_csv_Rice()
self.Train = train_future()
self.Total = train_total()
self.Total.tablename = self.total_tablename
# 查询获得N分钟K线
dfs_l = self.Rice.kline(mCodes,
period=self.klineType,
start=self.startDate,
end=self.endDate)
# 获得1分钟K线作为滚动线
dfs = self.Rice.kline(mCodes,
period='1m',
start=self.startDate,
end=self.endDate)
# 按时间截取并调整
dfs = self.dateAdjust(codes, dfs, sh)
print('kline load:', mCodes, len(dfs[mCodes[0]]), len(dfs[mCodes[1]]))
# 根据配置文件获取最佳交易手数对
self.iniVolume = round(
self.iniAmount / cs0["lastPrice"] / cs0["contract_multiplier"], 0)
# 分参数执行
results = []
for period in self.periodList:
for scale in self.scaleList:
for ss in self.shiftScaleList:
self.shiftScale = ss
self.shift = [sh[i] * ss for i in range(len(sh))]
doc = self.total(dfs, dfs_l, scale=scale, period=period)
if doc is None or doc['amount'] == 0: continue
logger.info((doc['uid'], doc['income'], " time:",
time.time() - time0))
results.append(doc)
# 结果写入共享阈
#shareDict.append(doc)
self.Total.insertAll(results)
def Pool(self):
time0 = time.time()
pool = Pool(processes=4)
shareDict = Manager().list([])
Base = future_baseInfo()
# 交易量大的，按价格排序, 类型:turple,第二位为夜盘收盘时间
lists = Base.all(vol=300)
print(len(lists), lists)
#for rs in list(itertools.combinations(lists, 1)):
for rs in lists:
# 检查时间匹配
#if rs[0][1] != rs[1][1]: continue
codes = [rs[0]]
for kt in self.klineTypeList:
#self.start(codes, time0, kt, shareDict)
try:
pool.apply_async(self.start, (codes, time0, kt, shareDict))
pass
except Exception as e:
print(e)
continue
pool.close()
pool.join()
def Pool(self):
time0 = time.time()
pool = Pool(processes=4)
shareDict = Manager().list([])
self.empty()
Base = future_baseInfo()
# 交易量大的，按价格排序, 类型:turple,第二位为夜盘收盘时间
lists = Base.all(vol=700)
tops, exists = self.tops()
for rs in list(itertools.combinations(lists, 2)):
# 检查时间匹配
if rs[0][1] != rs[1][1]: continue
codes = [rs[0][0], rs[1][0]]
if self.topUse and codes not in tops:
continue
if self.isKeeping and codes in exists:
continue
for kt in self.klineTypeList:
#self.start(codes, time0, kt, shareDict)
try:
pool.apply_async(self.start, (codes, time0, kt, shareDict))
pass
except Exception as e:
print(e)
continue
pool.close()
pool.join()
def Pool(self):
time0 = time.time()
pool = Pool(processes=self.processCount)
shareDict = Manager().list([])
Base = future_baseInfo()
# 交易量大的，按价格排序, 类型:turple,第二位为夜盘收盘时间
lists = Base.all(vol=280)
tops = self.tops()
# 清空数据库
self.empty()
for rs in lists:
# 检查时间匹配
codes = [rs[0]]
if self.topUse and codes not in tops: continue
print(rs)
if codes[0] not in ['JM', 'SM', 'RB', 'AP', 'JD']: continue
for kt in self.klineTypeList:
#self.start(codes, time0, kt, shareDict)
try:
pool.apply_async(self.start, (codes, time0, kt, shareDict))
pass
except Exception as e:
print(e)
continue
pool.close()
pool.join()
def start(self, codes, time0, kt, shareDict):
print("子进程启动:", self.cindex, codes, time.time() - time0)
self.klineType = kt
# 主力合约
self.codes = codes
self.mCodes = mCodes = [n + '88' for n in codes]
# 查询获得配置 - 费率和每手单量
self.Base = future_baseInfo()
for doc in self.Base.getInfo(codes):
self.baseInfo[doc["code"] + '88'] = doc
cs0 = self.baseInfo[mCodes[0]]
# 计算tick 导致的滑点
sh = [self.baseInfo[d + '88']['tick_size'] for d in codes]
self.shift = [sh[i] * self.shiftScale for i in range(len(sh))]
# 子进程共享类
self.Rice = tick_csv_Rice()
self.Rice.setTimeArea(cs0["nightEnd"])
self.Train = train_future()
self.Total = train_total()
self.Total.tablename = self.total_tablename
# 查询获得N分钟K线
dfs_l = self.Rice.kline(mCodes,
period=self.klineType,
start=self.startDate,
end=self.endDate,
pre=60)
# 获得1分钟K线作为滚动线
dfs = self.Rice.kline(mCodes,
period='1m',
start=self.startDate,
end=self.endDate,
pre=0)
# 按时间截取并调整
# dfs= self.dateAdjust(codes, dfs, sh)
print('kline load:', mCodes, len(dfs[mCodes[0]]))
# 根据配置文件获取最佳交易手数对
self.iniVolume = round(
self.iniAmount / cs0["lastPrice"] / cs0["contract_multiplier"], 0)
# 分参数执行
results = []
for period in self.periodList:
docs = self.total(dfs, dfs_l, period=period)
if docs is None or len(docs) == 0: continue
logger.info(
(self.codes, period, self.klineType, len(docs), " time:",
time.time() - time0))
results.extend(docs)
# 结果写入共享阈
self.Total.insertAll(results)
def seperate(self):
Base = future_baseInfo()
maps, codes = {}, []
dd = str(public.getTime(style='%H:%M:%S'))
# 按结束时间分组分进程
for doc in Base.getInfo(self.combinCode()):
key = key0 = doc['nightEnd']
if '03:00:00' < key0 < dd: continue
if '08:30:00' < dd < '15:00:00':
key = '15:00:00' if '09:00:00' < key0 < '15:30:00' else '23:30:00' if '15:30:00' < key0 < '23:35:00' else '02:30:00'
pass
if key not in maps.keys():
maps[key] = []
maps[key].append(doc['code'])
pc = 11
for key in maps.keys():
if len(maps[key]) < pc + 1:
yield maps[key]
else:
l, t = len(maps[key]), len(maps[key]) // pc
for i in range(t + 1):
s, e = i * pc, l if (i + 1) * pc > l else (i + 1) * pc
if s < e:
yield maps[key][s:e]
def Pool(self):
time0 = time.time()
# 清空数据库
self.switch()
pool = Pool(processes=self.processCount)
#share = Manager2()
Base = future_baseInfo()
lists = Base.getUsedMap(hasIndex=False,
isquick=False) + ['PB', 'SN', 'CY']
print(len(lists))
for rs in lists:
# 检查时间匹配
#if not rs in self.csvList: continue
codes = [rs]
for kline in self.klineList:
# try:
self.start(codes, time0, kline)
#pool.apply_async(self.start, (codes, time0, kline))
# except Exception as e:
# print(e)
# continue
pool.close()
pool.join()
def getList(self, type=0):
"""
查询获取可交易的合约模式
"""
lists = []
if type == 0:
# 主力合约模式
Base = future_baseInfo()
res = Base.getUsedMap(hasIndex=False, isquick=False) + ['PB', 'SN', 'CY']
lists = [
{'code': d[0] + '88',
'name': d[0],
'startdate': self.startDate,
'enddate': self.endDate,
} for d in res]
elif type == 1:
# 与SG完全对应合约模式
Order = future_orderForm()
Order.tablename = 'future_orderForm_sg'
lists = Order.sg_codes()
elif type == 2:
# 非主力合约模式
Order = future_code()
lists = Order.getMap(start=self.startDate, end=self.endDate)
return lists
def getCtpCode(self, mCode):
t = ''.join(re.findall(r'[0-9]', mCode))
c = mCode.replace(t, '')
Base = future_baseInfo()
doc = Base.getInfo([c])[0]
ctp = doc['ctp_symbol'].split("_")
sym = ctp[0] + t[-int(ctp[1]):]
return sym
def Pool(self):
time0 = time.time()
# 清空数据库
self.empty()
self.Base = future_baseInfo()
self.Cat = self.category()
for kline in self.klineList:
self.start(kline)
pass
def top(self, mode=0):
if mode == 0:
Total = train_total()
Total.tablename = self.total_tablename
rs = Total.last_top(10, maxsames=10, minRate = 0.02)
return [l[0] for l in rs]
elif mode==1:
Base = future_baseInfo()
return [ n[0] for n in Base.all(vol=300)]
def stage_jump(self):
Base = future_baseInfo()
# 交易量大的，按价格排序, 类型:turple,第二位为夜盘收盘时间
Rice = interface_Rice()
codes = [l[0] for l in Base.all(vol=100)]
mCodes = Rice.getMain(codes)
docs, res, doc = [], [], {}
period = '5'
for i in range(len(codes)):
klines = Rice.kline([mCodes[i]],
period='%sm' % period,
start=public.getDate(diff=-10))
df = klines[mCodes[i]].dropna().reindex()
print('width15: ', i, codes[i], mCodes[i], len(df))
if len(df) > 0:
# 计算跳空幅度和跳空前趋势
df['date'] = df.index
df['time'] = df['date'].apply(lambda x: str(x)[11:].strip())
sum, c = 0, 0
for j in range(1, len(df)):
if df.ix[j, 'time'] in ['09:05:00', '21:05:00']:
s0, e0, s1, e1 = df.ix[j - 1, 'open'], df.ix[
j - 1, 'close'], df.ix[j, 'open'], df.ix[j,
'close']
income = np.sign(e0 - s0) * (s1 - e0)
if income != 0:
docs.append({
'date': df.ix[i, 'date'],
'open': s0,
'close': e0,
'open1': s1,
'income': income
})
sum += income
c += 1
#break
res.append({
'code': codes[i],
'sum': sum,
'rate': sum / df['close'].mean(),
'count': c
})
print(codes[i], sum, sum / df['close'].mean(), c)
df0 = pd.DataFrame(docs)
df0.to_csv(self.Rice.basePath + 'stage_jump_detail_%s.csv' % period)
pd.DataFrame(res).to_csv(self.Rice.basePath +
'stage_jump_total_%s.csv' % period)
def tickList(self, long = 8):
Base = future_baseInfo()
l = []
files = os.listdir(self.basePath)
ticks = [file[0:-8] for file in files]
for c in Base.all(vol=400):
if c in ticks:
l.append(c)
return l
def his(self):
self.Rice = Rice = interface_Rice()
Base = future_baseInfo()
bCode = future_code()
bCode.empty()
years = [str(y)[-2:] for y in range(2010, 2021)]
months = [('0' if m < 10 else '') + str(m) for m in range(1, 13)]
lists = Base.getUsedMap(hasIndex=True)
for c in lists:
docs = []
mains = Rice.getAllMain(c, start='2010-01-01')
mainMap = {}
# 主力合约日期清单
for ma in mains:
mainMap[ma[1]] = str(ma[0])
# 第一个主力合约的初始交易量
mVol = self.getVol(mains[0][1], str(mains[0][0]))
# 循环查询合约交易
for y in years:
for m in months:
mcode = '%s%s%s' % (c, y, m)
obj = Rice.detail(mcode)
if obj is not None:
doc = obj.__dict__
mC = doc['order_book_id']
doc.update({
'code': mC,
'name': doc['underlying_symbol'],
})
d, de, v = self.getUsedVol(mC,
start=doc['listed_date'],
end=doc['de_listed_date'],
mVol=mVol)
if d is not None:
doc['used_date'], doc['de_used_date'], doc[
'used_volume'] = d, de, v
if mC in mainMap:
doc['main_date'] = mainMap[mC]
doc['used_volume'] = mVol = self.getVol(
mC, mainMap[mC])
docs.append(doc)
print(doc['name'], len(docs))
time.sleep(0.2)
bCode.insertAll(docs)
def getMainMap(self):
# 查询获得code活动代码及映射表
lists = future_baseInfo().getUsedMap(hasIndex=False) + ['PB', 'SN']
self.mCodes = self.getMain(lists)
i, cmap = 0, {}
for m in self.mCodes:
cmap[lists[i]] = m
i += 1
df = self.allCodes('Future')
df = df[df['underlying_symbol'].isin(lists)
& (df['listed_date'] != '0000-00-00')]
df['mcode'] = df['underlying_symbol'].apply(lambda x: cmap[x])
return df
def pool(self, func=None):
print(1222)
self.Rice = Rice = interface_Rice()
self.Rice.setIndexList(self.indexCodeList)
self.Base = Base = future_baseInfo()
self.Tick = mon_tick()
codes = Base.getUsedMap(hasIndex=True)
BI = BaseInfo(codes)
mCodes = Rice.getMain(codes)
period = 14
self.count = count = 300
self.preDict = {}
self.exKtype = self.getKtype()
self.renewQuicktype()
self.klines = self.quickPeriodList + self.periodList
docs, ex, trends = [], [], []
for mcode in mCodes:
print(mcode)
code = BI.parseCode(mcode)
nt = BI.att(code, 'nightEnd')
Rice.setTimeArea(BI.att(code, 'nightEnd'))
doc, base = {"code": code}, 1
for ktype in self.klines:
start = self.getStart(nt, ktype)
df0 = Rice.kline([mcode], period=ktype, start=start,
pre=0)[mcode]
if func is not None:
res = func(df0, period)
if isinstance(res, dict):
doc.update({'kline': res})
else:
doc.update({
'k_' + ktype: res,
'r_' + ktype: res / base
})
if ktype == self.quickPeriodList[0]:
doc.update({'r_' + ktype: 1})
base = res
docs.append(doc)
if len(docs) > 0:
#columns = [ ('k_'+ k, 'r_'+ k) for k in (self.klines)]
self.saveCsv(docs, 'atrCompare_%s_.csv')
def baseUpdate(self):
df = rq.all_instruments(type='Future', date=public.getDate())
u = df["underlying_symbol"].unique()
FT = future_baseInfo()
# 已有code及结束时间
exists = FT.exists()
exCodes = [c[0] for c in exists]
endMap = {}
for c in exists:
endMap[c[0]] = c[1]
docs = []
mu = self.getMain(u)
i = 0
for d in u:
n = df[df["underlying_symbol"] ==
d].loc[:, FT.keylist[2:]].values[-1].tolist()
doc = FT.set([d, 0] + n)
detais = rq.instruments(mu[i])
# tick_size
doc["tick_size"] = detais.tick_size()
doc['contract_multiplier'] = detais.contract_multiplier
doc['margin_rate'] = detais.margin_rate
# 结束时间
hh = detais.trading_hours.split(',')
hs = hh[0].split('-')
if hs[0][0:2] != '09':
doc["nightEnd"] = hs[1]
else:
doc["nightEnd"] = hh[-1].split('-')[1]
if d not in exCodes:
doc['product'] = 'Commodity'
docs.append(doc)
else:
# 更新结束时间
if doc["nightEnd"] != endMap[d][0:len(doc["nightEnd"])]:
print(d, endMap[d][0:len(doc["nightEnd"])],
doc["nightEnd"])
FT.setMulti(doc)
i += 1
if len(docs) > 0:
FT.insertAll(docs)
logger.info(('future base update finished, ', docs))
def start(self, full_codes, shareDict):
# 每个进程单独初始化对象
self.Record = future_orderForm()
self.Rice = interface_Rice()
self.Base = future_baseInfo()
#self.CTP = interface_pyctp()
self.shareDict = shareDict
self.full_codes = full_codes
# 子进程中共享变量
self.isOpen, self.batchId, self.preNode, self.isStop = {}, {}, {}, {}
# 配置文件
for doc in self.Base.getInfo(full_codes):
self.config[doc["code"]] = doc
# 设置交易对的收盘时间
self.Rice.setTimeArea(doc["nightEnd"])
# 查询主力代码，并存入字典
full_mCodes = self.Rice.getMain(full_codes)
self.mCodeMap = {}
for i in range(len(full_codes)):
self.mCodeMap[full_codes[i]] = full_mCodes[i]
# 初始化订单状态和batchID
self.kTypeMap = {}
openMap = self.Record.getOpenMap(self.methodName, full_codes)
for map in self.future_Map:
if map[0] not in full_codes or map[1] not in full_codes: continue
self.iniNode(map, openMap)
# 按k线时间框类型初始化 kTypeMap dict,
ktype = int(map[4])
if not ktype in self.kTypeMap.keys():
self.kTypeMap[ktype] = []
for i in [0, 1]:
if not self.mCodeMap[map[i]] in self.kTypeMap[ktype]:
self.kTypeMap[ktype].append(self.mCodeMap[map[i]])
# 子进程启动
logger.info(("model_future_detect start: %s " % ",".join(full_mCodes),
self.Rice.TimeArea))
self.Rice.startTick(full_mCodes, callback=self.onTick)
def seperate(self):
Base = future_baseInfo()
maps, codes = {}, []
dd = str(public.getTime(style='%H:%M:%S'))
# 按结束时间分组分进程
for doc in Base.getInfo(self.combinCode()):
key = doc['nightEnd']
#
if '03:00:00' < key < dd: continue
if key not in maps.keys():
maps[key] = []
maps[key].append(doc['code'])
for key in maps.keys():
yield maps[key]
def config(self):
# baseConfig信息
Base = future_baseInfo()
tmp = []
for doc in Base.getInfo(self.Instruments):
self.InstrumentMap[doc['code']] = doc
tmp.append(doc['code'])
# 空所有
if len(self.Instruments) == 0:
self.Instruments = tmp
# 根据code返回主力code，同时生成ctp-code map
for m in self.Rice.getMain(self.Instruments):
c = self.parseCode(m)
self.InstrumentMap[c]['mCode'] = m
self.InstrumentMap[c]['ctp'] = self.parseCtpCode(m)
def start(self, codes, klinePeriod, time0, shareDict):
print("子进程启动:", codes, time.time()-time0)
self.Rice = interface_Rice()
self.Train = train_future()
self.Train.tablename = self.detail_tablename
self.codes = codes
self.Base = future_baseInfo()
self.Total = train_total()
self.Total.tablename = self.total_tablename
# 主力合约
self.mCodes = mCodes = [n +'88' for n in codes]
self.klinePeriod = klinePeriod
# 查询获得分钟K线
dfs = self.Rice.kline(mCodes, period= klinePeriod, start=self.startDate, end=self.endDate)
print("kline load", self.mCodes)
# 查询获得配置 - 费率和每手单量
i= 0
for doc in self.Base.getInfo(codes):
self.baseInfo[doc["code"]+'88'] = doc
self.shift = doc["tick_size"] * self.shiftRatio
i+=1
# 分参数执行
res = []
for period in self.periodList:
for scale in self.scaleList:
for deltaline in self.widthDeltaLineList:
self.widthDeltaLine = deltaline
doc = self.total(dfs[mCodes[0]], scale=scale, period=period)
if doc is None: continue
doc.update({
"code": codes[0],
# "code1": codes[1],
})
logger.info((doc['uid'], doc['count'], doc['income'], " time:", time.time() - time0))
res.append(doc)
# 结果写入共享阈
#shareDict.append(doc)
self.Total.insertAll(res)
def order(code):
Rice = interface_Rice()
codes = [code]
Base = future_baseInfo()
config = [doc for doc in Base.getInfo(codes)][0]
mcodes = Rice.getMain(codes)
k = Rice.kline(mcodes)
# print(k)
doc = {
"code": mcodes[0],
"price": k[mcodes[0]]["close"].values[-1],
"vol": 1,
"mode": 1,
"isopen": 1,
"exchange": config["exchange"]
}
return doc
def start(self, codes, share):
print("子进程:", codes)
self.time0 = time0 = time.time()
self.Base = future_baseInfo()
self.Rice = tick_csv_Rice()
self.Rice.shareDict = share
self.Rice.basePath = self.basePath
self.Rice.cvs_start = self.cvs_start
self.Rice.cvs_end = self.cvs_end
self.Rice.dd = self.dd
self.new_docs = []
self.codes = codes
self.baseInfo = {}
self.filePath = self.basePath + "%s.csv" % "_".join(codes)
# 查询获得配置 - 费率和每手单量
for doc in self.Base.getInfo(codes):
self.baseInfo[doc["code"]] = doc
cs0, cs1 = self.baseInfo[codes[0]], self.baseInfo[codes[1]]
if cs0["nightEnd"] != cs1["nightEnd"]: return None
# 设置结束时间,用于数据清洗
try:
res = self.Rice.curKlineByCsv(codes, period=1, callback=self.new_tick)
except Exception as e:
print('error', codes, len(self.new_docs), e )
res = True
if res and len(self.new_docs) > 0 :
# 保存文件
df = pd.DataFrame(self.new_docs)
# 数据整理
df = self.detail(df)
print(public.getDatetime(), " 已保存", codes, "耗时:", time.time()-time0)
df.to_csv(self.filePath, columns=self.columns1, index=0)
self.new_docs= []
return True
def filterCodes(self):
# 查询每周统计表
if self.topUse:
Top = train_total()
Top.tablename = self.topTableName
self.future_Map = Top.last_top1(num=self.topNumbers,
method=self.methodName,
minVol=self.minVol,
ban=self.banCodeList)
else:
Base = future_baseInfo()
codes = Base.getUsedMap(hasIndex=len(self.indexCodeList) > 0)
for code in codes:
if not code in self.banCodeList:
uid = self.uidStyle % (code, self.methodName)
# if code in ['IC']: print(uid)
self.future_Map.append(uid.split("_"))
num0 = len(self.future_Map)
Record = future_orderForm()
if not self.isWorking: Record.tablename = self.orderFormTest
# 添加未平仓，并不再开仓
codesList = [c[0] for c in self.future_Map]
# 当前开仓清单
openCodes = Record.currentOpenCodes(method=self.methodName,
batchNum=self.batchNum)
if openCodes is not None:
for map in openCodes:
if not map[0] in codesList and not map[0] in self.banCodeList:
self.future_Map.append(map[:-3])
self.noneUsed.append(map[0])
# 调仓处理
dd = str(public.getTime(style='%H:%M:%S'))
if "10:15:00" < dd < "11:00:00":
self.alterPosition(Record, openCodes)
logger.info(('总监控币对：', len(self.future_Map), ' 新列表:', num0, ' 未平仓:',
len(self.noneUsed)))
logger.info(([n[0] for n in self.future_Map]))
logger.info(('暂停币对:', len(self.noneUsed), [n for n in self.noneUsed]))
def seperate(self):
Base = future_baseInfo()
maps, codes = {}, []
# 合并元素
for n in self.future_Map:
for i in [0, 1]:
if not n[i] in codes:
codes.append(n[i])
# 按结束时间分组分进程
for doc in Base.getInfo(codes):
key = doc['nightEnd']
if key not in maps.keys():
maps[key] = []
maps[key].append(doc['code'])
for key in maps.keys():
yield maps[key]
