def _create_stop_cond(self, label_text, name, layout, col):
# Create an indicator to show stop status
ind = Indicator(self, QColor(255, 0, 0))
ind.setFixedSize(25, 20)
layout.addWidget(ind, 0, col)
layout.setAlignment(ind, Qt.AlignCenter)
self._stop_inds[name] = ind
# Add a switch to control the stop control state
check = QCheckBox(self)
check.setFixedSize(20, 20)
check.setStyleSheet(
'QCheckBox::indicator{subcontrol-position:center;}')
layout.addWidget(check, 1, col)
layout.setAlignment(check, Qt.AlignCenter)
check.stateChanged.connect(self._set_stop_conds)
self._stop_switches[name] = check
# Create a label for the inhibit switch
label = QLabel(label_text, self)
label.setAlignment(Qt.AlignCenter)
font = label.font()
font.setPointSize(7)
font.setBold(True)
label.setFont(font)
label_height = 2 if '\n' in label_text else 1
layout.addWidget(label, 2, col, label_height, 1)
layout.setAlignment(label, Qt.AlignCenter | Qt.AlignTop)
def give_result_special(data, mt=None, get_json=True):
if mt is None:
mt = Indicator(name=data['symbol_id'])
valid = int(data['valid'])
special = {'function_name': data['indicators']['special']['name']}
special = add_apply_to(special, 'special', data)
if 'params' in data['indicators']['special']:
params = data['indicators']['special']['params']
for param in params:
special[param] = float(params[param])
indicator_special_org = bt.shifter(mt.indicator_calculator(**special),
int(data['indicators']['special']['settings']['shift']))
# indicator_ascending = indicator_ascending_org[data['indicators']['ascending']['output']['name']]
# indicator_ascending = pd.DataFrame(indicator_ascending)
outputs = data['indicators']['special']['outputs']
indicators = {'special': {}}
for output in outputs:
indicators['special'][output] = indicator.add_time(pd.DataFrame(indicator_special_org[output])).to_json(
orient='values')
result = bt.special(indicator_special_org, data['indicators']['special']['name'])
result = bt.set_valid_time(result, valid)
indicators['result'] = result.to_json(orient='values')
indicators['type'] = 'first'
# add_to_db(data['id'],result)
if not get_json:
return indicators
return json.dumps(indicators)
def save_df(df_list, ifcode, today, period_short, period_long):
df = pd.DataFrame(df_list, columns=['time_index', 'price', 'volume'])
price = list(df['price'])
df['ema_short'] = Indicator.ema_metric(period_short, price)
df['ema_long'] = Indicator.ema_metric(period_long, price)
#macd
macd_df = point_prosess_v3(df, 8)
macd_df['ma_short'] = Indicator.ewma_metric(12, macd_df[['price']], 'price', False)
macd_df['ma_long'] = Indicator.ewma_metric(26, macd_df[['price']], 'price', False)
macd_df['macd_dif'] = macd_df['ma_short'] - macd_df['ma_long']
macd_dif = list(macd_df['macd_dif'])
macd_df['macd_dem'] = Indicator.ewma_metric(9, macd_df[['macd_dif']], 'macd_dif')
_macd_file = '%s/%s_%s_macd' % (validate_df_dir, ifcode, today)
macd_df.to_csv(_macd_file, index=False)
sig_infos = PushSellSignal.compare_sig(macd_df, 'macd_dif', 'macd_dem', 16)
profit_infos = PushSellSignal.profit_infos(sig_infos)
print '*******macd******'
print profit_infos
print len(profit_infos)
_file = '%s/%s_%s' % (validate_df_dir, ifcode, today)
df.to_csv(_file, index=False)
sig_infos = PushSellSignal.compare_sig(df, 'ema_short', 'ema_long')
profit_infos = PushSellSignal.profit_infos(sig_infos)
print '*******ema*******'
print profit_infos
print len(profit_infos)
def give_result_ascending(data, mt=None, get_json=True):
if mt is None:
mt = Indicator(name=data['symbol_id'])
days = int(data['days'])
valid = int(data['valid'])
ascending = {'function_name': data['indicators']['ascending']['name']}
ascending = add_apply_to(ascending, 'ascending', data)
if 'params' in data['indicators']['ascending']:
params = data['indicators']['ascending']['params']
for param in params:
ascending[param] = float(params[param])
indicator_ascending_org = bt.shifter(mt.indicator_calculator(**ascending),
int(data['indicators']['ascending']['settings']['shift']))
indicator_ascending = indicator_ascending_org[data['indicators']['ascending']['output']['name']]
indicator_ascending = pd.DataFrame(indicator_ascending)
outputs = data['indicators']['ascending']['outputs']
indicators = {'ascending': {}}
for output in outputs:
indicators['ascending'][output] = indicator.add_time(pd.DataFrame(indicator_ascending_org[output])).to_json(
orient='values')
# print('monoto called!')
result = bt.monotono(indicator_ascending, days)
result = bt.set_valid_time(result, valid)
indicators['type'] = 'first'
indicators['result'] = result.to_json(orient='values')
if not get_json:
return indicators
return json.dumps(indicators)
def main(ifcode, period_short, period_long):
rs = []
total = 0
pos_num = 0
nag_num = 0
date_list = ifcode_day_map(ifcode)
for day in date_list:
df = get_data(ifcode, day)
#df = point_prosess_v2(_df, 30)
df['ema_short'] = Indicator.ewma_metric(period_short, df[['price']],
'price')
df['ema_long'] = Indicator.ewma_metric(period_long, df[['price']],
'price')
sig_infos = SellSignal.compare_ema(df, period_short, offset=5)
profit_infos = SellSignal.profit_infos(sig_infos)
profit_all = 0
trans_num = (len(profit_infos) + 1) / 2
for item in profit_infos:
if item['gain'] != '-':
profit_all += int(item['gain'])
rs.append({day: profit_all, 'trans_num': trans_num})
total += profit_all
if profit_all >= 0:
pos_num += 1
elif profit_all < 0:
nag_num += 1
pprint(rs)
print '%s total: %s' % (ifcode, total)
print '%s profit rate: %.2f' % (ifcode, pos_num * 1.0 / nag_num)
def give_result_draw(data, mt=None, get_json=True):
if mt is None:
mt = Indicator(name=data['symbol_id'])
draw = {'function_name': data['indicators']['draw']['name']}
draw = add_apply_to(draw, 'draw', data)
if 'params' in data['indicators']['draw']:
params = data['indicators']['draw']['params']
for param in params:
draw[param] = float(params[param])
indicator_draw_org = bt.shifter(mt.indicator_calculator(**draw),
int(data['indicators']['draw']['settings']['shift']))
# print(data['stock_name'])
# print(draw)
# print(calc_filter.delay(data['stock_name'],draw).get())
# print(type(calc_filter.delay(data['stock_name'],draw).get()))
# indicator_draw_org = bt.shifter(calc_filter.delay(data['stock_name'],draw).get(),
# int(data['indicators']['draw']['settings']['shift']))
#
outputs = data['indicators']['draw']['outputs']
indicators = {'draw': {}}
for output in outputs:
indicators['draw'][output] = indicator.add_time(pd.DataFrame(indicator_draw_org[output])).to_json(
orient='values')
indicators['type'] = 'default'
# return indicators
if not get_json:
return indicators
return json.dumps(indicators)
def _create_inh_control(self, name, parent, layout, col):
# Create a label for the inhibit switch
label = QLabel(name, parent)
label.setAlignment(Qt.AlignCenter)
font = label.font()
font.setPointSize(7)
font.setBold(True)
label.setFont(font)
layout.addWidget(label, 0, col)
# Add an indicator to show inhibit state
ind = Indicator(parent, QColor(255, 120, 0))
ind.setFixedSize(20, 20)
layout.addWidget(ind, 1, col)
layout.setAlignment(ind, Qt.AlignCenter)
# Add a switch to control the inhibit state
check = QCheckBox(parent)
check.setFixedSize(20, 20)
check.setStyleSheet(
'QCheckBox::indicator{subcontrol-position:center;}')
layout.addWidget(check, 2, col)
layout.setAlignment(check, Qt.AlignCenter)
layout.setColumnMinimumWidth(col, 25)
self._inh_switches.append(check)
self._inh_inds.append(ind)
def get(self):
self.response.headers['Content-Type'] = 'text/plain'
self.response.write('Reading Logframe...')
# Create the log frame object.
lf = LogicalFramework("Strengthening Afghanistan's Budget II", 5.03)
ctrler = Controller(lf)
# Set the high-level statements for the logframe.
ctrler.set_impact("The GIRoA can effectively manage resources in support of economic growth and to improve the lives of the Afghan people.")
ctrler.set_outcome("Transparent and well functioning GIRoA budget process.")
# Create and add high-level indicators for the logframe.
imp_ind = Indicator(1, "GDP Growth", 0, 5)
ctrler.add_impact_indicator(imp_ind)
oc_ind = Indicator(2, "Transparency Index", 21, 27)
ctrler.add_outcome_indicator(oc_ind)
# Add assumptions for the logframe.
impact_assumption1 = Assumption(assumption_level.IMPACT, 1, "Assuming the Government wishes to make public financial management reforms")
outcome_assumption1 = Assumption(assumption_level.OUTCOME, 1, "Assuming the Government assigns qualified staff to the team")
ctrler.add_impact_assumption(impact_assumption1)
ctrler.add_outcome_assumption(outcome_assumption1)
ctrler.display()
def push_signal(df_list, code, ifcode, today, period_short, period_long):
df = pd.DataFrame(df_list, columns=['time_index', 'price', 'volume'])
price = list(df['price'])
df['ema_short'] = Indicator.ema_metric(period_short, price)
df['ema_long'] = Indicator.ema_metric(period_long, price)
sig_infos = PushSellSignal.compare_ema(df)
profit_infos = PushSellSignal.profit_infos(sig_infos)
if is_push(profit_infos, ifcode, today):
if len(profit_infos) == 1:
print '*' * 20
print 'init message~!'
time_str = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
info_dict = profit_infos[0]
theevent = info_dict.get('event', '')
is_success = 'failed'
#添加交易接口
if theevent == '卖出信号':
trans_session = yinhe_trans()
r = trans_short_start(trans_session, code, ifcode)
if 'error_info' not in r:
is_success = '交易成功'
elif theevent == '买入信号':
trans_session = yinhe_trans()
r = trans_long_start(trans_session, code, ifcode)
if 'error_info' not in r:
is_success = '交易成功'
tip = 'ema 策略: \n%s, 交易价格: %s; 时间: %s; %s' % (
theevent, info_dict.get('price', 0), time_str, is_success)
push_sig(tip)
elif len(profit_infos) >= 2:
print '*' * 20
print 'push message~!'
time_str = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
info_dict_1 = profit_infos[-2]
info_dict_2 = profit_infos[-1]
_p = info_dict_2.get('price', 0)
trading_fee = cal_fee(_p)
_g = info_dict_1.get('gain', 0)
gain = _g - trading_fee
theevent = info_dict_2.get('event', '')
is_success = 'failed'
#添加交易接口
if theevent == '卖出信号':
trans_session = yinhe_trans()
r1 = trans_short_close(trans_session, code, ifcode)
r2 = trans_short_start(trans_session, code, ifcode)
if 'error_info' not in r1 and 'error_info' not in r2:
is_success = '交易成功'
elif theevent == '买入信号':
trans_session = yinhe_trans()
r1 = trans_long_close(trans_session, code, ifcode)
r2 = trans_long_start(trans_session, code, ifcode)
if 'error_info' not in r1 and 'error_info' not in r2:
is_success = '交易成功'
tip = 'ema 策略: \n%s, 盈利: %s, 实际盈利: %s, 交易费用: %s; \n%s, 交易价格: %s; 时间: %s; %s' % (
info_dict_1.get('event', ''), _g, gain, trading_fee,
info_dict_2.get('event', ''), _p, time_str, is_success)
push_sig(tip)
def __init__(self, utils, config, logger): Indicator.__init__(self, utils, config, logger) self.timeframe = self.conf["timeframe"] self.distance = self.conf["distance"] self.period = self.conf["period"] self.sell = self.conf["sell"] self.buy = self.conf["buy"]
def _add_indicator(self, settings):
exchange = settings.get('exchange')
refresh = settings.get('refresh')
asset_pair = settings.get('asset_pair')
default_label = settings.get('default_label')
indicator = Indicator(self, exchange, asset_pair, refresh,
default_label)
self.instances.append(indicator)
indicator.start()
def ema_df(cls, date, ifcode, period_short, period_long):
data = BacktestData.get_data_by_ifcode(date, ifcode)
if not data:
return pd.DataFrame()
df = pd.DataFrame(data, columns=['time_index', 'price', 'volume'])
price = list(df['price'])
df['ema_short'] = Indicator.ema_metric(period_short, price)
df['ema_long'] = Indicator.ema_metric(period_long, price)
return df
def start(self):
indicator = Indicator()
command = GetTemperatureCommand()
state = State()
state.setCommand(command)
indicator.setState(state)
indicator.start()
gtk.main()
def macd_df(_df, period_short, period_long, period_dif=9):
df = point_prosess_v2(_df, 59)
df['ma_short'] = Indicator.ewma_metric(period_short, df[['price']],
'price')
df['ma_long'] = Indicator.ewma_metric(period_long, df[['price']], 'price')
df['macd_dif'] = df['ma_short'] - df['ma_long']
df['macd_dem'] = Indicator.ewma_metric(period_dif, df[['macd_dif']],
'macd_dif')
return df
def give_result_backtest(name, res, config):
# print(config)
mt = Indicator(name=name)
price = {'function_name': 'close'}
price = mt.indicator_calculator(**price)
for setting in ['stop loss', 'take profit']:
config[setting]['apply'] = mt.indicator_calculator(**{'function_name': config[setting]['apply']})
res = pd.DataFrame(data=res)
# result = bt.BackTest(price, res, config).back_test()
result = bt.testresult(price, res, config)
return json.dumps(result)
def _create_alarm(self, name, color, layout, col):
# Create an indicator to show alarm status
ind = Indicator(self, color)
ind.setFixedSize(25, 20)
layout.addWidget(ind, 1, col)
layout.setAlignment(ind, Qt.AlignCenter)
self._alarm_inds[name.lower()] = ind
# Create a label for the indicator
label = self._create_label(name, self)
layout.addWidget(label, 0, col, 1, 1)
layout.setAlignment(label, Qt.AlignCenter | Qt.AlignTop)
def give_result_more(data, mt=None, get_json=True):
if mt is None:
mt = Indicator(name=data['symbol_id'])
valid = int(data['valid'])
indicators = {'main': {}, 'minor': {}}
main = {'function_name': data['indicators']['main']['name']}
main = add_apply_to(main, 'main', data)
if 'params' in data['indicators']['main']:
params = data['indicators']['main']['params']
for param in params:
main[param] = float(params[param])
indicator_main_org = bt.shifter(mt.indicator_calculator(**main),
int(data['indicators']['main']['settings']['shift']))
indicator_main = indicator_main_org[data['indicators']['main']['output']['name']]
indicator_main = pd.DataFrame(indicator_main)
outputs = data['indicators']['main']['outputs']
for output in outputs:
indicators['main'][output] = indicator.add_time(pd.DataFrame(indicator_main_org[output])).to_json(
orient='values')
minor = {'function_name': data['indicators']['minor']['name']}
minor = add_apply_to(minor, 'minor', data)
if 'params' in data['indicators']['minor']:
params = data['indicators']['minor']['params']
for param in params:
minor[param] = float(params[param])
indicator_minor_org = bt.shifter(mt.indicator_calculator(**minor),
int(data['indicators']['minor']['settings']['shift']))
indicator_minor = indicator_minor_org[data['indicators']['minor']['output']['name']]
indicator_minor = pd.DataFrame(indicator_minor)
outputs = data['indicators']['minor']['outputs']
for output in outputs:
indicators['minor'][output] = indicator.add_time(pd.DataFrame(indicator_minor_org[output])).to_json(
orient='values')
more = bt.more_than(indicator_main, indicator_minor)
more = bt.set_valid_time(bt.change_df(more), valid)
indicators['type'] = 'second'
indicators['result'] = more.to_json(orient='values')
# add_to_db(data['id'],more)
# print(more.head(10))
if not get_json:
return indicators
return json.dumps(indicators)
def boll_df(cls, date, ifcode, period_short, period_long, pre_point):
data = BacktestData.get_data_by_ifcode(date, ifcode)
if not data:
return pd.DataFrame()
_df = pd.DataFrame(data, columns=['time_index', 'price', 'volume'])
df = point_prosess(_df, pre_point)
price_list = list(df['price'])
df['boll_mb'] = Indicator.ma_metric(period_short, price_list)
mb_list = list(df['boll_mb'])
df['boll_md'] = Indicator.boll_md_metric(period_long, mb_list)
df['boll_up'] = df['boll_mb'] + 2.0 * df['boll_md']
df['boll_dn'] = df['boll_mb'] - 2.0 * df['boll_md']
return df
def give_result_cross(data, mt=None, get_json=True):
if mt is None:
mt = Indicator(name=data['symbol_id'])
valid = int(data['valid'])
indicators = {'shorter': {}, 'longer': {}}
shorter = {'function_name': data['indicators']['shorter']['name']}
shorter = add_apply_to(shorter, 'shorter', data)
if 'params' in data['indicators']['shorter']:
params = data['indicators']['shorter']['params']
for param in params:
shorter[param] = float(params[param])
indicator_shorter_org = bt.shifter(mt.indicator_calculator(**shorter),
int(data['indicators']['shorter']['settings']['shift']))
# print(indicator_shorter_org)
indicator_shorter = indicator_shorter_org[data['indicators']['shorter']['output']['name']]
indicator_shorter = pd.DataFrame(indicator_shorter)
outputs = data['indicators']['shorter']['outputs']
for output in outputs:
indicators['shorter'][output] = indicator.add_time(pd.DataFrame(indicator_shorter_org[output])).to_json(
orient='values')
longer = {'function_name': data['indicators']['longer']['name']}
longer = add_apply_to(longer, 'longer', data)
if 'params' in data['indicators']['longer']:
params = data['indicators']['longer']['params']
for param in params:
longer[param] = float(params[param])
indicator_longer_org = bt.shifter(mt.indicator_calculator(**longer),
int(data['indicators']['longer']['settings']['shift']))
indicator_longer = indicator_longer_org[data['indicators']['longer']['output']['name']]
indicator_longer = pd.DataFrame(indicator_longer)
outputs = data['indicators']['longer']['outputs']
for output in outputs:
indicators['longer'][output] = indicator.add_time(pd.DataFrame(indicator_longer_org[output])).to_json(
orient='values')
cross = bt.cross(indicator_shorter, indicator_longer)
cross = bt.set_valid_time(cross, valid)
indicators['type'] = 'first'
indicators['result'] = cross.to_json(orient='values')
# add_to_db(data['id'],cross)
if not get_json:
return indicators
return json.dumps(indicators)
def _add_indicator(self, settings):
exchange = settings.get('exchange')
refresh = settings.get('refresh')
asset_pair = settings.get('asset_pair')
default_label = settings.get('default_label')
self.unique_id += 1
indicator = Indicator(
self,
self.unique_id,
exchange,
asset_pair,
refresh,
default_label)
self.instances.append(indicator)
indicator.start()
return indicator
def _create_status_light(self, name, parent, layout, col):
label = QLabel(name, parent)
label.setAlignment(Qt.AlignCenter)
font = label.font()
font.setPointSize(7)
font.setBold(True)
label.setFont(font)
layout.addWidget(label, 1, col)
# Add an indicator to show inhibit state
ind = Indicator(parent, QColor(255, 0, 0))
ind.setFixedSize(20, 20)
layout.addWidget(ind, 2, col)
layout.setAlignment(ind, Qt.AlignCenter)
return ind
def macd_df(cls, date, ifcode, period_short, period_long, period_dif,
pre_point, pre_time):
data = BacktestData.get_macd_data_by_ifcode(date, ifcode, pre_time)
if not data:
return pd.DataFrame()
_df = pd.DataFrame(data, columns=['time_index', 'price', 'volume'])
df = point_prosess_v3(_df, pre_point)
#df = point_prosess_v2(_df, pre_point)
df['ma_short'] = Indicator.ewma_metric(period_short, df[['price']],
'price', False)
df['ma_long'] = Indicator.ewma_metric(period_long, df[['price']],
'price', False)
df['macd_dif'] = df['ma_short'] - df['ma_long']
df['macd_dem'] = Indicator.ewma_metric(period_dif, df[['macd_dif']],
'macd_dif', True)
return df
def ema_chart(cls, date, ifcode, period_short, period_long):
_file = '%s/%s_%s_%s_%s' % (ema_file_dir, date, ifcode, period_short,
period_long)
if os.path.isfile(_file):
df = read_df(_file)
else:
data = BacktestData.get_data_by_ifcode(date, ifcode)
df = pd.DataFrame(data, columns=['time_index', 'price', 'volume'])
price = list(df['price'])
df['ema_short'] = Indicator.ema_metric(period_short, price)
df['ema_long'] = Indicator.ema_metric(period_long, price)
price = df[['time_index', 'price']].values.tolist()
ema_short = df[['time_index', 'ema_short']].values.tolist()
ema_long = df[['time_index', 'ema_long']].values.tolist()
volume = df[['time_index', 'volume']].values.tolist()
return [price, ema_short, ema_long, volume]
def give_result_candlestick(data, mt=None, get_json=True):
if mt is None:
mt = Indicator(name=data['symbol_id'])
valid = int(data['valid'])
candlestick = {'function_name': data['indicators']['candlestick']['name']}
# ascending['price'] = data['apply_to']
if 'params' in data['indicators']['candlestick']:
params = data['indicators']['candlestick']['params']
for param in params:
candlestick[param] = float(params[param])
indicator_candlestick_org = bt.shifter(mt.indicator_calculator(**candlestick),
int(data['indicators']['candlestick']['settings']['shift']))
indicator_candlestick = indicator_candlestick_org[data['indicators']['candlestick']['output']['name']]
indicator_candlestick = pd.DataFrame(indicator_candlestick)
# for i in indicator_candlestick.index:
# if indicator_candlestick['integer'][i] not in [0,200,-200]:
# print('f**k: ',indicator_candlestick['integer'][i])
# indicator_candlestick_display = []
# high = mt.indicator_calculator(**{'function_name':'high'})
# low = mt.indicator_calculator(**{'function_name':'low'})
# for i in indicator_candlestick.index:
# if indicator_candlestick['integer'][i] != 0:
# indicator_candlestick_display +=[[i,1.05*high['real'][i],0.95*low['real'][i]]]
# df = pd.DataFrame(indicator_candlestick_display)
# indicators['test'] = df.to_json(orient='values')
indicators = {'candlestick': {}}
outputs = data['indicators']['candlestick']['outputs']
for output in outputs:
indicators['candlestick'][output] = indicator.add_time(pd.DataFrame(indicator_candlestick_org[output])).to_json(
orient='values')
indicator_candlestick = indicator_candlestick.replace([100, -100], [1, -1])
result = indicator_candlestick
result = bt.set_valid_time(result, valid)
indicators['type'] = 'first'
indicators['result'] = result.to_json(orient='values')
if not get_json:
return indicators
return json.dumps(indicators)
class App:
def __init__(self, ib: IB):
self.ib = ib
self.root = tk.Tk()
self.loop = asyncio.get_event_loop()
self.root.title("ModelTrader Indicators")
self.root.protocol('WM_DELETE_WINDOW', self._onDeleteWindow)
self.root.minsize(width=250, height=50)
self.qtrhour = Indicator(self.root, "Time of Check","")
self.connected = Indicator(self.root, "Connected", "True")
self.contract = Indicator(self.root, "Contract", "")
#self.root.sub1("current period")
self.cci15 = Indicator(self.root, "CCI (15m)", "")
self.cci15_av = Indicator(self.root, "CCI Avg (15m)", "")
self.atr15 = Indicator(self.root, "ATR (15m)", "")
self.bband15_width = Indicator(self.root, "BBAND Width (15m)", "")
self.bband15_b = Indicator(self.root, "BBAND %B (15m)", "")
self.cci15p = Indicator(self.root, "CCI (15p)", "")
self.cci15p_av = Indicator(self.root, "CCIP Avg (15m)", "")
self.ib.connectedEvent += self.connectEvent
self.ib.disconnectedEvent += self.disconnectEvent
def run(self):
self._onTimeout()
logic.Algo(self.ib, self).run()
self.loop.run_forever()
def _onTimeout(self):
self.root.update()
self.loop.call_later(0.03, self._onTimeout)
def _onDeleteWindow(self):
self.loop.stop()
def connectEvent(self):
self.connected.update("Connected")
logger.getLogger().info("Connected.")
def disconnectEvent(self):
self.connected.update("Disconnected")
logger.getLogger().info("Disconnected.")
def boll_chart(cls,
date,
ifcode,
period_short=50,
period_long=80,
offset=10):
df_list = realtime_data(date, ifcode)
df = pd.DataFrame(df_list, columns=['time_index', 'price', 'volume'])
boll_df = point_prosess(df, offset)
price_list = list(boll_df['price'])
boll_df['boll_mb'] = Indicator.ma_metric(period_short, price_list)
mb_list = list(boll_df['boll_mb'])
boll_df['boll_md'] = Indicator.boll_md_metric(period_long, mb_list)
boll_df['boll_up'] = boll_df['boll_mb'] + 2.0 * boll_df['boll_md']
boll_df['boll_dn'] = boll_df['boll_mb'] - 2.0 * boll_df['boll_md']
price = boll_df[['time_index', 'price']].values.tolist()
boll_up = boll_df[['time_index', 'boll_up']].values.tolist()
boll_dn = boll_df[['time_index', 'boll_dn']].values.tolist()
boll_mb = boll_df[['time_index', 'boll_mb']].values.tolist()
return price, boll_up, boll_dn, boll_mb
def get_performance_list(self, average_position_signal_array_norm):
# average_position_signal_array_norm = self.get_average_position_signal_array(self.position_signal_array_list)
indi_obj = Indicator(self, average_position_signal_array_norm)
ret = indi_obj.get_total_return()
mean_tvr = indi_obj.get_mean_turnover()
dd, dd_start, dd_end = indi_obj.get_max_drawdown()
sharp = indi_obj.get_sharp()
ret2dd = indi_obj.get_return_divide_dd()
mg_bp = indi_obj.get_margin_bp()
indi_list = [
'average', self.window_period, self.std_num, self.start_time[:-4],
self.end_time[:-4], ret, mean_tvr, sharp, ret2dd, dd, dd_start,
dd_end, mg_bp
]
return indi_list
def build_ta_feature(symbol: str, daily: Sequence[tuple],
save_feature: bool = True) -> pd.DataFrame:
'''Build features using the daily time series data. Indicators like EMA
should be computed using the complete set of data (instead of a subset)
@param: symbol: stock symbol that the daily data belongs to
@param: daily: daily time series data for a symbol
@param: save_feature: whether to save the features to file
'''
logger.info('Build ta feature for: %s. Last daily date: %s', symbol, daily[-1][0])
col_dtype = {'date': object, 'open': 'float64', 'high': 'float64', 'low': 'float64',
'close': 'float64', 'adj_close': 'float64', 'volume': 'int32'}
df = pd.DataFrame(daily, columns=col_dtype.keys(), dtype=object)
df = df.astype(col_dtype, copy=True)
high, low, close, volume = df['high'], df['low'], df['close'], df['volume']
# Overlap Studies
upperband, middleband, lowerband = Indicator.BBANDS(close, timeperiod=5)
df['ub_r'], df['mb_r'], df['lb_r'] = upperband / close, middleband / close, lowerband / close
df['trima_r'] = Indicator.TRIMA(close, timeperiod=30) / close
df['wma_r'] = Indicator.WMA(close, timeperiod=30) / close
# Momentum Indicator
macd, macdsignal, macdhist = Indicator.MACD(close, fastperiod=12, slowperiod=26, signalperiod=9)
df['macdhist'] = macdhist
df['ppo'] = Indicator.PPO(close, fastperiod=12, slowperiod=26)
df['rsi'] = Indicator.RSI(close, timeperiod=14)
# Volume Indicator
df['adosc'] = Indicator.ADOSC(high, low, close, volume * 1.0, fastperiod=3, slowperiod=10)
# Volatility Indicator
df['natr'] = Indicator.NATR(high, low, close, timeperiod=14)
# Drop rows with NaN values
df.dropna(axis=0, how='any', inplace=True)
# Drop useless columns
col_drop = ['open', 'high', 'low', 'close', 'volume']
df.drop(columns=col_drop, inplace=True)
if save_feature:
df.to_csv(_data_folder + '{0}_ta.csv'.format(symbol), float_format='%.4f', index=False)
return df
def give_update_indicators(data):
price = data['price']
data = data['params']
draw = {'function_name': data['name']}
draw = add_apply_to(draw, 'draw', data)
length = 5
if 'params' in data:
params = data['params']
for param in params:
draw[param] = float(params[param])
length = np.max([length, np.abs(float(params[param]))])
length = 10 * (int(length) + 2)
tail = {'price': price, 'length': length}
mt = Indicator(name=data['symbol_id'], tail=tail)
# mt = Indicator(name=data['symbol_id'])
indicator_draw_org = mt.indicator_calculator(**draw)
outputs = data['outputs']
indicators = {}
for output in outputs:
indicators[outputs[output]['id']] = indicator.add_time(
pd.DataFrame(indicator_draw_org[output].tail(1))).to_json(
orient='values')
print(indicators)
return json.dumps(indicators)
def load_all():
url = 'http://api.worldbank.org/indicators?format=json&per_page=' + \
str(per_page)
response = urllib.request.urlopen(url)
data = response.read().decode('utf-8')
data = json.loads(data)
for item in data[1]:
i = Indicator()
i.name = item['id']
i.description = item['name']
i.sourcenote = item['sourceNote']
i.datasource = item['sourceOrganization']
i.source = "worldbank"
Indicators.add(i)
FILE_PATH = 'input/{}'.format(name)
temp = name.split('-')
temp_str = temp[0] + temp[1]
model_name = temp_str.lower().split('.')[0]
BASELINE_MODEL_PATH = 'model/model-baseline-new/model-{}'.format(
model_name)
PSO_MODEL_PATH = 'model/model-pso-new/model-pso-{}'.format(model_name)
data = pd.read_csv(FILE_PATH)
ann = keras.models.load_model(BASELINE_MODEL_PATH)
pso = keras.models.load_model(PSO_MODEL_PATH)
# iteration
print('starting for {}'.format(name.split('.')[0]))
# create indicator
indicator = Indicator(data)
indicator_data = indicator.RSI()
indicator_data = indicator.EMA()
indicator_data = indicator.MACD()
indicator_data.dropna(inplace=True)
indicator_data['change_of_ema'] = (
(indicator_data['Close'] - indicator_data['ema_5_day']) /
indicator_data['ema_5_day']) * 100
data_set = indicator_data[[
'Close', 'rsi', 'Histogram', 'change_of_ema', 'change'
]]
simulator = Simulator(simulate_day=N_DAY,
simulate_data=data_set,
baseline_model=ann,
pso_model=pso)
def __init__(self):
Indicator.__init__(self)
self.set_params({'n':5},True)
from exchange.kraken import Kraken
from exchange.bitstamp import Bitstamp
from exchange.btce import BtcE
PROJECT_ROOT = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
if __name__ == "__main__":
signal.signal(signal.SIGINT, signal.SIG_DFL) # ctr+c exit
config = yaml.load(open(PROJECT_ROOT + '/config.yaml', 'r'))
config['project_root'] = PROJECT_ROOT
print("Starting Coin Price indicator v" + config['app']['version'])
# indicator applet
indicator = Indicator(config)
# exchanges
exchanges = [
{
'code': 'kraken',
'name': 'Kraken',
'instance': Kraken(config, indicator)
},
{
'code': 'bitstamp',
'name': 'Bitstamp',
'instance': Bitstamp(config, indicator)
},
{
'code': 'btce',