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 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 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 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 _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 _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 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 __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 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 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 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 _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 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)
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)
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 roll_test(self, ):
self.set_directory(self.start_time, self.end_time, self.strategy_name)
[
self.price_focused_list, self.volume_focused,
self.instrument_focused, self.datetime_focused
] = self.get_focused_info()
results_single_return_bp = np.zeros(
(len(self.window_period_list), len(self.std_num_list)))
results_return2dd = np.zeros(
(len(self.window_period_list), len(self.std_num_list)))
results_turnover = np.zeros(
(len(self.window_period_list), len(self.std_num_list)))
for i in range(len(self.window_period_list)):
for j in range(len(self.std_num_list)):
self.window_period = self.window_period_list[i]
self.std_num = self.std_num_list[j]
position_signal_focused = self.generate_position_signal()
if hasattr(self, 'loss_threshold'):
position_signal_focused = self.stop_loss_win(
position_signal_focused)
self.position_signal_array = self.map_signal_focused_to_array(
position_signal_focused)
self.position_signal_array_list.append(
self.position_signal_array)
indi_obj = Indicator(self, self.position_signal_array)
self.buysell_signal_array = indi_obj.get_buysell_signal()
# self.compound_return_array = indi_obj.get_compound_return()
self.single_return_array = indi_obj.get_single_return()
self.buysell_info = self.get_buysell_info()
seq = [
self.coinType1 + '-' + self.coinType2,
self.two_contract[0], self.two_contract[1],
self.strategy_name,
str(self.window_period),
str(self.std_num)
]
self.write_buysell_info_to_file(self.buysell_dir, seq,
self.buysell_info)
seq.append('day-return')
ret_unitTime_list, endtime_list = indi_obj.get_return_for_unitTime(
)
ret_unit_df = pd.DataFrame({
'endtime': endtime_list,
'return': ret_unitTime_list
})
self.write_buysell_info_to_file(self.buysell_dir, seq,
ret_unit_df)
del seq[-1]
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()
results_return2dd[i][j] = ret2dd
results_turnover[i][j] = mean_tvr
results_single_return_bp[i][j] = mg_bp
indi_list = [
self.coinType1 + '-' + self.coinType2, 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
]
self.indi_list_list.append(indi_list)
seq = [
self.coinType1 + '-' + self.coinType2, self.two_contract[0],
self.two_contract[1], self.strategy_name
]
results_list = [
results_single_return_bp, results_return2dd, results_turnover
]
self.results_tag_list = ['mg-bp', 'ret2dd', 'turnover']
self.get_average_result_list(self.results_tag_list)
for i in range(len(results_list)):
# record the data results for each coin type, it's used for calculating the average results
self.average_result_list[i].append(results_list[i])
seq.append(self.results_tag_list[i])
self.write_result_to_file(self.result_dir, seq, results_list[i],
self.window_period_list,
self.std_num_list)
del seq[-1]
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", "", 1)
self.connected = Indicator(self.root, "Connected", "True", 1)
self.contract = Indicator(self.root, "Contract", "", 1)
self.shares = Indicator(self.root, "Shares", "", 1)
self.label3 = Indicator(self.root, "15 Minutes ", "", 1)
self.crossover = Indicator(self.root, "Crossover", "False", 1)
self.spread = Indicator(self.root, "Spread", "", 1)
self.cci15 = Indicator(self.root, "CCI ", "", 1)
self.cci15_av = Indicator(self.root, "CCI Avg ", "", 1)
self.atr15 = Indicator(self.root, "ATR ", "", 1)
#self.bband15_width = Indicator(self.root, "BBAND Width", "",1)
#self.bband15_b = Indicator(self.root, "BBAND %B ", "",1)
self.label1 = Indicator(self.root, " ", "", 1)
self.cci15p = Indicator(self.root, "CCI ", "", 1)
self.cci15p_av = Indicator(self.root, "CCIP Avg", "", 1)
self.label2 = Indicator(self.root, "1 Hour ", "", 1)
self.cci1h = Indicator(self.root, "CCI ", "", 2)
self.cci1h_av = Indicator(self.root, "CCI Avg ", "", 2)
self.atr1h = Indicator(self.root, "ATR ", "", 2)
#self.bband1h_width = Indicator(self.root, "BBand Width ","",2)
#self.bband1h_b = Indicator(self.root, "BBand %p ","",2)
self.label1 = Indicator(self.root, "1 Day ", "", 1)
self.cci1d = Indicator(self.root, "CCI ", "", 3)
self.cci1d_av = Indicator(self.root, "CCI Avg ", "", 3)
self.atr1d = Indicator(self.root, "ATR ", "", 3)
#self.bband1d_width = Indicator(self.root, "BBand Width ","",3)
#self.bband1d_b = Indicator(self.root, "BBand %p ","",3)
self.status1 = Indicator(self.root, "Status1 ", "", 0)
self.ib.disconnectedEvent += self.disconnectEvent
self.ib.connectedEvent += self.connectEvent
self.ib.orderStatusEvent += self.orderStatusEvent
self.ib.newOrderEvent += self.newOrderEvent
self.ib.execDetailsEvent += self.execDetailsEvent
self.ib.errorEvent += self.onError
self.ib.newOrderEvent += self.newOrderEvent
def main():
xf_indicator = Indicator()
Gtk.main()
import pygame
from globals import *
from cell import Cell
from indicator import Indicator
# SETUP
pygame.init()
pygame.display.set_caption(WINDOW_LABEL)
screen = pygame.display.set_mode(WINDOW_DIMENSIONS)
running = True
indicator = Indicator(screen)
# GENERATE ALL CELLS
cells = []
for i in range((WINDOW_DIMENSIONS[1]-CELL_SIZE)//CELL_SIZE):
row = []
for j in range(WINDOW_DIMENSIONS[0]//CELL_SIZE):
row.append(Cell(screen, j*CELL_SIZE, i*CELL_SIZE+INDICATOR_WIDTH))
cells.append(row)
# DEFAULT PLAYER (True = red, False = yellow)
red = True
# INPUT LOGIC
def quitGame():
return event.type == pygame.QUIT or event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
def mouseMotion():
return event.type == pygame.MOUSEMOTION
def mouseClick():
def _create_reg(self, ind_list, name, width, color):
# Create a widget to hold the register's bits
reg_widget = QWidget(self)
reg_layout = QVBoxLayout(reg_widget)
reg_widget.setLayout(reg_layout)
reg_layout.setSpacing(0)
reg_layout.setMargin(0)
# Create a widget to hold the register's label and value textbox
label_value = QWidget(reg_widget)
lv_layout = QHBoxLayout(label_value)
label_value.setLayout(lv_layout)
lv_layout.setSpacing(1)
lv_layout.setMargin(0)
reg_layout.addWidget(label_value)
# Create a label to show the register's name
reg_label = QLabel(name, label_value)
reg_label.setAlignment(Qt.AlignCenter)
font = reg_label.font()
font.setPointSize(8)
reg_label.setFont(font)
lv_layout.addWidget(reg_label)
# Create a textbox to show the register's value in octal
n_digits = int((width + 2) / 3)
if n_digits == 1:
value_width = 25
elif n_digits == 2:
value_width = 30
else:
value_width = 45
reg_value = QLineEdit(label_value)
reg_value.setReadOnly(True)
reg_value.setMaximumSize(value_width, 32)
reg_value.setText(n_digits * '0')
font = QFont('Monospace')
font.setStyleHint(QFont.TypeWriter)
font.setPointSize(10)
reg_value.setFont(font)
reg_value.setAlignment(Qt.AlignCenter)
lv_layout.addWidget(reg_value)
# Create a frame to hold the register's bits
bit_frame = QFrame(reg_widget)
bit_layout = QHBoxLayout(bit_frame)
bit_layout.setSpacing(1)
bit_layout.setMargin(0)
bit_frame.setLayout(bit_layout)
bit_frame.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
# Add indicators for each bit in the register, from MSB to LSB
for i in range(width, 0, -1):
ind = Indicator(bit_frame, color)
ind.setFixedSize(20, 32)
bit_layout.addWidget(ind)
ind_list.insert(0, ind)
# Add separators between each group of 3 bits
if (i > 1) and ((i % 3) == 1):
sep = QFrame(bit_frame)
sep.setFrameStyle(QFrame.VLine | QFrame.Raised)
bit_layout.addWidget(sep)
reg_layout.addWidget(bit_frame)
return reg_widget, reg_value
def _setup_ui(self, name, color):
# Set up the overall horizontal layout
layout = QHBoxLayout(self)
self.setLayout(layout)
layout.setSpacing(3)
layout.setMargin(1)
# Construct a frame to hold the 16 indicators
bit_frame = QFrame(self)
bit_layout = QHBoxLayout(bit_frame)
bit_layout.setSpacing(1)
bit_layout.setMargin(0)
bit_frame.setLayout(bit_layout)
bit_frame.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
layout.addWidget(bit_frame)
# Add the 16 bit indicators to the frame, from 16 to 1.
for i in range(16, 0, -1):
ind = Indicator(bit_frame, color)
ind.setFixedSize(20, 32)
bit_layout.addWidget(ind)
self._indicators.insert(0, ind)
# Add separators between every group of 3 bits (except between
# bits 15 and 16).
if (i < 16) and (i > 1) and ((i % 3) == 1):
sep = QFrame(bit_frame)
sep.setFrameStyle(QFrame.VLine | QFrame.Raised)
bit_layout.addWidget(sep)
# Add sensed and generated parity bits, if this register has them
if self._has_parity:
sep = QFrame(bit_frame)
sep.setFrameStyle(QFrame.VLine | QFrame.Raised)
bit_layout.addWidget(sep)
for i in range(2, 0, -1):
ind = Indicator(bit_frame, QColor(220, 240, 0))
ind.setFixedSize(20, 32)
bit_layout.addWidget(ind)
self._parity_inds.insert(0, ind)
# Add a box to display the octal decoded value in
self._value_box = QLineEdit()
self._value_box.setMaximumSize(52, 32)
self._value_box.setReadOnly(True)
self._value_box.setAlignment(Qt.AlignCenter)
self._value_box.setText('00000')
font = QFont('Monospace')
font.setStyleHint(QFont.TypeWriter)
font.setPointSize(10)
self._value_box.setFont(font)
layout.addWidget(self._value_box)
# Add a label showing the name of the register
label = QLabel(name, self)
font = label.font()
font.setPointSize(14)
font.setBold(True)
label.setFont(font)
label.setMinimumWidth(20)
layout.addWidget(label)
# If parity was not included, fill up the equivalent space
if not self._has_parity:
layout.addSpacing(62)
else:
layout.addSpacing(17)
def add_indicator(self, settings=None):
indicator = Indicator(self, len(self.instances), self.config, settings)
self.instances.append(indicator)
nt = threading.Thread(target=indicator.start())
nt.start()
self.gui_ready.set()
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',
'name': 'BTC-E',
'instance': BtcE(config, indicator)
}]
def add_indicator(self, settings=None):
indicator = Indicator(self, len(self.instances), self.config, settings)
self.instances.append(indicator)
indicator.start()
self.gui_ready.set()
def __init__(self, ib: IB):
self.ib = ib
self.root = tk.Tk()
#new code
#ibc = IBC(twsVersion=972, gateway=True, tradingMode='paper')
#ib.connectedEvent += onConnected
#watchdog = Watchdog(ibc, ib, port=4002)
#watchdog.start()
#end new code
#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=100)
self.label4 = Indicator(self.root, "Positions","",1)
self.shares = Indicator(self.root, "Shares", "",1)
self.qtrhour = Indicator(self.root, "Time of Check","",1)
self.connected = Indicator(self.root, "Connected", "True",1)
self.contract = Indicator(self.root, "Contract", "",1)
self.label3 = Indicator(self.root, "15 Minutes ","",1)
self.crossover = Indicator(self.root, "Crossover", "False",1)
self.spread = Indicator(self.root, "CCI/CCIA Spread","",1)
self.cci15 = Indicator(self.root, "CCI ", "",1)
self.cci15_av = Indicator(self.root, "CCI Avg ", "",1)
self.atr15 = Indicator(self.root, "ATR ", "",1)
self.bband15_width = Indicator(self.root, "BBAND Width", "",1)
self.bband15_b = Indicator(self.root, "BBAND %B ", "",1)
self.label1 = Indicator(self.root, " ","",1)
self.cci15p = Indicator(self.root, "CCI ", "",1)
self.cci15p_av = Indicator(self.root, "CCIP Avg", "",1)
self.label2 = Indicator(self.root, "1 Hour ","",1)
self.cci1h = Indicator(self.root, "CCI ", "",2)
self.cci1h_av = Indicator(self.root, "CCI Avg ","",2)
self.atr1h = Indicator(self.root, "ATR ","",2)
self.bband1h_width = Indicator(self.root, "BBand Width ","",2)
self.bband1h_b = Indicator(self.root, "BBand %p ","",2)
self.label1 = Indicator(self.root, "1 Day ","",1)
self.cci1d = Indicator(self.root, "CCI ", "",3)
self.cci1d_av = Indicator(self.root, "CCI Avg ","",3)
self.atr1d = Indicator(self.root, "ATR ","",3)
self.bband1d_width = Indicator(self.root, "BBand Width ","",3)
self.bband1d_b = Indicator(self.root, "BBand %p ","",3)
self.status1 = Indicator(self.root, "Status1 ","",0)
self.ib.disconnectedEvent += self.disconnectEvent
self.ib.connectedEvent += self.connectEvent
self.ib.orderStatusEvent += self.orderStatusEvent
self.ib.newOrderEvent += self.newOrderEvent
self.ib.execDetailsEvent += self.execDetailsEvent
self.ib.errorEvent += self.onError
def _add_indicator(self, settings=None):
indicator = Indicator(self, settings)
self.instances.append(indicator)
indicator.start()
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)
from game import Game
from hero import Hero
from indicator import Indicator
# Графика
screen_height: int = 700 # Высота экрана в пикселях
screen_width: int = 1200 # Ширина экрана в пикселях
screen = pygame.display.set_mode((screen_width, screen_height), pygame.FULLSCREEN) # Объект экрана pygame
# Объекты
game = Game(screen) # Объект игры
hero = Hero(game, screen) # Объект героя
forest = Forest(hero, screen) # Объект леса
forest.setup()
satiety_percent: float = 100 * hero.satiety / hero.satiety_max # Сытость героя в [%]
indicator_satiety = Indicator('Сытость', screen, satiety_percent, 0, 0) # Объект индикатора сытости
while game.status != 'finished': # Пока игра не завершена
game.update_logic()
game.update_graphics()
forest.process()
hero.process()
satiety_percent: float = 100 * hero.satiety / hero.satiety_max # Сытость героя в [%]
indicator_satiety.value = satiety_percent # Значение индикатора сытости в [%]
indicator_satiety.process()