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 listen(self, main):
listener = Listener(self.address, authkey=self.authkey)
Train = train_future()
Total = train_total()
Total.tablename = self.total_tablename
Train.tablename = self.detail_tablename
while True:
conn = listener.accept()
data = conn.recv()
if 'end' in data and data['end']==1:
print('------------end-------------')
conn.close()
break
result=b'0'
try:
if data[0]==0:
Total.insertAll(data[1])
else:
Train.insertAll(data[1])
result = b'1'
conn.send_bytes(result)
except Exception as e:
print(e)
conn.send_bytes(result)
finally:
conn.close()
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, 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 empty(self):
if self.isEmptyUse :
Train = train_future()
Total = train_total()
Total.tablename = self.total_tablename
Train.tablename = self.detail_tablename
Train.empty()
Total.empty()
def empty(self):
if self.isEmptyUse:
Train = train_future()
Total = train_total()
Total.tablename = self.total_tablename
Train.tablename = self.detail_tablename
Train.empty()
Total.empty()
if self.savePoint:
TrainOrder = mon_trainOrder()
TrainOrder.drop(self.stage)
print("empty mongodb trainOrder", self.stage)
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 pool(self):
self.Rice = interface_Rice()
# 临时sql
self.Tmp = option_tmp()
if self.isNewTmp:
self.Tmp.empty()
self.saveETF()
#
self.Train = train_future()
self.Train.tablename = self.detail_tablename
self.Train.empty()
Option = data_Option_Rice()
for m in ['C', 'P']:
# 查询获得期权列表，以{code: expareDate} 字典表返回
codeList = Option.allCodes(mode=m)
self.start(codeList, m)
def detect(self, df0, period=14, uid=''):
docs = self.stageApply(df0, period=period, uid=uid)
res = pd.DataFrame(docs)
if len(res) > 0:
if self.saveDetail:
if docs is not None:
if self.isPool:
conn = Client(self.address, authkey=self.authkey)
conn.send([1, docs])
conn.close()
else:
Train = train_future()
Train.tablename = self.total_tablename
Train.insertAll(docs)
#self.Train.insertAll(docs)
diff = res[res['diff'] > 0]['diff'].mean()
self.testDays = public.dayDiff(self.endDate, self.startDate)
# 计算最大回测
sum = res['income'].cumsum() + self.iniAmount
inr = res['income'] / self.iniAmount
# 计算夏普指数
sha = (res['income'].sum() / self.iniAmount - 0.02 * self.testDays / 252) / inr.std()
doc = {
"count": int(len(docs) / 2),
"amount": self.iniAmount,
"price": res['price'].mean(),
"income": res["income"].sum(),
# "delta": res['delta'].mean(),
"maxdown": ((sum.shift(1) - sum) / sum.shift(1)).max(),
"sharprate": sha,
"timediff": int(0 if np.isnan(diff) else diff)
}
#print(self.code, doc['count'], doc['income'])
return doc
else:
return None
def start(self, codes, klinePeriod, time0, shareDict):
print("子进程启动:", codes, time.time()-time0)
self.Rice = interface_Rice()
self.Train = train_future()
self.Base = future_baseInfo()
self.Total = train_total()
self.Total.tablename = self.total_tablename
self.Train.tablename = self.detail_tablename
# 主力合约
self.mCodes = codes
self.klinePeriod = klinePeriod
# 查询获得分钟K线
dfs = self.Rice.kline(codes, period= klinePeriod, start=self.startDate, end=self.endDate)
print("kline load", self.mCodes)
# 查询获得配置 - 费率和每手单量
self.shift = 0.001 * self.shiftRatio
# 分参数执行
res = []
for period in self.periodList:
for scale in self.scaleList:
for deltaline in self.widthDeltaLineList:
self.widthDeltaLine = deltaline
doc = self.total(dfs[codes[0]], scale=scale, period=period)
if doc is None: continue
doc.update({
"code": codes[0],
# "code1": codes[1],
})
logger.info((doc, " time:", time.time()-time0))
res.append(doc)
# 结果写入共享阈
#shareDict.append(doc)
self.Total.insertAll(res)
def start(self, kline):
# 主力合约
self.codes = codes = self.Cat['shortList'] + self.Cat['longList']
self.mCodes = mCodes = [n + '88' for n in self.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.Rice = 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.klineType = kline
# 查询获得N分钟K线
print(self.startDate, self.endDate)
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.total(dfs)
def subInit(self, codes, time0, kline=None, Base=None, Rice=None):
self.codes = codes
self.Rice = Rice if Rice is not None else interface_Rice()
# 查询获得配置 - 费率和每手单量
self.Base = future_baseInfo() if Base is None else Base
self.BS = {}
for doc in self.Base.getInfo(codes):
self.BS[doc["code"]] = doc
cs = [self.BS[m] for m in codes]
self.Rice.setTimeArea(cs[0]["nightEnd"])
# 根据配置文件获取最佳交易手数对
self.iniVolume = round(
self.iniAmount / cs[0]["lastPrice"] / cs[0]["contract_multiplier"],
0)
if self.iniVolume == 0: self.iniVolume = 1
#
self.Train = train_future()
self.Total = train_total()
self.Total.tablename = self.total_tablename
self.Train.tablename = self.detail_tablename
def start(self, rs, time0, kline=None):
"""
子进程入口
"""
print("子进程启动:", self.cindex, rs, kline)
self.Rice = interface_Rice()
##### 子程序初始化
self.codes = codes = [d['name'] for d in rs]
if self.sourceListType == 1:
self.mCodes = mCodes = [self.Rice.id_convert(d['code']) for d in rs]
self.ctpCode = rs[0]['code']
else:
self.mCodes = mCodes = [d['code'] for d in rs]
self.ctpCode = rs[0]['code']
# 单一合约
self.code, self.mCode = self.codes[0], self.mCodes[0]
self.iniVolume = 0
if 'startdate' in rs[0]:
self.startDate = str(rs[0]['startdate'])[:10]
self.endDate = str(rs[0]['enddate'])[:10]
if 'iniVolume' in rs[0]:
self.iniVolume = rs[0]['iniVolume']
self.klineType = kline
self.Train = train_future()
self.Total = train_total()
self.Total.tablename = self.total_tablename
self.Train.tablename = self.detail_tablename
self.Base = future_baseInfo()
self.BS = {}
# 查询获得配置 - 费率和每手单量
for doc in self.Base.getInfo(codes):
self.BS[doc["code"]] = self.BS[self.mCode] = doc
cs = [self.BS[m] for m in self.mCodes]
# 子进程共享类
self.Rice.setTimeArea(cs[0]["nightEnd"])
if len(self.indexCodeList) > 0:
self.Rice.setIndexList(self.indexCodeList)
""""
-------------- 调用sub程序 -----------------
"""
# 查询获得N分钟K线
dfs = self.Rice.kline(mCodes, period=self.klineType, start=self.startDate, end=self.endDate, pre=1)
print('kline load:', mCodes, self.startDate, self.endDate, [len(dfs[m]) for m in mCodes])
# 分参数执行
docs = self.total(dfs, period=self.periodwidth)
if docs is None or len(docs) == 0: return
logger.info((self.mCodes, self.klineType, docs[0]['count'], docs[0]['income'], ''" time:", time.time() - time0))
self.Total.insertAll(docs)
# 关闭连接
self.Total.closecur()
def getExistCodes(self):
Record = train_future()
Record.tablename = self.tablename
long = len(self.uidKey)
return Record.exitCodes(long=long - 2)
def start(self, map, kPeriod, shareDict):
# 每个进程单独初始化对象
self.time0 = time.time()
self.Record = train_future()
# 数据库存储
self.Record.tablename = self.tablename
self.Rice = tick_csv_Rice()
self.Rice.setParam(self.cvsParam)
self.Rice.shareDict = self.shareDict = shareDict
self.Rice.kPeriod = self.kPeriod = kPeriod
self.Base = future_baseInfo()
self.timeArea = [("09:00:00", "11:30:00"), ("13:30:00", "15:00:00")]
self.codes = map[0:2]
# 查询基础配置
for doc in self.Base.getInfo(self.codes):
self.config[doc["code"]] = doc
c0, c1 = self.config[self.codes[0]], self.config[self.codes[1]]
# 设置交易对的收盘时间,用于计算收盘时间并计算止损
self.Rice.setTimeArea(doc["nightEnd"])
# 根据配置文件获取最佳交易手数对
self.iniVolume = round(
self.iniAmount / c0["lastPrice"] / c0["contract_multiplier"], 0)
# 设置shift区间
[t, c] = [[self.config[d][key] for d in self.codes]
for key in ["tick_size", "lastPrice"]]
self.shift = ((c[0] + t[0]) / (c[1] - t[1]) - (c[0] - t[0]) /
(c[1] + t[1])) / self.shiftScale
logger.info(("model_future_detect start: %s " % "_".join(self.codes),
self.uidKey, self.Rice.TimeArea))
# 启动进程
ticks = self.Rice.getTicks(self.codes)
# tick类型选择
if self.tickType != 'none':
ticks = ticks[ticks[self.tickType] == 1]
ticks["p_l"] = ticks["a1"] / ticks["n_b1"]
ticks["p_h"] = ticks["b1"] / ticks["n_a1"]
indexR, records = 0, []
# 及时K线
for index, row in ticks.iterrows():
#print(row["datetime"])
res = self.onTick(row, isdelay=self.tickType != 'isnew')
if len(res) > 0:
records.extend(res)
# 阶段性存入到数据库，并清空
if len(records) > 50:
self.Record.insertAll(records)
indexR += len(records)
print(public.getDatetime(), " insert into record:", self.codes,
self.kPeriod, indexR)
records = []
# 将剩下的写入数据库
if len(records) > 0:
self.Record.insertAll(records)
def start(self, codes, time0, kt, shareDict):
print("子进程启动:", self.cindex, codes, time.time() - time0)
self.Base = future_baseInfo()
self.klineType = kt
self.codes = codes
# 主力合约
self.mCodes = mCodes = [n + '88' for n in codes]
# 查询获得配置 - 费率和每手单量
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
shareDict.append(codes)
# 子进程共享类
self.Rice = interface_Rice()
self.Train = train_future()
self.Train.tablename = self.detail_tablename
self.Total = train_total()
self.Total.tablename = self.total_tablename
# 查询获得分钟K线
dfs = self.Rice.kline(mCodes,
period=self.klineType,
start=self.startDate,
end=self.endDate)
print('kline load:', mCodes, len(dfs[mCodes[0]]), len(dfs[mCodes[1]]))
# 计算tick 导致的滑点
sh = [self.baseInfo[d + '88']['tick_size'] for d in codes]
# 根据配置文件获取最佳交易手数对
self.iniVolume = round(
self.iniAmount / cs0["lastPrice"] / cs0["contract_multiplier"], 0)
self.shift = [sh[i] * self.shiftScale for i in range(len(sh))]
# 分参数执行
results = []
for period in self.periodList:
for scale in self.scaleList:
for conds in self.iterCond():
self.uid = self.uidKey % (
"_".join(self.codes), str(period), str(scale),
self.klineType.replace('m', ''), conds)
self.stopTimeDiff = self.stopTimeLine * period * int(
self.klineType[:-1])
doc = self.total(dfs[mCodes[0]],
dfs[mCodes[1]],
scale=scale,
period=period)
if doc is None and doc['amount'] == 0: continue
logger.info(
(doc['uid'], doc['count'], doc['income'], " time:",
time.time() - time0))
results.append(doc)
self.Total.insertAll(results)
