def test():
obj = interface_Rice()
codes = ['CU1903', 'AU1906', 'IH1902', 'IF1902', 'IC1903']
indexCodeList = [('IH', '000016.XSHG'), ('IF', '399300.XSHE'),
('IC', '399905.XSHE')]
res = obj.setIndexList(indexCodeList)
ss = obj.snap(codes)
print(ss)
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 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
print(self.code, self.klineType)
# 子进程共享类
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)
# 查询获得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.period)
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 __init__(self, codes=[], Rice=None):
self.Instruments = [self.parseCode(c) for c in codes]
self.InstrumentMap = {}
self.Rice = Rice if Rice else interface_Rice()
self.config()
cs = self.Instruments
self.nightEnd = self.att(cs[-1], 'nightEnd') # 收盘时间
self.mainCodes = [self.att(c, 'mCode') for c in cs] # 所有主力合约
self.ctpCodes = [self.att(c, 'ctp') for c in cs] # 所有ctpCode
def allCodes(self, mode='C'):
Rice = interface_Rice()
df = Rice.allCodes(type='Option')
c = df[df['underlying_order_book_id'] ==
'510050.XSHG']['order_book_id'].values[-1]
codeList = {}
for i in range(10000001, int(c) + 1):
s = Rice.detail(str(i))
if s is not None and s.option_type == mode:
codeList[s.order_book_id] = s.maturity_date
return codeList
def start(self, full_codes, Rice=None, CTP=None):
# print(full_codes)
self.Record = future_orderForm()
self.PStatus = future_status()
if not self.isWorking: self.Record.tablename = self.orderFormTest
if self.isTickSave:
self.Tick = mon_tick()
self.Rice = interface_Rice() if Rice is None else Rice
# 基础配置信息类
self.baseInfo = BaseInfo(full_codes, self.Rice)
# ctp 接口类
self.CTP = interface_pyctp(
use=self.isCTPUse, userkey=self.ctpuser) if CTP is None else CTP
self.CTP.baseInfo = self.baseInfo
# 进程控制类
self.procMap = ProcessMap()
# 趋势预测
self.trendMap = self.Record.trendMap(self.relativeMethods)
# 指数期货
self.indexList = [c[0] for c in self.indexCodeList]
# 设置交易对的收盘时间
self.Rice.setTimeArea(self.baseInfo.nightEnd)
if len(self.indexCodeList) > 0:
self.Rice.setIndexList(self.indexCodeList)
# 按k线类型分拆组，进行K线数据调用
self.groupByKline(full_codes)
# 初始化节点
self.iniNode(full_codes)
# 子进程启动
full_mCodes = self.baseInfo.mainCodes # 主力合约
logger.info(("model_future_detect start: %s " % ",".join(full_codes),
self.Rice.TimeArea))
self.Rice.startTick(full_mCodes,
kmap=self.kTypeMap,
timesleep=self.timeInterval,
source=self.sourceType,
callback=self.onTick)
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 __init__(self):
self.Rice = interface_Rice()
self.codes = ['510050.XSHG']
self.period = '30m'
self.timePeriodList = [5, 10, 20, 60]
self.timePeriods = 60
self.iniAmount = 40000
self.multiplier = 10000
self.ratio = 2
self.baisLineList = [0.15, 0.25, 0.35]
self.index_list = ["MA"]
self.startDate = public.getDate(diff=-130) # 60天数据回测
self.endDate = public.getDate(diff=0)
def update_last(self):
Rice = interface_Rice()
Record = stock_orderForm()
res = Record.getPosition(method=self.methodName, codes=None)
codes = [res[c]['code'] for c in res.keys()]
dfs = Rice.snap(codes)
for code in codes:
#print(code, dfs[code]['last'])
Record.update_last(code,
dfs[code]['last'],
batchid=res[code]['batchid'])
Record.closecur()
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 orderStart(self):
self.BI = BaseInfo([])
self.Rice = interface_Rice()
self.Record = future_orderForm()
self.Record.tablename = 'future_orderForm_1'
self.Rice.setIndexList([('IH', '000016.XSHG'), ('IF', '399300.XSHE'),
('IC', '399905.XSHE')])
map = [
['AP', 1, 1, 5, 'mZhao', 11087],
#['IH', 1, 1, 1, 'mZhao55']
]
orderMap = self.getMaps2(map)
self.addOrder(orderMap)
def start(self, pic, Rice, Base, code):
print(pic, code)
self.code = code
Rice = interface_Rice()
time0 = time.time()
k = 0
while True:
df = Rice.getTicks(code)
self.calc(df)
k += 1
print(k, len(df), time.time() - time0)
if k > 5: break
print(time.time() - time0)
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 __init__(self):
self.Rice = interface_Rice()
self.codes = "159901.XSHE,2159902.XSHE,2159915.XSHE,2510050.XSHG,2510900.XSHG, 2510300.XSHG,2519920.XSHG,\
2512160.XSHG,2512880.XSHG,2512800.XSHG,2510180.XSHG,2512660.XSHG".split(
",")
self.period = '30m'
self.timePeriods = 60
self.iniAmount = 250000
self.ratio = 2
self.startDate = public.getDate(diff=-130) # 60天数据回测
self.endDate = public.getDate(diff=0)
self.Record = sh50_orderForm()
self.Record.tablename = 'sh50_orderForm_train'
self.Record.empty()
self.Price = sh50_price_s()
def start(self, codeList, mode):
self.Rice = interface_Rice()
self.codes = cs = [c for c in codeList.keys()]
res = self.Rice.kline(self.codes,
period=self.period,
start=self.startDate,
end=self.endDate,
pre=1,
type='Option')
df = res[cs[0]]
df['dd'] = df.index
ed = codeList[cs[0]]
df.loc[:,
'monthdiff'] = df['dd'].apply(lambda x: getMonthDay(str(x), ed))
print(df)
def start(self, full_codes):
# print(full_codes)
self.Record = future_orderForm()
if not self.isCTPUse:
self.Record.tablename = 'future_orderForm_1'
self.time0 = time.time()
if self.isTickSave:
self.Tick = mon_tick()
self.Rice = interface_Rice()
# 基础配置信息类
self.baseInfo = BaseInfo(full_codes, self.Rice)
# ctp 接口类
# self.CTP = interface_pyctp(use=self.isCTPUse, baseInfo=self.baseInfo, userkey=self.ctpuser)
# 进程控制类
self.procMap = ProcessMap()
# 设置交易对的收盘时间
self.Rice.setTimeArea(self.baseInfo.nightEnd)
self.indexList = []
if len(self.indexCodeList) > 0:
self.Rice.setIndexList(self.indexCodeList)
self.indexList = [c[0] for c in self.indexCodeList]
# 按k线类型分拆组，进行K线数据调用
self.groupByKline(full_codes)
# 初始化节点
self.iniNode(full_codes)
# return
# 子进程启动
full_mCodes = self.baseInfo.mainCodes # 主力合约
logger.info(
("%s start: %s" % (self.__class__.__name__, ",".join(full_mCodes)),
self.Rice.TimeArea))
self.Rice.startTick(full_mCodes,
kmap=self.kTypeMap,
source='combin',
callback=self.onTick)
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 getMonTick(self, codes=None, method='dema5', num=4000):
Tick = mon_tick()
Rice = interface_Rice()
if codes is None: codes = ['MA', 'A']
diff = -1
for c in codes:
docs = Tick.getTick(c, count=num, method=method)
print(c, len(docs))
if len(docs) > 0:
f = Rice.basePath + "%s_%s.csv" % (c, public.getDate())
r = [d for d in docs]
r.reverse()
df = pd.DataFrame(r)
df.drop(['_id'], axis=1, inplace=True)
try:
df.to_csv(f, index=0)
print("%s output" % f)
except:
continue
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 updateSymbol(self):
if self.symbolList == {}:
self.Base = future_baseInfo()
Rice = interface_Rice()
codes = [c[0] for c in self.Base.all(vol=0)]
mCodes = Rice.getMain(codes)
i = 0
for code in codes:
self.symbolList[code] = mCodes[i].replace(code, '')
i += 1
self.qtySymbolStatus = True
self.qtyInstrument(callback=self.saveSymbol)
while 1:
if not self.qtySymbolStatus:
self.API.close()
self.ee.stop()
break
time.sleep(1)
def start(self, codes, kline, tms):
print((public.getDatetime(), ': start ', codes, kline, tms))
self.Rice = interface_Rice()
self.Record = sh50_orderForm()
self.Record.tablename = 'sh50_orderForm_train'
self.codes = codes
self.Price = sh50_price_s()
self.klineType = kline
self.timePeriods = tms
res = self.Rice.kline(codes,
period=kline,
start=self.startDate,
end=self.endDate)
df = res[codes[0]]
# 计算统一特征
for conds in self.iterCond():
self.uid = "%s_%s_%s_%s" % (codes[0].replace(
'.', '-'), tms, kline[:-1], conds)
df = self.add_stock_index(df, index_list=self.index_list)
df['createTime'] = df.index
saveList = [
'30_5_0.25_1.75', '15_15_0.25_1.75', '15_30_0.25_1.75',
'30_60_0.25_1.75'
]
if self.uid[12:] in saveList:
cs = []
bans = 'ma,bullwidth,open,sard,rsi,high,low,std,top,lower,p_h,p_l,,close,volume,wmean,width,kdj_d2,createTime'.split(
',')
for c in df.columns:
if c not in bans:
cs.append(c)
file = self.Rice.basePath + '%s.csv' % self.uid
df.to_csv(file, index=1, columns=cs)
# print(('start ', self.uid))
self.saveStage(df)
def update_stockBase(self):
# 更新stockBase
Base = stock_baseInfo()
Rice = interface_Rice()
codes = Base.getAllCodes()
#Base.empty()
df0 = Rice.allCodes(type='CS')
df = df0[~df0['order_book_id'].isin(codes)]
#print(df)
df['code'] = df['order_book_id'].apply(lambda x: x[:x.find('.')])
s = Rice.index_compose('000980.XSHG')
df['is50'] = df['order_book_id'].apply(lambda x: 1 if x in s else 0)
df['isST'] = df['symbol'].apply(lambda x: 1
if x.find('*ST') > -1 else 0)
print(len(df))
Base.insertAll(df.to_dict('records'))
def start(self, codes, time0, kt, isPool=True, Rice=None, Base = None):
self.klineType = kt
# 主力合约
self.codes = codes
self.mCodes = mCodes = [n + '88' for n in codes]
self.baseInfo = {}
self.Rice = interface_Rice() if Rice is None else Rice
# 查询获得配置 - 费率和每手单量
self.Base = future_baseInfo() if Base is None else Base
#self.Base = Base
#print(codes, self.Base.tablename)
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"])
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:
if isPool:
conn = Client(self.address, authkey=self.authkey)
conn.send(doc)
#print(conn.recv_bytes())
conn.close()
#Total.insert(doc)
else:
Total = stock_uniform()
Total.tablename = self.total_tablename
Total.insert(doc)
print("子进程启动:", self.cindex, codes, kt, time.time() - time0)
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 control(self):
Rice = interface_Rice()
Rice.TimeArea = self.TimeArea
Base = stock_baseInfo()
#lists = Base.getCodes(isBound=1)
#print(lists[0], len(lists))
lists = self.csvList
logger.info(('model_stock_pop scan list:', len(lists)))
while True:
# 满足时间
valid = Rice.isValidTime()
tt = int(time.time()) // 3
if valid[0]:
self.pool(lists)
# 非交易日和收盘则结束
elif not valid[1]:
break
time.sleep(self.timeInterval)
def create(self):
Rice = interface_Rice()
Base = future_baseInfo()
startdate = '2016-01-01'
# 选用的
used = Base.getUsedMap()
df = Rice.allHisFuture()
u = df["underlying_symbol"].unique()
for c in u:
if not c in used: continue
sdf = df[(df["underlying_symbol"] == c)
& (df["listed_date"] > '2015-01-01')].sort_values(
by='listed_date').reset_index(drop=True)
codes = sdf.loc[:, 'order_book_id']
dfs = Rice.kline(codes, period='1d', start=startdate)
print(sdf)
mcodes = Rice.getAllMain(c, start=startdate)
print(pd.DataFrame(mcodes))
break
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 compare(self, type=''):
if type == 'm':
user = '******'
methods = ['mZhao', 'mZhao55']
else:
user = '******'
methods = ['zhao', 'zhao55']
b = BaseInfo([])
Ctp = interface_pyctp(baseInfo=b, userkey=user)
map = Ctp.posMap
Rice = interface_Rice()
Orders = future_orderForm()
posMap = {}
for pos in Orders.posByCode(methods):
posMap[pos[0]] = pos[1]
if pos[0] in map and pos[1] == map[pos[0]][0]:
print('match ', pos, map[pos[0]])
else:
if pos[0] in map:
print('unmatch ', pos, map[pos[0]])
else:
print('no purchase', pos)
# 检查是否调仓
pCode, name = pos[2], pos[0].split("_")[0]
mCode = Rice.getMain([name])[0]
if pCode != mCode:
print(' --------- Need alter position:', pCode, mCode)
for key in map:
if len(key) < 6 and key not in posMap:
print('no record', key, map[key])
print(len(posMap.keys()))
def subFilter(self, codes, k):
print("stock filter subprocess start:", k / self.pageCount)
Rice = interface_Rice()
Base = stock_baseInfo()
startDate = public.getDatetime(diff=-200)
res = Rice.kline(codes, period=self.period, start=startDate, pre=90)
period = 180
line1 = 0.5
codeList = []
for code in codes:
df = res[code]
# 计算跌幅和回跌幅度
close = df['close']
mx0 = ta.MAX(close, timeperiod=60).values[-1]
last = close.values[-1]
opt0 = (mx0 - last) / mx0 > 0.2
mx = close[-period:].max()
mi = close[-period:].min()
miw = ta.MININDEX(close, timeperiod=period).values[-1]
mid = close[miw:].max()
# 超过M5
ma5 = ta.MA(close, timeperiod=5)
opt1 = (mx - mi) / mx > line1 and (mid - mi) / (
mx - mi) < 0.30 and (mx0 - last) / mx0 > 0.12
opt2 = (last > ma5.values[-1] or last > ma5.values[-2])
if (opt0) or (opt1 and opt2):
codeList.append(code)
print(k, len(codes), len(codeList))
Base.updateBound(codeList)
Base.closecur()
