#从tushare实时获取数据
import tushare as ts
import threading
import time
import pandas as pd
import sys
sys.path.append('..')
from config.Config import Config
from t1.datas.DataHolder import DataHolder
from t1.analyze.Analyze import Analyze
from t1.MyLog import MyLog
from utils.Utils import Utils
from sqlalchemy import create_engine
setting = Config()
engine = create_engine(setting.get_DBurl())
analyze = Analyze()
def get_today_all_codes():
def cb(**kw):
return ts.get_today_all()
df_todayAll = Utils.queryData('today_all',
'code',
engine,
cb,
forceUpdate=False)
return df_todayAll['code']
class NewAnalyze2(object):
def __init__(self):
self.__config = Config()
try:
if self.__config.get_mongo_config()['load_from_mongo']:
self.__mongo_client = pymongo.MongoClient(
self.__config.get_mongo_config()['mongo_url'])
self.__mongo_client.admin.command('ismaster')
self.__config.update_proxy(self.get_t1_from_mongo())
self.__config.get_mongo_config(
)['load_time'] = dt.datetime.now()
except Exception as e:
MyLog.error('can not connect to mongo, %s' % e)
self.__buyedCount = 0
self.__balance = self.__config.get_t1()['trade']['balance']
if self.__config.get_t1()['trade']['enable']:
self.__trade = Trade()
if self.__config.get_t1()['trade']['enableMock']:
self.__mockTrade = MockTrade()
self.__engine = create_engine(self.__config.get_DBurl())
def get_t1_from_mongo(self):
for doc in self.__mongo_client['stocking']['config'].find(
{'t1': {
'$exists': True
}}):
return doc
return None
def update_config_if_needed(self):
try:
if self.__config.get_mongo_config(
)['load_from_mongo'] and self.__config.get_mongo_config(
)['load_time'] is not None and (
dt.datetime.now() -
self.__config.get_mongo_config()['load_time']
).seconds > self.__config.get_mongo_config()['load_interval']:
self.__config.update_proxy(self.get_t1_from_mongo())
self.__config.get_mongo_config(
)['load_time'] = dt.datetime.now()
except Exception as e:
MyLog.error('failed to update config %s ' % e)
def printPerformace(self, timestamp):
deltaSeconds = (dt.datetime.now() - timestamp).seconds
if deltaSeconds > 3:
print('calc more than %s seconds' % deltaSeconds)
def calcMain(self, zs, dh, timestamp, balance, lock):
self.update_config_if_needed()
data = dh.get_data()
finalCode = ''
result = []
codes = []
for code in data:
if not self.hasNewData(data[code]):
continue
if code in dh.get_ignore():
continue
# self.updateStock(data[code],dh)
if code in dh.get_buyed():
#self.cancelBuyIfNeed(data[code],dh,timestamp,lock,balance)
#continue
pass
try:
if self.calc(zs, data[code], dh):
result.append(data[code])
# self.printPerformace(timestamp)
except Exception as e:
last_line = data[code].get_Lastline()
MyLog.error(last_line['time'] + ' :calc ' + code + ' error')
MyLog.error(str(e))
if len(result) != 0:
for stock in result:
try:
last_line = stock.get_Lastline()
return self.outputRes(stock, last_line, timestamp, dh,
balance, lock)
except Exception as e:
MyLog.error('outputRes error %s' % stock.get_code())
MyLog.error(str(e))
def updateStock(self, stock, dh):
self.updateBreak10(stock)
max_amount = stock.get_cache('max_b1_amount')
now_line = stock.get_Lastline()
stop_price = round(float(now_line['pre_close']) * 1.1, 2)
if float(now_line['b1_p']) == stop_price:
now_amount = float(now_line['b1_p']) * self.convertToFloat(
now_line['b1_v']) * 100
if max_amount is None or now_amount > max_amount:
stock.set_cache('max_b1_amount', now_amount)
if stock.get_code() in dh.get_buyed():
last_second_line = stock.get_LastSecondline()
if last_second_line is None or float(
last_second_line['b1_p']) != stop_price:
return
deal_amount = self.convertToFloat(
now_line['amount']) - self.convertToFloat(
last_second_line['amount'])
old_deal_amount = stock.get_cache('deal_amount')
if old_deal_amount is None:
stock.set_cache('deal_amount', [deal_amount])
else:
if len(old_deal_amount) >= 15:
old_deal_amount.pop(0)
old_deal_amount.append(deal_amount)
stock.set_cache('deal_amount', old_deal_amount)
def cancelBuyIfNeed(self, stock, dh, timestamp, lock, balance):
trade = self.__config.get_t1()['trade']
last_second_line = stock.get_LastSecondline()
now_line = stock.get_Lastline()
last_second_buy1_v = self.convertToFloat(last_second_line['b1_v'])
last_second_buy1_amount = float(
last_second_line['b1_p']) * last_second_buy1_v * 100
now_buy1_v = self.convertToFloat(now_line['b1_v'])
now_buy1_amount = float(now_line['b1_p']) * now_buy1_v * 100
stop_price = round(float(now_line['pre_close']) * 1.1, 2)
max_b1_amount = stock.get_cache('max_b1_amount')
deal_amount = self.convertToFloat(
now_line['amount']) - self.convertToFloat(
last_second_line['amount'])
cancel_b1_amount = self.__config.get_t1()['hit10']['cancel_b1_amount']
strTime = time.strftime('%H:%M:%S', time.localtime(time.time()))
if strTime > '13:30:00':
cancel_b1_amount = self.__config.get_t1(
)['hit10']['cancel_b1_amount_1']
if strTime > '14:30:00':
cancel_b1_amount = self.__config.get_t1(
)['hit10']['cancel_b1_amount_2']
if max_b1_amount is None:
max_b1_amount = -1
sum_last_10_deal_amount = 0
last_10_deal_amount = stock.get_cache('deal_amount')
if last_10_deal_amount is not None:
sum_last_10_deal_amount = sum(last_10_deal_amount)
if float(now_line['price']) == stop_price:
if float(now_line['b1_p']) == stop_price and self.convertToFloat(
now_line['a1_v']
) == 0 and (
now_buy1_amount < cancel_b1_amount
or now_buy1_v < last_second_buy1_v *
self.__config.get_t1()['hit10']['cancel_ratio']
or now_buy1_amount < max_b1_amount *
self.__config.get_t1()['hit10']['cancel_ratio_max_amount']
or deal_amount >= now_buy1_amount *
self.__config.get_t1()['hit10']['cancel_deal_amount_ratio']
or sum_last_10_deal_amount > now_buy1_amount *
self.__config.get_t1()['hit10']['max_deal_amount']):
info = '[%s] 在 [%s] 撤单 [%s],b1_v=%s' % (
Utils.getCurrentTime(), str(now_line['date']) + ' ' +
str(now_line['time']), stock.get_code(), now_buy1_v)
MyLog.info(info)
if trade['enable'] or trade['enableMock']:
self.cancelBuy(trade, stock, dh, lock, balance)
# self.printPerformace(timestamp)
@Utils. async
def save_to_excel(self, stock):
try:
now_line = stock.get_Lastline()
df = pd.DataFrame(stock.get_data())
writer = pd.ExcelWriter(
'D:/aqua/stock/stocking/data/result/%s-%s.xlsx' %
(stock.get_code(), now_line['time'].replace(':', '-')))
df.to_excel(writer, 'Sheet1')
writer.save()
except Exception as e:
MyLog.error('save %s error, e = %s' % (stock.get_code(), e))
def cancelBuy(self, trade, stock, dh, lock, balance):
status = -1
if trade['enable']:
try:
lock.acquire()
status = self.__trade.cancel(stock.get_code(), True)
buyMoney = stock.get_cache('buyMoney')
if buyMoney is not None:
balance.value = balance.value + buyMoney
except Exception as e:
pass
finally:
lock.release()
if trade['enableMock']:
buyMoney = stock.get_cache('buyMoney')
if buyMoney is not None:
balance.value = balance.value + buyMoney
status = self.__mockTrade.cancelBuy(stock.get_code())
#cancel success
if status == 0:
MyLog.info('[%s] 撤单成功' % stock.get_code())
now_line = stock.get_Lastline()
now_buy1_v = self.convertToFloat(now_line['b1_v'])
now_buy1_amount = float(now_line['b1_p']) * now_buy1_v * 100
stock.set_cache('cancel_b1_amount', now_buy1_amount)
dh.get_buyed().remove(stock.get_code())
#cancel failed, already buyed
else:
MyLog.info('[%s] 撤单失败' % stock.get_code())
stock.add_cancelTimes()
if stock.get_cancelTimes() >= 2:
dh.add_ignore(stock.get_code())
def outputRes(self, stock, df_final, timestamp, dh, balance, lock):
p = (float(df_final['price']) - float(df_final['pre_close'])) / float(
df_final['pre_close'])
d_price = round(float(df_final['pre_close']) * (1 + p + 0.005), 2)
# d_price = round(float(df_final['price']) + 0.02, 2)
trade = self.__config.get_t1()['trade']
buyVolume = trade['volume']
if trade['dynamicVolume']:
buyVolume = int(trade['amount'] / d_price / 100) * 100
buyMoney = d_price * buyVolume
price = str('%.2f' % d_price)
try:
if lock is not None:
lock.acquire()
if balance is not None and buyMoney > balance.value or buyVolume == 0:
return None
if df_final['code'] in dh.get_buyed():
dh.add_ignore(df_final['code'])
info = '在 %s 以 %s 买入 [%s]%s %s 股' % (
str(df_final['date']) + ' ' + str(df_final['time']), price,
df_final['code'], df_final['name'], str(buyVolume))
MyLog.info(info)
now = dt.datetime.now()
deltaSeconds = (now - timestamp).seconds
if deltaSeconds > trade['timestampLimit']:
MyLog.info('[%s] 行情超时 %s秒 放弃买入' %
(df_final['code'], deltaSeconds))
return None
if trade['enable']:
res = str(
self.__trade.buy(df_final['code'], buyVolume,
float(price)))
if 'entrust_no' in res or 'success' in res:
if balance is not None:
balance.value = balance.value - buyMoney
stock.set_cache('buyMoney', buyMoney)
stock.set_cache('buy_price', d_price)
dh.add_buyed(df_final['code'])
return df_final['code'], str(d_price)
return None
if trade['enableMock']:
res = self.__mockTrade.mockTrade(df_final['code'],
float(price), buyVolume)
if res == 0:
if balance is not None:
balance.value = balance.value - buyMoney
stock.set_cache('buyMoney', buyMoney)
stock.set_cache('buy_price', d_price)
dh.add_buyed(df_final['code'])
return df_final['code'], str(d_price)
return None
stock.set_cache('buy_price', d_price)
dh.add_buyed(df_final['code'])
return df_final['code'], str(d_price)
except Exception as e:
MyLog.error(e)
return None
finally:
if lock is not None:
lock.release()
self.save_to_excel(stock)
# self.printPerformace(timestamp)
def calc(self, zs, stock, dh):
if not self.canCalc(stock, dh):
return False
if stock.get_code() in dh.get_buyed():
try:
return self.is_bc_point(stock, dh)
except Exception as e:
MyLog.error('bc point error %s' % e)
return False
return self.isStockMatch(zs, stock, dh)
def isOpenMatch(self, row):
if float(row['pre_close']) == 0 or float(row['open']) == 0:
return False
return (float(row['open']) - float(row['pre_close'])) / float(
row['pre_close']) * 100 >= -1.5
def hasNewData(self, stock):
lastLine = stock.get_Lastline()
if stock.get_time() == lastLine['time']:
return False
stock.set_time(lastLine['time'])
return True
def canCalc(self, stock, dh):
if stock.len() < 2:
return False
lastLine = stock.get_Lastline()
lastSecondLine = stock.get_LastSecondline()
if float(lastLine['open']) == 0.0 or float(
lastSecondLine['open']) == 0.0:
return False
return True
def convertToFloat(self, str):
if str == '':
return 0
try:
return float(str)
except Exception as e:
MyLog.error('convertToFloat error: ' + str + '\n')
return 0
def isStockMatch(self, zs, stock, dh):
if self.isZSMatch(zs, stock):
if stock.get_cache('ignore_ydls') is None and self.isYDLS(
stock, dh):
return True
try:
return self.is_tail_match(stock, dh)
except Exception as e:
MyLog.error('buy tailed error %s' % e)
return False
def is_tail_match(self, stock, dh):
now_line = stock.get_Lastline()
if now_line['time'] < '14:30:00':
return False
cur_p = self.getCurrentPercent(stock)
if cur_p > self.__config.get_t1()['buy_tail']['p_range'][
1] or cur_p < self.__config.get_t1()['buy_tail']['p_range'][0]:
return False
now_price = self.convertToFloat(now_line['price'])
lowest_price = self.convertToFloat(now_line['low'])
highest_price = self.convertToFloat(now_line['high'])
if now_price == lowest_price or (
now_price - lowest_price) / self.convertToFloat(
now_line['pre_close']) * 100 > self.__config.get_t1(
)['buy_tail']['p_limit_lowest']:
return False
if (highest_price - lowest_price) / self.convertToFloat(
now_line['pre_close']) * 100 < self.__config.get_t1(
)['buy_tail']['high_low_diff']:
return False
datas = stock.get_data()
start = -15
if len(datas) < start * -1:
start = len(datas) * -1
amount = self.convertToFloat(
datas[-1]['buy_amount']) - self.convertToFloat(
datas[start]['buy_amount'])
sell_amount = self.convertToFloat(
datas[-1]['sell_amount']) - self.convertToFloat(
datas[start]['sell_amount'])
amount_ratio = 100
if sell_amount != 0.0:
amount_ratio = amount / sell_amount
tag = amount > self.__config.get_t1(
)['buy_tail']['min_amount'] and amount_ratio > self.__config.get_t1(
)['buy_tail']['amount_ratio']
if tag:
MyLog.info(
'buy tail match : time = %s, lowest_price = %s, buy_amount = %s, sell_amount = %s, amount_ratio = %s'
% (now_line['date'] + ' ' + now_line['time'], lowest_price,
amount, sell_amount, amount_ratio))
return tag
def get_data_time(self, data):
return dt.datetime.strptime(data['date'] + ' ' + data['time'],
'%Y-%m-%d %H:%M:%S')
def is_bc_point(self, stock, dh):
now_line = stock.get_Lastline()
now_second_line = stock.get_LastSecondline()
buyed_price = stock.get_cache('buy_price')
now_price = self.convertToFloat(now_line['price'])
if buyed_price is not None and (
buyed_price - now_price) / self.convertToFloat(
now_line['pre_close']) * 100 < self.__config.get_t1(
)['bc_point']['p_drop']:
return False
lowest_price = stock.get_cache('lowest_price')
if lowest_price is None or lowest_price > now_price:
lowest_price = now_price
stock.set_cache('lowest_price', lowest_price)
if now_price == lowest_price or (
now_price - lowest_price) / self.convertToFloat(
now_line['pre_close']) * 100 > self.__config.get_t1(
)['bc_point']['p_limit_lowest']:
return False
datas = stock.get_data()
start = -15
if len(datas) < start * -1:
start = len(datas) * -1
amount = self.convertToFloat(
datas[-1]['buy_amount']) - self.convertToFloat(
datas[start]['buy_amount'])
sell_amount = self.convertToFloat(
datas[-1]['sell_amount']) - self.convertToFloat(
datas[start]['sell_amount'])
amount_ratio = 100
if sell_amount != 0.0:
amount_ratio = amount / sell_amount
tag = amount > self.__config.get_t1(
)['bc_point']['min_amount'] and amount_ratio > self.__config.get_t1(
)['bc_point']['amount_ratio']
if tag:
MyLog.info(
'bc buy match: time = %s, lowest_price = %s, buy_amount = %s, sell_amount = %s, amount_ratio = %s'
% (now_line['date'] + ' ' + now_line['time'], lowest_price,
amount, sell_amount, amount_ratio))
return tag
def isYDLS(self, stock, dh):
now_line = stock.get_Lastline()
high_limit = round(
decimal.Decimal(self.convertToFloat(now_line['pre_close']) * 1.1),
2)
if self.convertToFloat(now_line['price']) >= float(high_limit):
stock.set_cache('ignore_ydls', True)
self.save_to_excel(stock)
return False
if self.getOpenPercent(stock) - self.getPercent(
now_line['price'],
stock) > self.__config.get_t1()['ydls']['open-low']:
stock.set_cache('ignore_ydls', True)
return False
if self.getPercent(now_line['high'], stock) - self.getPercent(
now_line['price'],
stock) > self.__config.get_t1()['ydls']['open-low']:
stock.set_cache('ignore_ydls', True)
return False
if float(now_line['high']) > float(now_line['price']):
return False
stop_p = self.__config.get_t1()['ydls']['stop_p']
current_p = self.getCurrentPercent(stock)
if current_p < stop_p[0] or current_p > stop_p[1]:
return False
datas = stock.get_data_in_len(self.__config.get_t1()['ydls']['in_len'])
length = len(datas)
last_datetime = self.get_data_time(datas[-1])
fist_datetime = self.get_data_time(datas[-1 * length])
p1 = self.getPercent(datas[-1 * length]['price'], stock)
p2 = self.getPercent(datas[-1]['price'], stock)
p = p2 - p1
amount = self.convertToFloat(
datas[-1]['buy_amount']) - self.convertToFloat(
datas[-1 * length]['buy_amount'])
sell_amount = self.convertToFloat(
datas[-1]['sell_amount']) - self.convertToFloat(
datas[-1 * length]['sell_amount'])
delta = (last_datetime - fist_datetime).seconds
if delta < 45:
if delta < 15:
return False
if p < self.__config.get_t1()['ydls']['yd_p']:
return False
if amount < self.__config.get_t1()['ydls']['min_amount'] or (
sell_amount > 0.0 and amount / sell_amount <
self.__config.get_t1()['ydls']['amount_ratio']):
return False
MyLog.info(
'%s is match ydls, t1 = %s, t2 = %s, p1 = %s, p2 = %s, p = %s, amount = %s, sell_amount = %s, amount_ratio = %s'
% (stock.get_code(), datas[-1 * length]['date'] + ' ' +
datas[-1 * length]['time'], datas[-1]['date'] + ' ' +
datas[-1]['time'], p1, p2, p, amount, sell_amount,
100 if sell_amount == 0.0 else amount / sell_amount))
return True
else:
if length > 15:
step = 2
i = -15
while i >= length * -1:
p1 = self.getPercent(datas[i]['price'], stock)
p2 = self.getPercent(datas[-1]['price'], stock)
p = p2 - p1
amount = self.convertToFloat(
datas[-1]['buy_amount']) - self.convertToFloat(
datas[i]['buy_amount'])
sell_amount = self.convertToFloat(
datas[-1]['sell_amount']) - self.convertToFloat(
datas[i]['sell_amount'])
fist_datetime_temp = self.get_data_time(datas[i])
i = i - step
if (last_datetime - fist_datetime_temp).seconds < 45:
continue
if p >= pow(
((last_datetime - fist_datetime_temp).seconds - 45),
self.__config.get_t1()['ydls']
['yd_ratio']) + self.__config.get_t1()['ydls']['yd_p']:
if amount >= self.__config.get_t1(
)['ydls']['min_amount'] and (
sell_amount == 0.0 or amount / sell_amount >=
self.__config.get_t1()['ydls']['amount_ratio']
):
MyLog.info(
'%s is match ydls, t1 = %s , t2 = %s, p1 = %s, p2 = %s, p = %s, amount = %s, sell_amount = %s, amount_ratio = %s'
%
(stock.get_code(), datas[i + step]['date'] +
' ' + datas[i + step]['time'],
datas[-1]['date'] + ' ' + datas[-1]['time'],
p1, p2, p, amount, sell_amount, 100 if
sell_amount == 0.0 else amount / sell_amount))
return True
if p >= pow(((last_datetime - fist_datetime).seconds - 45),
self.__config.get_t1()['ydls']
['yd_ratio']) + self.__config.get_t1()['ydls']['yd_p']:
if amount >= self.__config.get_t1()['ydls']['min_amount'] and (
sell_amount == 0.0 or amount / sell_amount >=
self.__config.get_t1()['ydls']['amount_ratio']):
MyLog.info(
'%s is match ydls, t1 = %s , t2 = %s, p1 = %s, p2 = %s, p = %s, amount = %s, sell_amount = %s, amount_ratio = %s'
%
(stock.get_code(), datas[-1 * length]['date'] + ' ' +
datas[-1 * length]['time'], datas[-1]['date'] + ' ' +
datas[-1]['time'], p1, p2, p, amount, sell_amount,
100 if sell_amount == 0.0 else amount / sell_amount))
return True
return False
def updateBreak10(self, stock):
if stock.get_cache('status') == 1:
if stock.get_cache('min_break') is None:
stock.set_cache('min_break', self.getCurrentPercent(stock))
elif self.getCurrentPercent(stock) < stock.get_cache('min_break'):
stock.set_cache('min_break', self.getCurrentPercent(stock))
def isReach10Again(self, stock):
now_line = stock.get_Lastline()
stop_price = round(float(now_line['pre_close']) * 1.1, 2)
if float(now_line['b1_p']) == stop_price and self.convertToFloat(
now_line['a1_v']) == 0:
stock.set_cache('min_break', None)
stock.set_cache('status', None)
return False
else:
if self.convertToFloat(now_line['a5_v']) != 0:
return False
if stock.get_cache('min_break') is None or stock.get_cache(
'min_break') > self.__config.get_t1(
)['hit10']['min_break']:
return False
if stock.get_cache('break_time') is None or (
dt.datetime.now() - stock.get_cache('break_time')
).seconds > self.__config.get_t1()['hit10']['break_time']:
return False
if stock.get_cache('hit_top_time') is None or (
stock.get_cache('break_time') -
stock.get_cache('hit_top_time')
).seconds < self.__config.get_t1()['hit10']['hit_break_inter']:
return False
total_sell = 0
for i in range(1, 6):
total_sell += self.convertToFloat(
now_line['a' + str(i) + '_v']) * self.convertToFloat(
now_line['a' + str(i) + '_p']) * 100
if total_sell > stock.get_cache(
'max_b1_amount') * self.__config.get_t1(
)['hit10']['max_b1_amount_ratio']:
return False
info = '[%s]在[%s][%s] match 10,b1_v=%s' % (
Utils.getCurrentTime(), str(now_line['date']) + ' ' +
str(now_line['time']), stock.get_code(), now_line['b1_v'])
MyLog.info(info)
return True
def isbreak10(self, stock, dh):
now_line = stock.get_Lastline()
stop_price = round(float(now_line['pre_close']) * 1.1, 2)
if float(now_line['b1_p']) != stop_price and self.convertToFloat(
now_line['a1_v']) != 0:
count = stock.get_cache('break_count')
if count is None:
count = 1
else:
count = count + 1
stock.set_cache('break_count', count)
if count >= self.__config.get_t1()['hit10']['break_count']:
stock.set_cache('status', 0)
dh.add_ignore(stock.get_code())
else:
stock.set_cache('break_time', dt.datetime.now())
stock.set_cache('min_break', self.getCurrentPercent(stock))
stock.set_cache('status', 1)
MyLog.info('%s is break 10' % stock.get_code())
return False
def isReach10(self, stock):
now_line = stock.get_Lastline()
stop_price = round(float(now_line['pre_close']) * 1.1, 2)
if float(now_line['b1_p']) == stop_price and self.convertToFloat(
now_line['a1_v']) == 0:
hit_top_time = stock.get_cache('hit_top_time')
strTime = time.strftime('%H:%M:%S', time.localtime(time.time()))
if hit_top_time is None and strTime > self.__config.get_t1(
)['hit10']['hit_top_time']:
return False
stock.set_cache('hit_top_time', dt.datetime.now())
now_b1_amount = self.convertToFloat(now_line['b1_v']) * float(
now_line['b1_p']) * 100
if now_b1_amount >= self.__config.get_t1(
)['hit10']['buy_b1_amount']:
MyLog.info('%s is reach 10' % stock.get_code())
stock.set_cache('status', 0)
return False
def isZSMatch(self, zs, stock):
if zs is None:
return True
code = stock.get_code()
i = 0
if code.startswith('3'):
i = 5
line = zs.iloc[i]
pre_close = line.get('pre_close')
price = line.get('price')
p = (float(price) - float(pre_close)) / float(pre_close) * 100
return p > self.__config.get_t1()['ydls']['zs']
def getPercent(self, price, stock):
lastLine = stock.get_Lastline()
pre_close = lastLine['pre_close']
open_p = (float(price) - float(pre_close)) / float(pre_close) * 100
return open_p
def getCurrentPercent(self, stock):
lastLine = stock.get_Lastline()
price = lastLine['price']
return self.getPercent(price, stock)
def getOpenPercent(self, stock):
ocp = stock.get_cache('ocp')
if ocp is not None:
return ocp
lastLine = stock.get_Lastline()
open = lastLine['open']
ocp = self.getPercent(open, stock)
stock.set_cache('ocp', ocp)
return ocp
class NewAnalyze(object):
def __init__(self):
self.__config = Config()
self.__buyedCount = 0
self.__balance = self.__config.get_t1()['trade']['balance']
if self.__config.get_t1()['trade']['enable']:
self.__trade = Trade()
if self.__config.get_t1()['trade']['enableMock']:
self.__mockTrade = MockTrade()
self.__engine = create_engine(self.__config.get_DBurl())
def printPerformace(self, timestamp):
deltaSeconds = (dt.datetime.now() - timestamp).seconds
if deltaSeconds > 3:
print('calc more than %s seconds' % deltaSeconds)
def calcMain(self, zs, dh, timestamp, buyCount):
data = dh.get_data()
finalCode = ''
result = []
codes = []
for code in data:
if code in dh.get_buyed() or code in dh.get_ignore():
continue
try:
if self.calc(zs, data[code], dh):
result.append(data[code])
# self.printPerformace(timestamp)
except Exception as e:
last_line = data[code].get_Lastline()
MyLog.error(last_line['time'] + ' :calc ' + code + ' error')
MyLog.error(str(e))
if len(result) != 0:
for stock in result:
try:
last_line = stock.get_Lastline()
res = self.outputRes(last_line, timestamp, buyCount)
if res is not None:
codes.append(stock.get_code())
except Exception as e:
MyLog.error('outputRes error %s' % stock.get_code())
MyLog.error(str(e))
return codes
def outputRes(self, df_final, timestamp, buyCount):
trade = self.__config.get_t1()['trade']
if buyCount <= 0:
return None
buyMoney = (float(df_final['price']) +
trade['addPrice']) * trade['volume']
if buyMoney > self.__balance:
return None
price = str('%.2f' % (float(df_final['price']) + trade['addPrice']))
info = '[%s] 在 %s 以 %s 买入 [%s]%s %s 股' % (
Utils.getCurrentTime(),
str(df_final['date']) + ' ' + str(df_final['time']), price,
df_final['code'], df_final['name'], str(trade['volume']))
MyLog.info(info)
now = dt.datetime.now()
deltaSeconds = (now - timestamp).seconds
if deltaSeconds > trade['timestampLimit']:
MyLog.info('[%s] 行情超时 %s秒 放弃买入' % (df_final['code'], deltaSeconds))
return None
if trade['enable']:
res = str(
self.__trade.buy(df_final['code'], trade['volume'],
float(price)))
if 'entrust_no' in res:
self.__buyedCount = self.__buyedCount + 1
self.__balance = self.__balance - buyMoney
return df_final['code']
return None
if trade['enableMock']:
res = self.__mockTrade.mockTrade(df_final['code'], float(price),
trade['volume'])
if res == 0:
self.__buyedCount = self.__buyedCount + 1
self.__balance = self.__balance - buyMoney
return df_final['code']
return None
return df_final['code']
def calc(self, zs, stock, dh):
if not self.canCalc(stock, dh):
return False
open_p = self.getOpenPercent(stock)
conf = self.getConfig(open_p)
if conf is None:
dh.add_ignore(stock.get_code())
return False
if not stock.is_inited():
self.initStockData(stock, open_p, conf)
self.updateStock(stock, conf)
return self.isStockMatch(zs, stock, conf, dh)
def isOpenMatch(self, row):
if float(row['pre_close']) == 0 or float(row['open']) == 0:
return False
return (float(row['open']) - float(row['pre_close'])) / float(
row['pre_close']) * 100 >= -1.0
def canCalc(self, stock, dh):
if stock.len() < 0:
return False
lastLine = stock.get_Lastline()
if float(lastLine['open']) == 0.0:
return False
lastSecondLine = stock.get_LastSecondline()
if lastSecondLine is None:
return False
if float(lastSecondLine['open']) == 0.0:
return False
return True
def initStockData(self, stock, open_p, conf):
r_line = self.__config.get_t1()['R_line']
for key in r_line:
if stock.get_r_val(key) == -10:
val = open_p + (10 - open_p) * r_line[key]
stock.set_r_val(key, val)
stock.set_inited()
def updateStock(self, stock, conf):
self.updateBreakRtimes(stock, conf)
def convertToFloat(self, str):
if str == '':
return 0
try:
return float(str)
except Exception as e:
MyLog.error('convertToFloat error: ' + str + '\n')
return 0
def updateBreakRtimes(self, stock, conf):
now_p = self.getCurrentPercent(stock)
lastSecondLine = stock.get_LastSecondline()
last_p = self.getPercent(lastSecondLine['price'], stock)
for key in ['R1', 'R2', 'R3', 'R4']:
val = stock.get_r_val(key)
if last_p > val and now_p < val:
stock.add_rBreakTimes(key)
minR = stock.get_minR()
if minR is None:
minR = conf['min_R']
if stock.get_rBreakTimes(minR) > 0:
for i in [1, 2, 3, 4, 5]:
if i > int(minR[-1]) and stock.get_rBreakTimes('R' +
str(i)) == 0:
stock.set_minR('R' + str(i))
break
else:
stock.set_minR(minR)
def getConfig(self, open_p):
t1 = self.__config.get_t1()
keys = ['A', 'B', 'C']
for key in keys:
if t1[key]['open_p'][0] <= open_p and open_p < t1[key]['open_p'][1]:
return t1[key]
def isStockMatch(self, zs, stock, conf, dh):
if 'time' in self.__config.get_t1(
)['strategy'] and not self.isTimeMatch(stock, conf):
return False
if 'xspeed' in self.__config.get_t1(
)['strategy'] and not self.isXSpeedMatch(dh, stock):
return False
if 'sellWindow' in self.__config.get_t1(
)['strategy'] and not self.isSellWindowMatch(zs, stock):
return False
if 'minR' in self.__config.get_t1(
)['strategy'] and not self.isReachMinR(stock):
return False
return self.isLastTwoMatch(stock)
def isZSMatch(self, zs, stock):
if zs is None:
return True
code = stock.get_code()
i = 0
if code.startswith('3'):
i = 5
line = zs.iloc[i]
pre_close = line.get('pre_close')
price = line.get('price')
p = (float(price) - float(pre_close)) / float(pre_close) * 100
if p < -0.3:
return False
if code in self.__config.get_conceptCodes():
return True
return p > 0
def isSellWindowMatch(self, zs, stock):
data = stock.get_data()
size = len(data)
if size > self.__config.get_t1()['big_money']['count']:
size = self.__config.get_t1()['big_money']['count']
temp = data[size * -1:]
nowAmount = self.convertToFloat(temp[-1]['amount'])
lastAmount = self.convertToFloat(temp[0]['amount'])
avgAmount = (nowAmount - lastAmount) / size
if avgAmount < self.__config.get_t1()['big_money']['amount']:
return False
if avgAmount < self.__config.get_t1()['big_money']['amount_2']:
if 'zs' in self.__config.get_t1(
)['strategy'] and not self.isZSMatch(zs, stock):
return False
MyLog.info('[%s] average amount = %s' % (stock.get_code(), avgAmount))
now_line = stock.get_Lastline()
totalAmountInSell = 0.0
for i in range(1, 6):
temp = self.convertToFloat(
now_line['a' + str(i) + '_p']) * self.convertToFloat(
now_line['a' + str(i) + '_v']) * 100
totalAmountInSell = totalAmountInSell + temp
ratio = totalAmountInSell / (nowAmount - lastAmount)
MyLog.info('[%s] sell window ratio = %s' % (stock.get_code(), ratio))
return ratio <= self.__config.get_t1()['sellWindow']['threshold']
def isXSpeedMatch(self, dh, stock):
now_line = stock.get_Lastline()
ccp = self.getCurrentPercent(stock)
ocp = self.getOpenPercent(stock)
# if ocp - ccp >= self.__config.get_t1()['x_speed']['lowerThanBefore']:
# stock.add_lowerThanBeforeTimes()
# if stock.get_lowerThanBeforeTimes() > self.__config.get_t1()['x_speed']['lowerThanBeforeTimes']:
# dh.add_ignore(stock.get_code())
# return False
ct = dt.datetime.strptime(now_line['date'] + ' ' + now_line['time'],
'%Y-%m-%d %H:%M:%S')
pcpArray = self.generatePCPArray(stock)
i = 0
while i < len(pcpArray):
line = pcpArray[i]
if line['time'] == now_line['time']:
break
price = float(line['price'])
pcp = (float(pcpArray[i]['price']) -
float(pcpArray[i]['pre_close'])) / float(
pcpArray[i]['pre_close']) * 100
# if pcp - ccp >= self.__config.get_t1()['x_speed']['lowerThanBefore']:
# stock.add_lowerThanBeforeTimes()
# if stock.get_lowerThanBeforeTimes() > self.__config.get_t1()['x_speed']['lowerThanBeforeTimes']:
# dh.add_ignore(stock.get_code())
# return False
if ccp - pcp >= (10 -
pcp) * self.__config.get_t1()['x_speed']['a']:
if ccp - pcp >= (ccp - ocp) * self.__config.get_t1(
)['x_speed']['b'] and pcp > ocp:
pt = dt.datetime.strptime(
line['date'] + ' ' + line['time'], '%Y-%m-%d %H:%M:%S')
c = self.__config.get_t1()['x_speed']['c'][0]
if ocp >= 2 and ocp < 5:
c = self.__config.get_t1()['x_speed']['c'][1]
elif ocp >= -1 and ocp < 2:
c = self.__config.get_t1()['x_speed']['c'][2]
if (ct - pt).seconds / 60 < (ccp - pcp) * c:
MyLog.info('[%s] match cond a, ccp = %s, pcp = %s' %
(stock.get_code(), ccp, pcp))
MyLog.info('[%s] match cond b, ccp = %s, ocp = %s' %
(stock.get_code(), ccp, ocp))
MyLog.info('[%s] match cond c, ct = %s, pt = %s' %
(stock.get_code(), ct, pt))
last_second_line = stock.get_LastSecondline()
stock.add_buySignal()
if stock.get_buySignal() >= self.__config.get_t1(
)['trade']['maxBuySignal']:
return True
return False
i = i + 1
# stock.reset_buySignal()
return False
def generatePCPArray(self, stock):
pcpArray = []
len = stock.len()
start = 0
step = 1
if len > 30:
if len > 250:
start = -250
len = 250
step = math.ceil(len / 30)
data = stock.get_data()
for val in data[start::step]:
pcpArray.append(val)
return pcpArray
def isLastTwoMatch(self, stock):
data = stock.get_data()
if stock.len() < 3:
return False
price = float(data[-1]['price'])
price2 = float(data[-2]['price'])
price3 = float(data[-2]['price'])
return price - price2 >= 0 and price2 - price3 >= 0
def isTimeMatch(self, stock, conf):
lastLine = stock.get_Lastline()
timeStr = lastLine['time']
return timeStr <= conf['time']
def getPercent(self, price, stock):
lastLine = stock.get_Lastline()
pre_close = lastLine['pre_close']
open_p = (float(price) - float(pre_close)) / float(pre_close) * 100
return open_p
def getCurrentPercent(self, stock):
lastLine = stock.get_Lastline()
price = lastLine['price']
return self.getPercent(price, stock)
def getOpenPercent(self, stock):
ocp = stock.get_cache('ocp')
if ocp is not None:
return ocp
lastLine = stock.get_Lastline()
open = lastLine['open']
ocp = self.getPercent(open, stock)
stock.set_cache('ocp', ocp)
return ocp
def isReachMinR(self, stock):
now_p = self.getCurrentPercent(stock)
minR = stock.get_minR()
return now_p > stock.get_r_val(minR) or now_p >= 9.0
class DataHolder(object):
def __init__(self, codes):
self.__data = {}
self.__buyed = []
self.__selled = []
self.__setting = Config()
self.__tpe = ThreadPoolExecutor(5)
self.__engine = create_engine(self.__setting.get_DBurl())
if self.__setting.get_t1(
)['need_recover_data'] and self.needRecoverData():
self.recoverData(codes)
def recoverData(self, codes):
for code in codes:
try:
src_data = pd.read_sql_table('live_' + code, con=self.__engine)
if src_data is not None and len(src_data) > 0:
last = src_data.iloc[-1]
now_date = time.strftime('%Y-%m-%d',
time.localtime(time.time()))
if now_date == last['date']:
self.__data[code] = Stock(code, src_data)
except Exception as e:
MyLog.error('recover data error \n')
MyLog.error(str(e) + '\n')
def needRecoverData(self):
now = dt.datetime.now()
return now > dt.datetime(now.year, now.month, now.day, 9, 15)
def get_buyed(self):
return self.__buyed
def get_selled(self):
return self.__selled
def add_selled(self, code, save=False):
self.__selled.append(code)
if save:
self.__tpe.submit(self.saveData, self.__data[code].get_data())
def add_buyed(self, code, save=False):
self.__buyed.append(code)
if save:
self.__tpe.submit(self.saveData, self.__data[code].get_data())
def get_data(self):
return self.__data
def addDataHandler(self, row):
code = row['code']
if code in self.get_buyed():
return
if code in self.__data and self.__data[code].len() > 0:
self.__data[code].add_Line(row)
else:
self.__data[code] = Stock(code, row)
if float(row['pre_close']) != 0 and (float(row['price']) - float(
row['pre_close'])) / float(row['pre_close']) * 100 >= 9.9:
if not (code in self.get_buyed()):
MyLog.info('[%s] reach 10' % code)
self.add_buyed(code, True)
def addSellDataHandler(self, row):
code = row['code']
if code in self.get_selled():
return
if code in self.__data and self.__data[code].len() > 0:
self.__data[code].add_Line(row)
else:
self.__data[code] = Stock(code, row)
def addData(self, df):
df.apply(self.addDataHandler, axis=1)
def addSellData(self, df):
df.apply(self.addSellDataHandler, axis=1)
def saveData(self, data):
try:
line = data.iloc[0]
code = line['code']
data.to_sql('live_' + code,
con=self.__engine,
if_exists='replace',
index=False)
MyLog.info('[%s] save data' % code)
except Exception as e:
MyLog.error('[%s %s] save [%s] data error \n' %
(line['date'], line['time'], code))
MyLog.error(str(e) + '\n')
class NewDataHolder2(object):
def __init__(self):
self.__data = {}
self.__ignore = []
self.__buyed = []
self.__selled = []
self.__setting = Config()
self.__tpe = ThreadPoolExecutor(5)
self.__engine = create_engine(self.__setting.get_DBurl())
def get_buyed(self):
return self.__buyed
def add_buyed(self, code):
self.__buyed.append(code)
# self.__tpe.submit(self.saveData,self.__data[code].get_data())
#use for mock
def add_buyed_mock(self, code):
self.__buyed.append(code)
def get_selled(self):
return self.__selled
def add_selled(self, code, save=False):
self.__selled.append(code)
# if save:
# self.__tpe.submit(self.saveData,self.__data[code].get_data())
def get_ignore(self):
return self.__ignore
def add_ignore(self, code, save=False):
self.__ignore.append(code)
# if save:
# self.__tpe.submit(self.saveData,self.__data[code].get_data())
def get_data(self):
return self.__data
def addDataHandler(self, row):
code = row['code']
if code in self.get_ignore():
return
if code in self.__data and self.__data[code].len() > 0:
self.__data[code].add_Line(row)
else:
self.__data[code] = NewStock(code, row)
def addSellDataHandler(self, row):
code = row['code']
if code in self.get_selled():
return
if code in self.__data and self.__data[code].len() > 0:
self.__data[code].add_Line(row)
else:
self.__data[code] = NewStock(code, row)
def addData(self, df):
df.apply(self.addDataHandler, axis=1)
def addSellData(self, df):
df.apply(self.addSellDataHandler, axis=1)
def saveData(self, data):
try:
line = data[0]
code = line['code']
df = pd.DataFrame(data)
df.to_sql('live_' + code,
con=self.__engine,
if_exists='replace',
index=False)
MyLog.info('[%s] save data' % code)
except Exception as e:
MyLog.error('[%s %s] save [%s] data error \n' %
(line['date'], line['time'], code))
MyLog.error(str(e) + '\n')
class HitBottomAnalyze(object):
def __init__(self):
self.__config = Config()
self.__buyedCount = 0
self.__balance = self.__config.get_t1()['trade']['balance']
if self.__config.get_t1()['trade']['enable']:
self.__trade = Trade()
if self.__config.get_t1()['trade']['enableMock']:
self.__mockTrade = MockTrade()
self.__engine = create_engine(self.__config.get_DBurl())
def printPerformace(self,timestamp):
deltaSeconds = (dt.datetime.now() - timestamp).seconds
if deltaSeconds > 3:
print('calc more than %s seconds' % deltaSeconds)
def calcMain(self,dh,timestamp,buyCount):
data = dh.get_data()
finalCode = ''
result = []
codes = []
for code in data:
if code in dh.get_buyed() or code in dh.get_ignore():
continue
try:
if self.calc(data[code],dh):
result.append(data[code])
# self.printPerformace(timestamp)
except Exception as e:
last_line = data[code].get_Lastline()
MyLog.error(last_line['time'] + ' :calc ' + code + ' error')
MyLog.error(str(e))
if len(result) != 0:
for stock in result:
try:
last_line = stock.get_Lastline()
res = self.outputRes(last_line,timestamp,buyCount)
if res is not None:
codes.append(stock.get_code())
except Exception as e:
MyLog.error('outputRes error %s' % stock.get_code())
MyLog.error(str(e))
return codes
def outputRes(self,df_final,timestamp,buyCount):
trade = self.__config.get_t1()['trade']
if buyCount <= 0:
return None
buyMoney = (float(df_final['price']) + trade['addPrice']) * trade['volume']
if buyMoney > self.__balance:
return None
price = str('%.2f' % (float(df_final['price']) + trade['addPrice']))
info = '[%s] 在 %s 以 %s 买入 [%s]%s %s 股' % (Utils.getCurrentTime(),str(df_final['date']) + ' ' + str(df_final['time']), price, df_final['code'], df_final['name'], str(trade['volume']))
MyLog.info(info)
now = dt.datetime.now()
deltaSeconds = (now - timestamp).seconds
if deltaSeconds > trade['timestampLimit']:
MyLog.info('[%s] 行情超时 %s秒 放弃买入' % (df_final['code'],deltaSeconds))
return None
if trade['enable']:
res = str(self.__trade.buy(df_final['code'],trade['volume'],float(price)))
if 'entrust_no' in res:
self.__buyedCount = self.__buyedCount + 1
self.__balance = self.__balance - buyMoney
return df_final['code']
return None
if trade['enableMock']:
res = self.__mockTrade.mockTrade(df_final['code'],float(price),trade['volume'])
if res == 0:
self.__buyedCount = self.__buyedCount + 1
self.__balance = self.__balance - buyMoney
return df_final['code']
return None
return df_final['code']
def calc(self,stock,dh):
ccp = self.getCurrentPercent(stock)
if ccp >= self.__config.get_t1()['hitBottom']['max_p'] or ccp <= self.__config.get_t1()['hitBottom']['min_p']:
return False
lastLine = stock.get_Lastline()
price = float(lastLine['price'])
openPrice = float(lastLine['open'])
high = float(lastLine['high'])
low = float(lastLine['low'])
if price >= openPrice or price <= low:
return False
return price - low <= (high - low) * self.__config.get_t1()['hitBottom']['margin']
def convertToFloat(self,str):
if str == '':
return 0
try:
return float(str)
except Exception as e:
MyLog.error('convertToFloat error: ' + str + '\n')
return 0
def getPercent(self,price,stock):
lastLine = stock.get_Lastline()
pre_close = lastLine['pre_close']
open_p = (float(price) - float(pre_close)) / float(pre_close) * 100
return open_p
def getCurrentPercent(self,stock):
lastLine = stock.get_Lastline()
price = lastLine['price']
return self.getPercent(price,stock)
def getOpenPercent(self,stock):
ocp = stock.get_cache('ocp')
if ocp is not None:
return ocp
lastLine = stock.get_Lastline()
open = lastLine['open']
ocp = self.getPercent(open,stock)
stock.set_cache('ocp',ocp)
return ocp
class Analyze(object):
def __init__(self, thshy, thsgn):
self.__config = Config()
self.__buyedCount = 0
self.__balance = self.__config.get_t1()['trade']['balance']
if self.__config.get_t1()['trade']['enable']:
self.__trade = Trade()
if self.__config.get_t1()['trade']['enableMock']:
self.__mockTrade = MockTrade()
self.__engine = create_engine(self.__config.get_DBurl())
self.__hygnData = self.initHYGN(thshy, thsgn)
def initHYGN(self, thshy, thsgn):
if thshy is None or thsgn is None:
return
data = {}
for index, row in thshy.iterrows():
if row['code'] not in data:
data[row['code']] = {'hy': [], 'gn': []}
if row['hy'] not in data[row['code']]['hy']:
data[row['code']]['hy'].append(row['hy'])
for index, row in thsgn.iterrows():
if row['code'] not in data:
data[row['code']] = {'hy': [], 'gn': []}
if row['cont'] not in data[row['code']]['gn']:
data[row['code']]['gn'].append(row['cont'])
return data
def calcMain(self, zs, dh, hygn, netMoney, timestamp):
data = dh.get_data()
finalCode = ''
result = []
codes = []
for code in data:
if len(dh.get_buyed()) > 0:
if code in dh.get_buyed():
continue
try:
if self.calc(zs, data[code], dh, hygn, netMoney):
result.append(data[code])
except Exception as e:
last_line = data[code].get_Lastline()
MyLog.error(last_line['time'] + ' :calc ' + code + ' error')
MyLog.error(str(e))
if len(result) != 0:
for stock in result:
try:
last_line = stock.get_Lastline()
res = self.outputRes(last_line, timestamp)
if res is not None:
codes.append(stock.get_code())
self.saveData(stock)
except Exception as e:
MyLog.error('outputRes error %s' % stock.get_code())
MyLog.error(str(e))
return codes
def save(self, data):
try:
code = data.iloc[0]['code']
data.to_sql('live_' + code,
con=self.__engine,
if_exists='replace',
index=False)
except Exception as e:
MyLog.error('save [%s] data error \n' % code)
MyLog.error(str(e) + '\n')
def saveData(self, stock):
data = stock.get_data()
t = threading.Thread(target=self.save, args=(data, ))
t.start()
def outputRes(self, df_final, timestamp):
trade = self.__config.get_t1()['trade']
if self.__buyedCount >= trade['max_buyed']:
return None
buyMoney = (float(df_final['price']) +
trade['addPrice']) * trade['volume']
if buyMoney > self.__balance:
return None
price = str('%.2f' % (float(df_final['price']) + trade['addPrice']))
info = '[%s] 在 %s 以 %s 买入 [%s]%s %s 股' % (
Utils.getCurrentTime(),
str(df_final['date']) + ' ' + str(df_final['time']), price,
df_final['code'], df_final['name'], str(trade['volume']))
MyLog.info(info)
now = dt.datetime.now()
deltaSeconds = (now - timestamp).seconds
if deltaSeconds > trade['timestampLimit']:
MyLog.info('[%s] 行情超时 %s秒 放弃买入' % (df_final['code'], deltaSeconds))
return None
if trade['enable']:
res = str(
self.__trade.buy(df_final['code'], trade['volume'],
float(price)))
if 'entrust_no' in res:
self.__buyedCount = self.__buyedCount + 1
self.__balance = self.__balance - buyMoney
return df_final['code']
return None
if trade['enableMock']:
res = self.__mockTrade.mockTrade(df_final['code'], float(price),
trade['volume'])
if res == 0:
self.__buyedCount = self.__buyedCount + 1
self.__balance = self.__balance - buyMoney
return df_final['code']
return None
return df_final['code']
def goTopsis(self, result):
df = pd.DataFrame()
for stock in result:
df = self.buildData(df, stock)
return self.topsisCalc(df)
def topsisCalc(self, df):
df = df.fillna(df.mean())
self.commonCalc(df, 'net',
self.__config.get_t1()['topsis']['net'], True)
self.commonCalc(df, 'v120',
self.__config.get_t1()['topsis']['v120'], True)
self.commonCalc(df, 'v300',
self.__config.get_t1()['topsis']['v300'], True)
self.commonCalc(df, 'v30',
self.__config.get_t1()['topsis']['v30'], True)
self.commonCalc(df, 'r_break',
self.__config.get_t1()['topsis']['r_break'], False)
for index, row in df.iterrows():
self.calcDi(df, index, row,
['net', 'v120', 'v300', 'v30', 'r_break'], '_best')
self.calcDi(df, index, row,
['net', 'v120', 'v300', 'v30', 'r_break'], '_worst')
self.calcCi(df, index, row)
df = df.sort_values('ci', ascending=False)
return df
def calcCi(self, df, index, row):
if (row['Di_best'] + row['Di_worst']) == 0:
row['ci'] = 0
df.loc[index, 'ci'] = 0
else:
row['ci'] = row['Di_worst'] / (row['Di_best'] + row['Di_worst'])
df.loc[index, 'ci'] = row['ci']
def calcDi(self, df, index, row, columnList, best_worst):
temp = 0
for column in columnList:
temp = temp + np.square(row[column + '_vi'] -
row[column + best_worst])
row['Di' + best_worst] = cmath.sqrt(temp)
df.loc[index, 'Di' + best_worst] = row['Di' + best_worst]
def commonCalc(self, df, columnName, weight, positive):
temp = cmath.sqrt((df[columnName] * df[columnName]).sum())
#wi*ri
if temp == 0:
df[columnName + '_vi'] = weight * 0
else:
df[columnName + '_vi'] = weight * df[columnName] / temp
#vi+, vi-
if positive == True:
df[columnName + '_best'] = df[columnName + '_vi'].max()
df[columnName + '_worst'] = df[columnName + '_vi'].min()
else:
df[columnName + '_best'] = df[columnName + '_vi'].min()
df[columnName + '_worst'] = df[columnName + '_vi'].max()
def buildData(self, df, stock):
data = stock.get_data()
last_line = stock.get_Lastline()
data.loc[data['time'] == last_line['time'], 'net'] = stock.get_net()
data.loc[data['time'] == last_line['time'],
'v300'] = stock.get_speed('v300')
data.loc[data['time'] == last_line['time'],
'v120'] = stock.get_speed('v120')
data.loc[data['time'] == last_line['time'],
'v30'] = stock.get_speed('v30')
minR = stock.get_minR()
times = 0
for i in [1, 2, 3, 4]:
if 'R' + str(i) != minR:
times = times + stock.get_rBreakTimes('R' + str(i))
else:
break
data.loc[data['time'] == last_line['time'], 'r_break'] = times
last_line = stock.get_Lastline()
return df.append([last_line])
def calc(self, zs, stock, dh, hygn, netMoney):
if not self.canCalc(stock, dh):
return False
open_p = self.getOpenPercent(stock)
conf = self.getConfig(open_p)
if conf is None:
dh.add_buyed(stock.get_code(), False)
return False
self.initStockData(stock, open_p, conf)
self.updateStock(stock, conf)
return self.isStockMatch(zs, stock, conf, hygn, netMoney, dh)
# def isJHJJMatch(self,stock,dh):
# lastLine = stock.get_Lastline()
# now_time = lastLine['time']
# if now_time >= '09:30:00':
# return True
# if stock.len() >= 2:
# lastSecondLine = stock.get_LastSecondline()
# if now_time > '09:17:00' and now_time < '09:20:00':
# b1_v = self.convertToFloat(lastLine.get('b1_v'))
# b1_amount = float(lastLine.get('b1_p')) * b1_v * 100
# lastB1_v = self.convertToFloat(lastSecondLine.get('b1_v'))
# lastB1_amount = float(lastSecondLine.get('b1_p')) * lastB1_v * 100
# if b1_v < lastB1_v * 0.5 or b1_amount < lastB1_amount * 0.5:
# dh.add_buyed(stock.get_code(),True)
# return False
# if now_time > '09:24:30' and now_time < '09:25:03':
# b1_v = self.convertToFloat(lastLine.get('b1_v'))
# b1_amount = float(lastLine.get('b1_p')) * b1_v * 100
# if b1_v <= 1000 or b1_amount <= 3000000:
# dh.add_buyed(stock.get_code(),True)
# return False
# return True
# return False
def isOpenMatch(self, row):
if float(row['pre_close']) == 0 or float(row['open']) == 0:
return False
return (float(row['open']) - float(row['pre_close'])) / float(
row['pre_close']) * 100 >= -1.0
def isOpenMatch2(self, row):
if float(row['settlement']) == 0 or float(row['open']) == 0:
return False
return (float(row['open']) - float(row['settlement'])) / float(
row['settlement']) * 100 >= -1.0
def canCalc(self, stock, dh):
if stock.len() < 0:
return False
# if not self.isJHJJMatch(stock,dh):
# return False
lastLine = stock.get_Lastline()
if float(lastLine.get('open')) == 0.0:
return False
lastSecondLine = stock.get_LastSecondline()
if lastSecondLine is None:
return False
if float(lastSecondLine.get('open')) == 0.0:
return False
return True
def initStockData(self, stock, open_p, conf):
r_line = self.__config.get_t1()['R_line']
for key in r_line:
if stock.get_r_val(key) == -10:
val = open_p + (10 - open_p) * r_line[key]
stock.set_r_val(key, val)
def updateStock(self, stock, conf):
self.updateBreakRtimes(stock, conf)
# self.updateSpeed(stock)
# self.updatePriceVolumeMap(stock)
# try:
# self.updateBigMoney(stock,conf)
# except Exception as e:
# MyLog.error('updateBigMoney error \n')
# MyLog.error(str(e) + '\n')
def updatePriceVolumeMap(self, stock):
try:
last_line = stock.get_Lastline()
time = last_line['time']
if time > self.__config.get_t1(
)['stop']['am_stop'] and time < self.__config.get_t1(
)['stop']['pm_start']:
return
stock.addPriceVolumeMap(last_line['date'], last_line['time'],
float(last_line['price']),
float(last_line['volume']))
except Exception as e:
MyLog.error('updatePriceVolumeMap error \n')
MyLog.error(str(e) + '\n')
def updateSpeed(self, stock):
data = stock.get_data()
last_line = stock.get_Lastline()
now_time = dt.datetime.strptime(
last_line['date'] + ' ' + last_line['time'], '%Y-%m-%d %H:%M:%S')
l = stock.len()
for i in [30, 120, 300]:
pos = l
if int(i / 3) + 1 < l:
pos = int(i / 3) + 1
df_temp = data.tail(pos)
for index, row in df_temp.iterrows():
if float(row['open']) != 0.0:
row_time = dt.datetime.strptime(
row['date'] + ' ' + row['time'], '%Y-%m-%d %H:%M:%S')
deltaS = (now_time - row_time).seconds
if deltaS == 0:
stock.set_speed('v' + str(i), 0)
break
if deltaS <= i and deltaS >= i - 6:
p = (float(last_line.get('price')) - float(
row['price'])) / float(row['pre_close']) * 100
stock.set_speed('v' + str(i), p / deltaS)
# MyLog.info('speed %s = %f' % ('v' + str(i),p / deltaS))
break
def convertToFloat(self, str):
if str == '':
return 0
try:
return float(str)
except Exception as e:
MyLog.error('convertToFloat error: ' + str + '\n')
return 0
def theLastIsSellOrBuy(self, stock):
lastLine = stock.get_Lastline()
lastSeconfLine = stock.get_LastSecondline()
last_amount = float(lastLine.get('amount'))
last_sec_amount = float(lastSeconfLine.get('amount'))
if last_sec_amount == last_amount:
return 'no_deal'
last_price = float(lastLine.get('price'))
last_b_p_1 = float(lastLine.get('b1_p'))
last_b_v_1 = self.convertToFloat(lastLine.get('b1_v'))
last_a_p_1 = float(lastLine.get('a1_p'))
last_a_v_1 = self.convertToFloat(lastLine.get('a1_v'))
last_sec_price = float(lastSeconfLine.get('price'))
last_sec_b_p_1 = float(lastSeconfLine.get('b1_p'))
last_sec_b_v_1 = self.convertToFloat(lastSeconfLine.get('b1_v'))
last_sec_a_p_1 = float(lastSeconfLine.get('a1_p'))
last_sec_a_v_1 = self.convertToFloat(lastSeconfLine.get('a1_v'))
if (last_a_p_1 > last_sec_a_p_1 or
(last_a_p_1 == last_sec_a_p_1 and
last_a_v_1 < last_sec_a_v_1)) and (last_price >= last_sec_price):
return 'drive_buy'
elif (last_b_p_1 < last_sec_b_p_1 or
(last_b_p_1 == last_sec_b_p_1 and last_b_v_1 < last_sec_b_v_1)
) and (last_price <= last_sec_price):
return 'drive_sell'
return 'unknown'
def updateBigMoney(self, stock, conf):
lastLine = stock.get_Lastline()
now_time = dt.datetime.strptime(
lastLine['date'] + ' ' + lastLine['time'], '%Y-%m-%d %H:%M:%S')
lastSeconfLine = stock.get_LastSecondline()
last_time = dt.datetime.strptime(
lastSeconfLine['date'] + ' ' + lastSeconfLine['time'],
'%Y-%m-%d %H:%M:%S')
last_amount = float(lastLine.get('amount'))
last_sec_amount = float(lastSeconfLine.get('amount'))
last_volume = float(lastLine.get('volume'))
last_sec_volume = float(lastSeconfLine.get('volume'))
amount = last_amount - last_sec_amount
volume = last_volume - last_sec_volume
big_amount = self.__config.get_t1()['big_money']['amount']
big_volume = self.__config.get_t1()['big_money']['volume']
# MyLog.info('price=%s,amount=%s' % (lastLine['price'],amount))
# if amount >= big_amount or volume >= big_volume:
type = self.theLastIsSellOrBuy(stock)
if type == 'drive_buy':
stock.addBigMoneyIn(last_amount - last_sec_amount)
# MyLog.info('in = %f' % stock.getBigMoneyIn())
stock.addNetBuy(last_amount - last_sec_amount)
# MyLog.info('net = %f' % stock.get_net())
elif type == 'drive_sell':
stock.addBigMoneyOut(last_amount - last_sec_amount)
stock.addNetBuy(last_sec_amount - last_amount)
# MyLog.info('net = %f' % stock.get_net())
def updateBreakRtimes(self, stock, conf):
now_p = self.getCurrentPercent(stock)
lastSecondLine = stock.get_LastSecondline()
last_p = self.getPercent(lastSecondLine.get('price'), stock)
for key in ['R1', 'R2', 'R3', 'R4']:
val = stock.get_r_val(key)
if last_p > val and now_p < val:
stock.add_rBreakTimes(key)
minR = stock.get_minR()
if minR is None:
minR = conf['min_R']
if stock.get_rBreakTimes(minR) > 0:
for i in [1, 2, 3, 4, 5]:
if i > int(minR[-1]) and stock.get_rBreakTimes('R' +
str(i)) == 0:
stock.set_minR('R' + str(i))
break
else:
stock.set_minR(minR)
def getConfig(self, open_p):
t1 = self.__config.get_t1()
keys = ['A', 'B', 'C']
for key in keys:
if t1[key]['open_p'][0] <= open_p and open_p < t1[key]['open_p'][1]:
return t1[key]
def isStockMatch(self, zs, stock, conf, hygn, netMoney, dh):
# if 'zs' in self.__config.get_t1()['strategy'] and not self.isZSMatch(zs,stock):
# return False
if 'time' in self.__config.get_t1(
)['strategy'] and not self.isTimeMatch(stock, conf):
return False
# if 'hygn' in self.__config.get_t1()['strategy'] and not self.isHygnMatch(stock,hygn):
# return False
# if 'net' in self.__config.get_t1()['strategy'] and not self.isNetMatch(stock,conf):
# return False
# if 'speed' in self.__config.get_t1()['strategy'] and stock.get_minR() != 'R5':
# if not self.isSpeedMatch(stock,conf):
# return False
# if 'pvmap' in self.__config.get_t1()['strategy'] and not self.isPriceVolumeMapMatch(stock):
# return False
# if 'netRatio' in self.__config.get_t1()['strategy'] and not self.netMoneyRatioMatch(stock,netMoney):
# return False
if 'xspeed' in self.__config.get_t1(
)['strategy'] and not self.isXSpeedMatch(dh, stock):
return False
if 'minR' in self.__config.get_t1(
)['strategy'] and not self.isReachMinR(stock):
return False
return self.isLastTwoMatch(stock)
def isZSMatch(self, zs, stock):
code = stock.get_code()
i = 0
if code.startswith('3'):
i = 5
line = zs.iloc[i]
pre_close = line.get('pre_close')
price = line.get('price')
p = (float(price) - float(pre_close)) / float(pre_close) * 100
return p > 0
def isXSpeedMatch(self, dh, stock):
now_line = stock.get_Lastline()
ccp = self.getCurrentPercent(stock)
ocp = self.getOpenPercent(stock)
if ocp - ccp >= self.__config.get_t1()['x_speed']['lowerThanBefore']:
stock.add_lowerThanBeforeTimes()
if stock.get_lowerThanBeforeTimes() > self.__config.get_t1(
)['x_speed']['lowerThanBeforeTimes']:
dh.add_buyed(stock.get_code(), False)
return False
ct = dt.datetime.strptime(now_line['date'] + ' ' + now_line['time'],
'%Y-%m-%d %H:%M:%S')
len = stock.len()
i = len - 2
if i > self.__config.get_t1()['x_speed']['maxStickNum']:
i = self.__config.get_t1()['x_speed']['maxStickNum']
while i >= 0:
line = stock.get_data().iloc[i]
price = float(line['price'])
pcp = self.getPercent(price, stock)
if pcp - ccp >= self.__config.get_t1(
)['x_speed']['lowerThanBefore']:
stock.add_lowerThanBeforeTimes()
if stock.get_lowerThanBeforeTimes() > self.__config.get_t1(
)['x_speed']['lowerThanBeforeTimes']:
dh.add_buyed(stock.get_code(), False)
return False
if ccp - pcp >= (10 -
pcp) * self.__config.get_t1()['x_speed']['a']:
if ccp - pcp >= (ccp - ocp) * self.__config.get_t1(
)['x_speed']['b'] and pcp > ocp:
pt = dt.datetime.strptime(
line['date'] + ' ' + line['time'], '%Y-%m-%d %H:%M:%S')
if (ct - pt).seconds / 60 <= (
ccp -
pcp) * self.__config.get_t1()['x_speed']['c']:
# MyLog.info('[%s] match cond a, ccp = %s, pcp = %s' % (stock.get_code(),ccp,pcp))
# MyLog.info('[%s] match cond b, ccp = %s, ocp = %s' % (stock.get_code(),ccp,ocp))
# MyLog.info('[%s] match cond c, ct = %s, pt = %s' % (stock.get_code(),ct,pt))
last_second_line = stock.get_LastSecondline()
deltaVolume = float(now_line['volume']) - float(
last_second_line['volume'])
deltaAmount = float(now_line['amount']) - float(
last_second_line['amount'])
stock.add_buySignal()
if stock.get_buySignal() >= self.__config.get_t1(
)['trade']['maxBuySignal'] or deltaVolume >= self.__config.get_t1(
)['x_speed'][
'minimumVolume'] or deltaAmount >= self.__config.get_t1(
)['x_speed']['minimumAmount']:
return True
return False
i = i - 1
stock.reset_buySignal()
# perform the calc time test
# now = dt.datetime.now()
# if stock.get_time() is not None:
# deltaSeconds = (now - stock.get_time()).seconds
# if deltaSeconds > 3:
# print('[%s] calc more than %s s' % (stock.get_code(),deltaSeconds))
# stock.set_time(now)
return False
def netMoneyRatioMatch(self, stock, netMoney):
if netMoney is None:
return False
return stock.get_code() in netMoney
def isHygnMatch(self, stock, hygn):
if hygn is None:
return False
code = stock.get_code()
if code not in self.__hygnData:
return False
stockHYGN = self.__hygnData[code]
if 'hy' in stockHYGN:
shys = stockHYGN['hy']
for shy in shys:
for hy in hygn['hy']:
if shy == hy:
return True
if 'gn' in stockHYGN:
sgns = stockHYGN['gn']
for sgn in sgns:
for gn in hygn['gn']:
if sgn == gn:
return True
return False
def isPriceVolumeMapMatch(self, stock):
pvMap = stock.getPriceVolumeMap()
if len(pvMap) < 2:
return True
lastPrice = 0
maxBuyVolume = 0
for pv in pvMap:
if lastPrice != 0:
if pv['price'] < lastPrice and maxBuyVolume != 0 and pv[
'volume'] > maxBuyVolume * self.__config.get_t1(
)['pvRatio']:
return False
if pv['price'] > lastPrice and pv['volume'] > maxBuyVolume:
maxBuyVolume = pv['volume']
lastPrice = pv['price']
return True
def isLastTwoMatch(self, stock):
data = stock.get_data()
if stock.len() < 3:
return False
price = float(data.iloc[-1].get('price'))
price2 = float(data.iloc[-2].get('price'))
price3 = float(data.iloc[-2].get('price'))
return price - price2 > 0 and price2 - price3 >= 0
def isSpeedMatch(self, stock, conf):
v30 = stock.get_speed('v30')
v120 = stock.get_speed('v120')
v300 = stock.get_speed('v300')
p = self.getCurrentPercent(stock)
v_list = [v30, v120, v300]
flag = False
if v_list[0] * 30 >= (
10 - p) * self.__config.get_t1()['speed']['v30_ratio']:
flag = True
elif v_list[0] >= self.__config.get_t1()['speed']['v30'] and (
v_list[1] >= self.__config.get_t1()['speed']['v120']
or v_list[2] >= self.__config.get_t1()['speed']['v300']):
flag = True
if flag == True:
last_line = stock.get_Lastline()
info = '[%s] *** [%s] match speed at %s %s,v30=%s,v120=%s,v300=%s ***' % (
Utils.getCurrentTime(), stock.get_code(), last_line['date'],
last_line['time'], str(v30), str(v120), str(v300))
MyLog.info(info)
return flag
def isBigMoneyMatch(self, stock, conf):
p = stock.get_net() / stock.getBigMoneyIn()
flag = p > self.__config.get_t1()['big_money']['threshold']
if flag == True:
last_line = stock.get_Lastline()
info = '[%s] *** [%s] match big_money at %s %s,net=%s,in=%s,p=%s ***' % (
Utils.getCurrentTime(), stock.get_code(), last_line['date'],
last_line['time'], str(
stock.get_net()), str(stock.getBigMoneyIn()), str(p * 100))
MyLog.info(info)
return flag
def isNetMatch(self, stock, conf):
last_line = stock.get_Lastline()
return stock.get_net() >= conf['big_money']['net'] * float(
last_line['price'])
def isTimeMatch(self, stock, conf):
lastLine = stock.get_Lastline()
timeStr = lastLine['time']
return timeStr <= conf['time']
def getPercent(self, price, stock):
lastLine = stock.get_Lastline()
pre_close = lastLine.get('pre_close')
open_p = (float(price) - float(pre_close)) / float(pre_close) * 100
return open_p
def getCurrentPercent(self, stock):
lastLine = stock.get_Lastline()
price = lastLine.get('price')
return self.getPercent(price, stock)
def getOpenPercent(self, stock):
ocp = stock.get_cache('ocp')
if ocp is not None:
return ocp
lastLine = stock.get_Lastline()
open = lastLine.get('open')
ocp = self.getPercent(open, stock)
stock.set_cache('ocp', ocp)
return ocp
def isReachMinR(self, stock):
now_p = self.getCurrentPercent(stock)
minR = stock.get_minR()
return now_p > stock.get_r_val(minR)
