def delete_link(sender, link):
"""
Deletes a link and removes the topics (in and out) it represents from the corresponding nodes
:param sender: Not used
:param link: The id of the link item
:return: Nothing
"""
global links_dict
link_conf = dpg.get_item_configuration(link)
output_node = link_conf['user_data']['node_id_out']
input_node = link_conf['user_data']['node_id_in']
topic_out = link_conf['user_data']['topic_out']
topic_in = link_conf['user_data']['topic_in'].replace(' ', '_')
del links_dict[topic_out.split('-')[0]]
topic_out = topic_out.replace(' ', '_')
for n in nodes_list:
if output_node == n.id:
n.remove_topic_out(topic_out)
n.links_list.remove(link)
if input_node == n.id:
n.remove_topic_in(topic_in)
n.links_list.remove(link)
dpg.delete_item(link)
def on_end_graph(sender, data):
"""
Kill all running processes (except the one running the gui). Also shows a progress bar while waiting for processes
to die. They need a ct.HEARTBEAT_RATE * ct.HEARTBEATS_TO_DEATH seconds to die.
:param sender: Not used
:param data: Not used
:return: Nothing
"""
global forwarders
for n in nodes_list:
n.stop_com_process()
if platform.system() == 'Windows':
forwarders.send_signal(signal.CTRL_BREAK_EVENT)
elif platform.system() == 'Linux':
forwarders.terminate()
with dpg.window(label='Progress bar', pos=[500, 400], width=400, height=80) as progress_bar:
killing_proc_bar = dpg.add_progress_bar(label='Killing processes', parent=progress_bar, width=400, height=40,
overlay='Closing worker_exec processes')
t = 0
while t < ct.HEARTBEAT_RATE * ct.HEARTBEATS_TO_DEATH:
dpg.set_value(killing_proc_bar, t / (ct.HEARTBEAT_RATE * ct.HEARTBEATS_TO_DEATH))
t = t + 0.1
time.sleep(0.1)
dpg.delete_item(killing_proc_bar)
update_control_graph_buttons(False)
dpg.delete_item(progress_bar)
forwarders.kill()
del forwarders
def update():
global _text, _cell
dpg.delete_item(_text)
_text = dpg.add_text(
parent=_cell,
default_value=f"hiiiiiiii {np.random.randint(324214234)}")
def update_internal(self) -> bool:
# remove text
if self.text_id != 0:
dpg.delete_item(self.text_id)
self.text_id = 0
if self.dealer is None or self.symbols is None:
return True
if not self.dealer.good() or not self.symbols.good():
return True
self.current_prices = self.dealer.binance.symbol_ticker(
self.symbols.symbols)
# add plot if needed
if self.text_id == 0:
self.text_id = dpg.add_node_attribute(
parent=self.node_id, attribute_type=dpg.mvNode_Attr_Static)
for s in self.current_prices:
dpg.add_text(
s + ' R$ %.2f' % float(self.current_prices[s].current),
parent=self.text_id)
return True
def remove_from_editor(self):
dpg.remove_alias('verb#{}#{}'.format(self.operation.name,
self.node_index))
if dpg.does_alias_exist('relic#{}#{}'.format(self.operation.name,
self.node_index)):
dpg.remove_alias('relic#{}#{}'.format(self.operation.name,
self.node_index))
dpg.delete_item(self.id)
def update(self):
with dpg.mutex():
dpg.delete_item(self.left_panel, children_only=True)
self.data_set_container.submit(self.left_panel)
self.modifier_container.submit(self.left_panel)
dpg.delete_item(self.right_panel, children_only=True)
self.inspector_container.submit(self.right_panel)
self.tool_container.submit(self.right_panel)
def clear_editor():
"""
Clear the editor of all nodes and links
:return: Nothing
"""
global nodes_list
if dpg.get_item_children(node_editor, slot=1):
for n in dpg.get_item_children(node_editor, slot=1):
dpg.delete_item(n)
for a in dpg.get_aliases():
dpg.remove_alias(a)
nodes_list = []
def callback(sender):
dpg.delete_item(editor_id, children_only=True)
IncludeNode.count = 0
IncludeNode.level = 0
IncludeNode.levels = {0: 0}
if sender is not None:
selection = dpg.get_value(sender)
file = selection
else:
file = IncludeNode.root
inode = IncludeNode(file, 0)
inode.start_tree()
def add_rsi_series(iw, ws, dates, ta, parent):
values = ta.rsi(iw, ws)
dpg.add_line_series(dates, values, label='RSI', parent=parent)
dpg.add_button(label="Delete Series",
user_data=dpg.last_item(),
parent=dpg.last_item(),
callback=lambda s, a, u: dpg.delete_item(u))
def delete_selected_rows(self):
sel_rows = []
for row in range(self.num_of_rows):
if dpg.get_value(self.rows_ids[f"##{self.name}_{row}_{0}"]):
sel_rows.append(row)
for row in sel_rows:
id = dpg.get_value(self.rows_ids[f"##{self.name}_{row}_{1}"])
del self.ssh_info[id]
for row in sel_rows:
dpg.delete_item(self.rows_ids[f"##{self.name}_{row}_sep"])
for col in range(len(self.header)):
dpg.delete_item(self.rows_ids[f"##{self.name}_{row}_{col}"])
self.save_to_json()
def update_internal(self) -> bool:
if self.text_id:
dpg.delete_item(self.text_id)
self.text_id = 0
if self.a is None or self.b is None:
return True
if not self.a.good() or not self.b.good():
return True
def get_values(data):
values = {}
if type(data) is CurrentPriceNode:
for s in data.current_prices:
values[s] = float(data.current_prices[s].current)
elif type(data) is RollingMeanNode:
for s in data.data:
values[s] = float(data.data[s].to_list()[-1])
return values
a_values = get_values(self.a)
b_values = get_values(self.b)
self.data = {}
self.data_pct = {}
for a in a_values:
if a in b_values:
self.data[a] = b_values[a] - a_values[a]
self.data_pct[a] = b_values[a] / a_values[a]
if self.text_id == 0:
self.text_id = dpg.add_node_attribute(
parent=self.node_id, attribute_type=dpg.mvNode_Attr_Static)
for s in self.data:
dpg.add_text('a = %.2f' % a_values[s], parent=self.text_id)
dpg.add_text('b = %.2f' % b_values[s], parent=self.text_id)
dpg.add_text('b - a = %.2f' % self.data[s],
parent=self.text_id)
dpg.add_text('a -> b = %.2f%%' %
((self.data_pct[s] - 1) * 100),
parent=self.text_id)
break
return True
def update_internal(self) -> bool:
if self.data_id:
dpg.delete_item(self.data_id)
self.data_id = 0
if self.series is None or self.reference_prices is None:
return True
if not self.series.good() or not self.reference_prices.good():
return True
self.data['res'] = {}
self.data['sup'] = {}
for s in self.series.symbols.symbols:
self.data['res'][s] = self.series.prices[s][
'ta'].resistance_lines_for_price(
float(self.reference_prices.current_prices[s].current),
self.min_strength, self.threshold)
self.data['sup'][s] = self.series.prices[s][
'ta'].support_lines_for_price(
float(self.reference_prices.current_prices[s].current),
self.min_strength, self.threshold)
if self.data_id == 0:
self.data_id = dpg.add_node_attribute(
parent=self.node_id, attribute_type=dpg.mvNode_Attr_Static)
for s in self.data['res']:
dpg.add_text('%s %d res lines' % (s, len(self.data['res'][s])),
parent=self.data_id)
if len(self.data['res'][s]):
dpg.add_text(
'closest %.2f (%d)' %
(self.data['res'][s][0][0], self.data['res'][s][0][1]),
parent=self.data_id)
dpg.add_text('%s %d sup lines' % (s, len(self.data['sup'][s])),
parent=self.data_id)
if len(self.data['sup'][s]):
dpg.add_text(
'closest %.2f (%d)' %
(self.data['sup'][s][0][0], self.data['sup'][s][0][1]),
parent=self.data_id)
return True
def update_internal(self) -> bool:
# remove plot
if self.plot_id != 0:
dpg.delete_item(self.plot_id)
self.plot_id = 0
if self.dealer is None or self.symbols is None:
return True
start_date = datetime(year=2021, month=6, day=29)
end_date = datetime(year=2021, month=6, day=30)
if self.period == '1y':
start_date = end_date - timedelta(days=365)
elif self.period == '6m':
start_date = end_date - timedelta(days=182)
elif self.period == '1m':
start_date = end_date - timedelta(days=30)
elif self.period == '1w':
start_date = end_date - timedelta(days=7)
elif self.period == '1d':
start_date = end_date - timedelta(days=1)
if self.period == '1y' or self.period == '6m' or self.period == '1m':
if self.interval == '15m' or self.interval == '30m':
print('changing interval to 1h')
self.interval = '1h'
self.prices = self.dealer.binance.historical_candle_series(
self.symbols.symbols, start_date, end_date, self.interval)
# add plot if needed
if self.plot_id == 0:
data = self.prices[
self.symbols.symbols[0]]['ta'].data['close'].to_list()
self.plot_id = dpg.add_node_attribute(
parent=self.node_id, attribute_type=dpg.mvNode_Attr_Static)
dpg.add_simple_plot(label='',
default_value=data,
parent=dpg.last_item(),
width=110,
height=70)
return True
def show_history_messages(self, history: History):
dpg.delete_item(MESSAGE_GROUP, children_only=True)
width = dpg.get_item_width(MESSAGE_GROUP)
for message in history.messages:
if message.is_sent_by_me():
dpg.add_text(
message.as_string(),
parent=MESSAGE_GROUP,
indent=MESSAGE_INDENT,
wrap=width - MESSAGE_INDENT,
color=COLOR_MESSAGE_OTHERS,
)
else:
dpg.add_text(
message.as_string(),
parent=MESSAGE_GROUP,
indent=0,
wrap=width - MESSAGE_INDENT,
color=COLOR_MESSAGE_ME,
)
def __read_csv_cars__():
if dpg.does_alias_exist(TABLE_TAG):
dpg.delete_item(TABLE_TAG, children_only=False)
if dpg.does_alias_exist(TABLE_TAG):
dpg.remove_alias(TABLE_TAG)
with dpg.table(header_row=True, resizable=True, tag=TABLE_TAG, parent=MAIN_WINDOW_TAG):
with open(dpg.get_value(READ_FILENAME_FIELD)) as f:
csv_reader = csv.reader(f, delimiter=',')
# f'Table of {f.name}'
for num, row in enumerate(csv_reader):
if num == 0:
for column in row:
dpg.add_table_column(label=column, parent=TABLE_TAG)
else:
with dpg.table_row(parent=TABLE_TAG):
for column in row:
dpg.add_text(column)
if num % 100 == 0:
dpg.set_value(value=f'Loaded so far: {num:,}', item=LOADED_FIELD)
dpg.set_value(value=f'Loaded ALL', item=LOADED_FIELD)
def add_ema_series(n, dates, parent, ta):
ema_dates = dates[n - 1:]
ema_values = ta.ema(n).to_list()[n - 1:]
dpg.add_line_series(ema_dates,
ema_values,
label='EMA-' + str(n),
parent=parent)
dpg.add_button(label="Delete Series",
user_data=dpg.last_item(),
parent=dpg.last_item(),
callback=lambda s, a, u: dpg.delete_item(u))
def __init__(self, parent=None):
self.log_level = 0
self._auto_scroll = True
self.filter_id = None
if parent:
self.window_id = parent
else:
self.window_id = dpg.add_window(label="mvLogger",
pos=(10, 150),
width=800,
height=200)
self.count = 0
self.flush_count = 1000
with dpg.group(horizontal=True, parent=self.window_id):
dpg.add_checkbox(label="Auto-scroll",
default_value=True,
callback=lambda sender: self.auto_scroll(
dpg.get_value(sender)))
dpg.add_button(label="Clear",
callback=lambda: dpg.delete_item(
self.filter_id, children_only=True))
dpg.add_input_text(label="Filter",
callback=lambda sender: dpg.set_value(
self.filter_id, dpg.get_value(sender)),
parent=self.window_id)
self.child_id = dpg.add_child(parent=self.window_id,
autosize_x=True,
autosize_y=True)
self.filter_id = dpg.add_filter_set(parent=self.child_id)
with dpg.theme() as self.trace_theme:
dpg.add_theme_color(dpg.mvThemeCol_Text, (0, 255, 0, 255))
with dpg.theme() as self.debug_theme:
dpg.add_theme_color(dpg.mvThemeCol_Text, (64, 128, 255, 255))
with dpg.theme() as self.info_theme:
dpg.add_theme_color(dpg.mvThemeCol_Text, (255, 255, 255, 255))
with dpg.theme() as self.warning_theme:
dpg.add_theme_color(dpg.mvThemeCol_Text, (255, 255, 0, 255))
with dpg.theme() as self.error_theme:
dpg.add_theme_color(dpg.mvThemeCol_Text, (255, 0, 0, 255))
with dpg.theme() as self.critical_theme:
dpg.add_theme_color(dpg.mvThemeCol_Text, (255, 0, 0, 255))
def update_internal(self) -> bool:
# remove plot
if self.plot_id != 0:
dpg.delete_item(self.plot_id)
self.plot_id = 0
if self.series is None or not self.series.good():
return True
if len(self.series.prices) == 0:
return True
plot_symbol = ''
w = 0
for s in self.series.symbols.symbols:
plot_symbol = s
w = min([len(self.series.prices[s]['ta'].data), self.window_size])
if self.mean_type == 'SMA':
self.data[s] = self.series.prices[s]['ta'].sma(w)
elif self.mean_type == 'EMA':
self.data[s] = self.series.prices[s]['ta'].ema(w)
if w == 0 or len(plot_symbol) == 0:
return True
# add plot if needed
if self.plot_id == 0:
self.plot_id = dpg.add_node_attribute(
parent=self.node_id, attribute_type=dpg.mvNode_Attr_Static)
dpg.add_simple_plot(
label='',
default_value=self.data[plot_symbol].to_list()[w - 1:],
parent=dpg.last_item(),
width=110,
height=70)
return True
def delete_error_popup_aliases():
if dpg.does_alias_exist('modal_error_id'):
dpg.delete_item('modal_error_id')
if dpg.does_alias_exist("modal_id_credentials"):
dpg.delete_item("modal_id_credentials")
print('killed creds window')
if dpg.does_alias_exist("modal_id_folders_not_found"):
dpg.delete_item("modal_id_folders_not_found")
print('killed wrong folder window')
def _candle_plot_drop(sender, app_data, user_data):
global prices
global window_data
if window_data.selected_ticker == '':
return
ta = prices[window_data.selected_ticker]['ta']
dates = (ta.data['date'].astype('int64') // 1e9).to_list()
# indicator comes in app_data
logger.log('adding indicator ' + app_data[0])
if app_data[0] == 'RLINES':
current_price = float(exchange.symbol_ticker(window_data.selected_ticker)[window_data.selected_ticker].current)
threshold = dpg.get_value(app_data[1]) / 100
min_strength = dpg.get_value(app_data[2])
resistance_lines = ta.resistance_lines_for_price(current_price, min_strength, threshold)
resistance_levels = [v[0] for v in resistance_lines]
resistance_strengths = [v[1] for v in resistance_lines]
resistance_lines = ta.support_lines_for_price(current_price, min_strength, threshold)
resistance_levels += [v[0] for v in resistance_lines]
resistance_strengths += [v[1] for v in resistance_lines]
logger.log(str(resistance_levels))
hlid = dpg.add_hline_series(resistance_levels, label='RLINES', parent=window_data.candle_yaxis)
def delete_hl_series(s, a, u):
dpg.delete_item(u)
for an in window_data.rlines_annotation_ids[u]:
dpg.delete_item(an)
window_data.rlines_annotation_ids[u] = []
dpg.add_button(label="Delete", user_data=dpg.last_item(), parent=dpg.last_item(),
callback=delete_hl_series)
window_data.rlines_annotation_ids[hlid] = []
# add annotations
for ri in range(len(resistance_levels)):
dpg.add_plot_annotation(label=str(resistance_strengths[ri]),
default_value=(dates[-1], resistance_levels[ri]), offset=(10, 0),
clamped=False, parent=window_data.candle_plot)
window_data.rlines_annotation_ids[hlid].append(dpg.last_item())
elif app_data[0] == 'SMA':
indicators.add_sma_series(app_data[1], dates, window_data.candle_yaxis, ta)
elif app_data[0] == 'EMA':
indicators.add_ema_series(app_data[1], dates, window_data.candle_yaxis, ta)
elif app_data[0] == 'BOLLINGER_BANDS':
indicators.add_bbands_series(app_data[1], app_data[2], dates, ta, window_data.candle_yaxis)
dpg.add_button(label="Delete", user_data=dpg.last_item(), parent=dpg.last_item(),
callback=lambda s, a, u: dpg.delete_item(u))
def add_bbands_series(w, s, dates, ta, parent):
values = ta.bollinger_bands(w, s)
bbdates = dates[w - 1:]
upper_band = values[1].to_list()[w - 1:]
lower_band = values[2].to_list()[w - 1:]
with dpg.theme() as b_theme:
dpg.add_theme_color(dpg.mvPlotCol_Fill, (100, 100, 150, 64),
category=dpg.mvThemeCat_Plots)
dpg.add_shade_series(bbdates,
upper_band,
y2=lower_band,
label="BBANDS",
parent=parent)
dpg.set_item_theme(dpg.last_item(), b_theme)
dpg.add_button(label="Delete Series",
user_data=dpg.last_item(),
parent=dpg.last_item(),
callback=lambda s, a, u: dpg.delete_item(u))
def init(self, parent):
self.window_id = parent
with dpg.group(horizontal=True, parent=self.window_id):
dpg.add_checkbox(label="Auto-scroll",
default_value=True,
callback=lambda sender: self.auto_scroll(
dpg.get_value(sender)))
dpg.add_same_line()
dpg.add_button(label="Clear",
callback=lambda: dpg.delete_item(
self.filter_id, children_only=True))
dpg.add_same_line()
dpg.add_input_text(label="Filter",
callback=lambda sender: dpg.set_value(
self.filter_id, dpg.get_value(sender)))
self.child_id = dpg.add_child(parent=self.window_id,
autosize_x=True,
autosize_y=True)
self.filter_id = dpg.add_filter_set(parent=self.child_id)
def __init__(self):
self.log_level = 0
self._auto_scroll = True
self.filter_id = None
self.window_id = dpg.add_window(label="mvLogger", pos=(200, 200), width=500, height=500)
self.count = 0
self.flush_count = 1000
self.level_options = {"Trace": 0, "Debug": 1, "Info": 2, "Warning": 3, "Error": 4, "Critical": 5}
with dpg.group(horizontal=True, parent=self.window_id):
dpg.add_checkbox(label="Auto-scroll", default_value=True,
callback=lambda sender: self.auto_scroll(dpg.get_value(sender)))
dpg.add_button(label="Clear", callback=lambda: dpg.delete_item(self.filter_id, children_only=True))
dpg.add_input_text(label="Filter", callback=lambda sender: dpg.set_value(self.filter_id, dpg.get_value(sender)),
parent=self.window_id)
dpg.add_radio_button(list(self.level_options.keys()), parent=self.window_id,
callback=lambda sender: self.set_level(self.level_options[dpg.get_value(sender)]))
dpg.add_same_line(parent=self.window_id)
self.child_id = dpg.add_child(parent=self.window_id, autosize_x=True, autosize_y=True)
self.filter_id = dpg.add_filter_set(parent=self.child_id)
with dpg.theme() as self.trace_theme:
dpg.add_theme_color(dpg.mvThemeCol_Text, (0, 255, 0, 255))
with dpg.theme() as self.debug_theme:
dpg.add_theme_color(dpg.mvThemeCol_Text, (64, 128, 255, 255))
with dpg.theme() as self.info_theme:
dpg.add_theme_color(dpg.mvThemeCol_Text, (255, 255, 255, 255))
with dpg.theme() as self.warning_theme:
dpg.add_theme_color(dpg.mvThemeCol_Text, (255, 255, 0, 255))
with dpg.theme() as self.error_theme:
dpg.add_theme_color(dpg.mvThemeCol_Text, (255, 0, 0, 255))
with dpg.theme() as self.critical_theme:
dpg.add_theme_color(dpg.mvThemeCol_Text, (255, 0, 0, 255))
def start(self):
dpg.setup_registries()
dpg.setup_viewport()
dpg.set_viewport_title("Simple Data Flow")
node_editor = NodeEditor()
with dpg.window() as main_window:
with dpg.menu_bar():
with dpg.menu(label="Operations"):
dpg.add_menu_item(label="Reset", callback=lambda: dpg.delete_item(node_editor.uuid, children_only=True))
with dpg.menu(label="Plugins"):
for plugin in self.plugins:
dpg.add_menu_item(label=plugin[0], callback=plugin[1])
with dpg.group(horizontal=True) as group:
# left panel
with dpg.group(id=self.left_panel):
self.data_set_container.submit(self.left_panel)
self.modifier_container.submit(self.left_panel)
# center panel
node_editor.submit(group)
# right panel
with dpg.group(id=self.right_panel):
self.inspector_container.submit(self.right_panel)
self.tool_container.submit(self.right_panel)
dpg.set_primary_window(main_window, True)
dpg.start_dearpygui()
def configure_pygui(renderer, widgets, update=True):
if not dearpygui_imported:
raise RuntimeError(
"Attempted to use DearPyGUI when it isn't imported.")
if update:
dpg.delete_item(window)
else:
dpg.setup_viewport()
dpg.set_viewport_title(title=f"Manim Community v{__version__}")
dpg.set_viewport_width(1015)
dpg.set_viewport_height(540)
def rerun_callback(sender, data):
renderer.scene.queue.put(("rerun_gui", [], {}))
def continue_callback(sender, data):
renderer.scene.queue.put(("exit_gui", [], {}))
def scene_selection_callback(sender, data):
config["scene_names"] = (dpg.get_value(sender), )
renderer.scene.queue.put(("rerun_gui", [], {}))
scene_classes = scene_classes_from_file(Path(config["input_file"]),
full_list=True)
scene_names = [scene_class.__name__ for scene_class in scene_classes]
with dpg.window(
id=window,
label="Manim GUI",
pos=[config["gui_location"][0], config["gui_location"][1]],
width=1000,
height=500,
):
dpg.set_global_font_scale(2)
dpg.add_button(label="Rerun", callback=rerun_callback)
dpg.add_button(label="Continue", callback=continue_callback)
dpg.add_combo(
label="Selected scene",
items=scene_names,
callback=scene_selection_callback,
default_value=config["scene_names"][0],
)
dpg.add_separator()
if len(widgets) != 0:
with dpg.collapsing_header(
label=f"{config['scene_names'][0]} widgets",
default_open=True):
for widget_config in widgets:
widget_config_copy = widget_config.copy()
name = widget_config_copy["name"]
widget = widget_config_copy["widget"]
if widget != "separator":
del widget_config_copy["name"]
del widget_config_copy["widget"]
getattr(dpg, f"add_{widget}")(name,
**widget_config_copy)
else:
dpg.add_separator()
if not update:
dpg.start_dearpygui()
def _ticker_drop(sender, app_data, user_data):
global window_data
global prices
# update data
window_data.selected_ticker = app_data
if app_data == '':
return
dpg.set_value(window_data.main_window_title, 'Ticker: ' + window_data.selected_ticker)
# clean plots
for i in dpg.get_item_children(window_data.candle_yaxis)[1]:
dpg.delete_item(i)
if window_data.volume_unit_yaxis != 0:
dpg.delete_item(window_data.volume_unit_yaxis)
for i in dpg.get_item_children(window_data.volume_yaxis)[1]:
dpg.delete_item(i)
# load data
start_date = datetime(year=2021, month=6, day=29)
end_date = datetime(year=2021, month=6, day=30)
end_date = datetime.now()
start_date = end_date - timedelta(days=7)
if window_data.period == '1y':
start_date = end_date - timedelta(days=365)
elif window_data.period == '6m':
start_date = end_date - timedelta(days=182)
elif window_data.period == '1m':
start_date = end_date - timedelta(days=30)
elif window_data.period == '1w':
start_date = end_date - timedelta(days=7)
elif window_data.period == '1d':
start_date = end_date - timedelta(days=1)
# current price
window_data.current_price = float(
exchange.symbol_ticker(window_data.selected_ticker)[window_data.selected_ticker].current)
# candle history
prices = exchange.historical_candle_series([window_data.selected_ticker], start_date, end_date,
window_data.interval)
# compute ticker data
new_dates = (prices[window_data.selected_ticker]['ta'].data['date'].astype('int64') // 1e9).to_list()
new_closes = prices[window_data.selected_ticker]['ta'].data['close'].to_list()
new_lows = prices[window_data.selected_ticker]['ta'].data['low'].to_list()
new_highs = prices[window_data.selected_ticker]['ta'].data['high'].to_list()
new_opens = prices[window_data.selected_ticker]['ta'].data['open'].to_list()
# create candle stick graph
dpg.add_candle_series(new_dates, new_opens, new_closes, new_lows, new_highs,
label=app_data,
parent=window_data.candle_yaxis)
dpg.add_hline_series([window_data.current_price], label='cur price', parent=window_data.candle_yaxis)
# add indicators
indicators.add_sma_series(3, new_dates, window_data.candle_yaxis,
prices[window_data.selected_ticker]['ta'])
indicators.add_sma_series(7, new_dates, window_data.candle_yaxis,
prices[window_data.selected_ticker]['ta'])
indicators.add_sma_series(14, new_dates, window_data.candle_yaxis,
prices[window_data.selected_ticker]['ta'])
# create volume graph
values = prices[window_data.selected_ticker]['ta'].data['volume'].to_list()
dpg.add_bar_series(new_dates, values, parent=window_data.volume_yaxis, weight=500)
# fit plot views
dpg.fit_axis_data(window_data.candle_xaxis)
dpg.fit_axis_data(window_data.candle_yaxis)
dpg.fit_axis_data(window_data.volume_yaxis)
dpg.fit_axis_data(window_data.volume_xaxis)
def _delink_node(sender, app_data, user_data):
nodes.disconnect(dpg.get_item_user_data(app_data)[0], dpg.get_item_user_data(app_data)[1])
dpg.delete_item(app_data)
def delete_hl_series(s, a, u):
dpg.delete_item(u)
for an in window_data.rlines_annotation_ids[u]:
dpg.delete_item(an)
window_data.rlines_annotation_ids[u] = []
def clear_log(self):
dpg.delete_item(self.filter_id, children_only=True)
self.count = 0
def on_close():
global ssh_table
ssh_table.save_to_json()
dpg.delete_item(ssh_table.id)
