def stock_list(request):
date = datetime.strptime(request.GET['date'], '%Y-%m-%d').date()
info = StockData().get_info(date=date,
date_start=date - timedelta(days=14))
info_today = info[info['date'] == date].dropna()
for i in range(1, 14):
info_yesterday = info[info['date'] == date - timedelta(days=i)]
if len(info_yesterday) > 0:
break
if len(info_today) == 0 or len(info_yesterday) == 0:
return JsonResponse({'ok': False, 'msg': '当天无基金数据，请更换日期'})
index = StockData().get_index()
info_today.loc[:, 'name'] = index['name']
info_today.loc[:, 'close_last'] = info_yesterday['close']
info_today.loc[:, 'adjclose_last'] = info_yesterday['adjclose']
info_today.loc[:,
'raising'] = (info_today.adjclose - info_today.adjclose_last
) / info_today.adjclose_last
result = []
for code, row in info_today.dropna().iterrows():
result.append(
(int(code), row['name'], row['open'], row['high'], row['low'],
row['close'], row['close_last'], row['raising'], row['volume']))
return HttpResponse(json.dumps(result))
def MA_n(code, date, n):
infos = StockData().get_info(code, date)
infos = infos.append(StockData().get_a_stock_days_before(
date, code, n - 1))
if len(infos) == n:
return mean(infos.close)
else:
return NaN
def get_index(request):
index = StockData().get_index()
min_date, max_date = StockData().get_date_range()
return HttpResponse(
json.dumps({
'min': str(min_date),
'max': str(max_date),
'index':
{int(code): row.to_dict()
for code, row in index.iterrows()}
}))
def stock(request):
result = {'dates': [], 'data': [], 'volume': []}
code = int(request.GET['code'])
infos = StockData().get_info(code=code, limit=500)
index = StockData().get_index()
result['name'] = index['name'][code]
for code, row in infos.iloc[::-1].dropna().iterrows():
result['dates'].append(str(row['date']))
result['data'].append(
(row['open'], row['close'], row['low'], row['high']))
result['volume'].append(row['volume'])
return HttpResponse(json.dumps(result))
def readPool(request):
stock_index = StockData().get_index()
result = {
'base': [],
'industries': [{
'name': row['name'],
'stocks': json.loads(row['stocks'])
} for id, row in StockData().get_industries().iterrows()],
'custom': []
}
if 'uid' in request.session:
uid = request.session['uid']
result['custom'] = [{
'id': pool.id,
'name': pool.name,
'stocks': json.loads(pool.stock_list)
} for pool in StockPool.objects.filter(uid=uid)]
return JsonResponse(result)
def stock_list(request):
date = datetime.strptime(request.GET['date'], '%Y-%m-%d').date()
info = StockData().get_info(date=date, date_start=date - timedelta(days=1))
info_today = info[info['date'] == date]
info_yesterday = info[info['date'] == date - timedelta(days=1)]
index = StockData().get_index()
info_today.loc[:, 'name'] = index['name']
info_today.loc[:, 'close_last'] = info_yesterday['close']
info_today.loc[:, 'adjclose_last'] = info_yesterday['adjclose']
info_today.loc[:,
'raising'] = (info_today.adjclose - info_today.adjclose_last
) / info_today.adjclose_last
result = []
for code, row in info_today.dropna().iterrows():
result.append(
(int(code), row['name'], row['open'], row['high'], row['low'],
row['close'], row['close_last'], row['raising'], row['volume']))
return HttpResponse(json.dumps(result))
def readPool(request):
stock_index = StockData().get_index()
result = {
'base': [
{
'name':
'沪深300',
'stocks':
stock_index[stock_index.index < 2000].index.values.tolist()
},
{
'name':
'中小板',
'stocks':
stock_index[(stock_index.index >= 2000) &
(stock_index.index < 3000)].index.values.tolist()
},
{
'name':
'创业板',
'stocks':
stock_index[stock_index.index >= 300000].index.values.tolist()
},
],
'industries': [{
'name': row['name'],
'stocks': json.loads(row['stocks'])
} for id, row in StockData().get_industries().iterrows()],
'custom': []
}
if 'uid' in request.session:
uid = request.session['uid']
result['custom'] = [{
'id': pool.id,
'name': pool.name,
'stocks': json.loads(pool.stock_list)
} for pool in StockPool.objects.filter(uid=uid)]
return JsonResponse(result)
def stock_predict(request):
code = int(request.GET['code'])
info = StockData().get_info(code=code, limit=90).iloc[::-1]
data = list(info['close'])
keras.backend.clear_session()
model = keras.models.load_model('model.h5')
new_data = lstm.pure_deal_data(data, 30)
predict_list = lstm.pure_predict(model, new_data)
predict_rate = [
((1 + predict_list[i]) * data[i] - data[i + 29]) / data[i + 29]
for i in range(len(predict_list))
]
real_rate = [(data[i + 30] - data[i + 29]) / data[i + 29]
for i in range(len(predict_list) - 1)]
return JsonResponse({
'tomorrow': predict_rate[-1],
'predict': predict_rate[:-1],
'real': real_rate,
'dates': list(info[-60:]['date'])
})
def run(args, ws):
print('Starting backtest')
# load args
start_date = args['start_date']
end_date = args['end_date']
universe = args['universe']
frequency = int(args['frequency'])
capital = 100000000
if len(universe) == 0:
ws.send(json.dumps({'error': True, 'msg': '未选中任何基金，请重新选择'}))
return
# load data
print('Loading stock data')
global stock_data
stock_data = StockData().get_info(date=end_date,
date_start=get_date(start_date) -
timedelta(days=90)).reset_index()
global trade_days
trade_days = stock_data['date'].drop_duplicates().tolist()
# load dates
start_date_index = end_date_index = -1
for i in range(0, len(trade_days)):
if end_date_index == -1 and trade_days[i] <= get_date(end_date):
end_date_index = i
if start_date_index == -1 and trade_days[i] <= get_date(start_date):
start_date_index = i
if start_date_index == -1:
start_date_index = len(trade_days) - 1
if end_date_index == -1:
end_date_index = 0
if start_date_index <= end_date_index:
ws.send(json.dumps({'error': True, 'msg': '选中日期范围内不包含交易日，请重新选择'}))
return
# init strategy and account
handler = imp.new_module('handler')
exec(args['code'], handler.__dict__)
account = Account(args['params'], universe, capital)
daily_earn_rate = []
base_earn_rate = []
drawdown = []
infos = []
win_times = 0
history_max_value = 0
for i in range(start_date_index, end_date_index, -frequency):
account.set_date_index(i)
handler.handle(account)
# portofolio
if history_max_value < account.portfolio:
history_max_value = account.portfolio
new_portfolio = account.cash
for stk in account.sec_pos:
if stk in account.price:
new_portfolio += account.sec_pos[stk] * account.price[stk]
account.portfolio = new_portfolio
# earning rate
earn_rate = (new_portfolio - capital) / capital
daily_earn_rate.append(earn_rate)
# base earning rate
if i == start_date_index:
base_stock_price = numpy.mean(list(account.price.values()))
today_base_earn_rate = (numpy.mean(list(account.price.values())) -
base_stock_price) / base_stock_price
base_earn_rate.append(today_base_earn_rate)
# update win times
if earn_rate > today_base_earn_rate:
win_times += 1
# Max Drawdown
drawdown.append(1 - new_portfolio / history_max_value)
# update progress
progress = int((start_date_index - i) * 100.0 /
(start_date_index - end_date_index))
info = {
'progress': progress,
'date': trade_days[i].strftime('%Y-%m-%d'),
'cash': account.cash,
'earn_rate': earn_rate,
'base_earn_rate': today_base_earn_rate
}
infos.append(info)
ws.send(json.dumps(info))
annualized = daily_earn_rate[-1] / (start_date_index - end_date_index +
1) * 250
base_annualized = base_earn_rate[-1] / (start_date_index - end_date_index +
1) * 250
win_rate = win_times * 1.0 / len(daily_earn_rate)
sharp = (annualized - 0.0175) / numpy.std(daily_earn_rate)
beta = calc_beta(daily_earn_rate, base_earn_rate)
alpha = calc_alpha(annualized, base_earn_rate, beta)
max_drawdown = max(drawdown)
result = {
'success': True,
'annualized': annualized,
'max_drawdown': max_drawdown,
'base_annualized': base_annualized,
'win_rate': win_rate,
'sharp': sharp,
'beta': beta,
'alpha': alpha
}
ws.send(json.dumps(result))
time.sleep(3)
return {'infos': infos, 'result': result}
def market(request):
start = time.time()
result = {
'volumes': [],
'top_surge': [],
'top_decline': [],
'top_industries': [],
'last_industries': []
}
date = datetime.strptime(request.GET['date'], '%Y-%m-%d').date()
index = StockData().get_index()
info = StockData().get_info(date=date,
date_start=date - timedelta(days=14))
dates = info['date'].drop_duplicates()
for row in dates:
result['volumes'].append(
(str(row), int(info[info['date'] == row]['volume'].sum())))
info_today = info[info['date'] == date].dropna()
for i in range(1, 14):
info_yesterday = info[info['date'] == date - timedelta(days=i)]
if len(info_yesterday) > 0:
break
if len(info_today) == 0 or len(info_yesterday) == 0:
return JsonResponse({'ok': False, 'msg': '当天无股票数据，请更换日期'})
info_today['name'] = index['name']
info_today['adjclose_last'] = info_yesterday['adjclose']
info_today['raising'] = (info_today.adjclose - info_today.adjclose_last
) / info_today.adjclose_last
info_today = info_today.sort_values('raising', ascending=False)
for code, stk in info_today[
info_today['raising'] >= 0].iloc[:20].iterrows():
result['top_surge'].append({
'code': int(code),
'name': stk['name'],
'close': stk['close'],
'rate': stk['raising']
})
for code, stk in info_today[
info_today['raising'] <= 0].iloc[:-21:-1].iterrows():
result['top_decline'].append({
'code': int(code),
'name': stk['name'],
'close': stk['close'],
'rate': stk['raising']
})
industries = StockData().get_industries()
industries['total'] = pandas.Series()
industries['surged'] = pandas.Series()
industries['declined'] = pandas.Series()
for index, row in industries.iterrows():
stk_list = json.loads(row['stocks'])
stk_info = info_today[info_today.index.isin(stk_list)]
industries.loc[index, 'total'] = len(stk_info)
industries.loc[index,
'surged'] = len(stk_info[stk_info['raising'] > 0])
industries.loc[index,
'declined'] = len(stk_info[stk_info['raising'] < 0])
industries['rate'] = industries['surged'] / industries['total']
industries['dec_rate'] = industries['declined'] / industries['total']
industries = industries.sort_values('rate', ascending=False)
for _, row in industries[industries['rate'] >= 0].iloc[:10].iterrows():
result['top_industries'].append({
'name': row['name'],
'total': row['total'],
'count': row['surged'],
'rate': row['rate']
})
industries = industries.sort_values('dec_rate', ascending=False)
for _, row in industries[industries['dec_rate'] >= 0].iloc[:10].iterrows():
result['last_industries'].append({
'name': row['name'],
'total': row['total'],
'count': row['declined'],
'rate': row['dec_rate']
})
result['total'] = len(info_today)
result['surged'] = len(info_today[info_today.raising > 0])
result['balanced'] = len(info_today[info_today.raising == 0])
result['declined'] = len(info_today[info_today.raising < 0])
return JsonResponse(result)
from datetime import timedelta, datetime
from stock.data.stock_data import StockData
import stock.data.qtshare as qts
if __name__ == '__main__':
sd = StockData()
index = sd.get_index()
print('Total:', len(index))
end_date = datetime.now()
count = 0
for code, row in index.iterrows():
try:
max_date = sd.get_info(code=code, limit=1).iloc[0]['date']
start_date = max_date + timedelta(days=1)
df = qts.history(code, start_date, end_date)
df = df[df['volume'] != 0]
df['adjclose'] = df['close']
print(df)
df.to_sql('stock_data', sd.conn, index=False, if_exists='append')
count += 1
print('Finished:', code, ', progress:', count, '/', len(index))
except:
pass
from datetime import timedelta, datetime
import sys
from stock.data.stock_data import StockData
import stock.data.qtshare as qts
if __name__ == '__main__':
a = int(sys.argv[1])
b = int(sys.argv[2])
sd = StockData()
index = sd.get_index().index.values.tolist()
print('Total:', len(index))
end_date = datetime.now() - timedelta(days=1)
count = 0
for i in range(0, len(index)):
if i >= a and i < b:
code = index[i]
try:
info = sd.get_info(code=code, limit=1)
if len(info) == 0:
max_date = datetime(2016, 12, 31)
else:
max_date = info.iloc[0]['date']
start_date = max_date + timedelta(days=1)
df = qts.history(code, start_date, end_date)
# df = df[df['volume'] != 0]
df['adjclose'] = df['volume']
print(df)
df.to_sql('stock_data',
sd.conn,
index=False,
