def entry(app, parent):
str_value = StringVar()
str_value.set(str(getattr(app.bot_config, name)))
frame = Frame(parent)
label = Label(frame, text=begin_text)
entry = Entry(frame, textvariable=str_value)
def creator(attr_name):
def validate_cmd(value, action_type):
if action_type == '1':
if not value.isdigit():
return False
if value[0] == '0':
return False
setattr(app.bot_config, attr_name, int(value if value != '' else '1'))
write_bot_config(app.bot_config, app.device.serial.replace(':', "_"))
return True
return validate_cmd
entry.config(width=10, validate='key', validatecommand=(
frame.register(creator(name)), '%P', '%d'
))
label.grid(row=0, column=0, sticky=N + W, padx=5)
entry.grid(row=0, column=1, sticky=N + W, padx=5)
if end_text is not None:
Label(frame, text=end_text).grid(row=0, column=2, sticky=N+W, padx=5)
return frame, None
def scenarioWin(self):
self.scenButton['state'] = 'disabled'
newWindow = Toplevel(self.master)
newWinOffset = f"+{self.master.winfo_rootx()}+{self.master.winfo_rooty()+self.master.winfo_height()}"
newWindow.geometry(newWinOffset)
newWindow.title("Scenario")
self.scenWin = newWindow
#Set the framework for the components
scenFrame = Frame(newWindow)
scenFrame.pack()
self.scenFrame = scenFrame
uniqStrike = list({tr["Strike"] for tr in self.tradeRecord if tr})
#self.uniqStrike = uniqStrike
titleLabel = Label(scenFrame, text="Changes in")
titleLabel.grid(row=0, column=1, columnspan=3)
calcButton = Button(scenFrame,
text="Calculate",
command=self.scenarioCalculation)
calcButton.grid(row=self.NScenario + 3, column=len(uniqStrike) + 3)
########################################
self.scenInputHeading = self.ScenInputField.copy()
for i in range(len(uniqStrike)):
self.scenInputHeading.append(f"k={uniqStrike[i]:.2f}")
ivLable = Label(scenFrame, text="ImplVol For strike=")
ivLable.grid(row=0, column=4, columnspan=len(uniqStrike))
for i, s in enumerate(self.scenInputHeading):
l = Label(scenFrame, text=s)
l.grid(row=1, column=i + 1)
for i in range(self.NScenario):
l = Label(scenFrame, text=str(i + 1))
l.grid(row=i + 2, column=0)
self.scenarioEntry = [[] for i in range(self.NScenario)]
vcmdFloat = scenFrame.register(self.validateFloat)
for j in range(self.NScenario):
for i in range(3 + len(uniqStrike)):
self.scenarioEntry[j].append(
Entry(scenFrame,
validate="key",
validatecommand=(vcmdFloat, '%P')))
self.scenarioEntry[j][i].grid(row=j + 2,
column=i + 1,
sticky=W + E)
def resource_ratio(app, parent):
label_texts = ['Food:', 'Wood:', 'Stone:', 'Gold:']
attr_names = [
'gatherResourceRatioFood', 'gatherResourceRatioWood',
'gatherResourceRatioStone', 'gatherResourceRatioGold'
]
frame = Frame(parent)
label_1 = Label(frame, text='Type:')
label_2 = Label(frame, text='Ratio:')
label_1.grid(row=0, column=0, sticky=N + W, padx=(0, 5))
label_2.grid(row=1, column=0, sticky=N + W, padx=(0, 5))
for col in range(4):
str_value = StringVar()
str_value.set(str(getattr(app.bot_config, attr_names[col])))
label = Label(frame, text=label_texts[col])
entry = Entry(frame, textvariable=str_value)
def creator(attr_name):
def validate_cmd(value, action_type):
if action_type == '1':
if not value.isdigit():
return False
if len(value) > 1 and value[0] == '0':
return False
setattr(app.bot_config, attr_name,
int(value if value != '' else '0'))
write_bot_config(app.bot_config,
app.device.serial.replace(':', "_"))
return True
return validate_cmd
entry.config(validate='key',
validatecommand=(frame.register(creator(attr_names[col])),
'%P', '%d'))
label.grid(row=0, column=col + 1, sticky=N + W, padx=5)
entry.grid(row=1, column=col + 1, sticky=N + W, padx=5)
entry.config(width=10)
return frame, None
def widget_minute_seconds(parent: tk.Frame, var: tk.StringVar,
conf: Property) -> tk.Widget:
"""A widget for specifying times - minutes and seconds.
The value is saved as seconds.
Max specifies the largest amount.
"""
max_value = conf.int('max', 60)
min_value = conf.int('min', 0)
if min_value > max_value:
raise ValueError('Bad min and max values!')
values = timer_values(min_value, max_value)
# Stores the 'pretty' value in the actual textbox.
disp_var = tk.StringVar()
existing_value = var.get()
def update_disp(var_name: str, var_index: str, operation: str) -> None:
"""Whenever the string changes, update the displayed text."""
seconds = conv_int(var.get(), -1)
if min_value <= seconds <= max_value:
disp_var.set('{}:{:02}'.format(seconds // 60, seconds % 60))
else:
LOGGER.warning('Bad timer value "{}" for "{}"!', var.get(),
conf['id'])
# Recurse, with a known safe value.
var.set(values[0])
# Whenever written to, call this.
var.trace_add('write', update_disp)
def set_var():
"""Set the variable to the current value."""
try:
minutes, seconds = disp_var.get().split(':')
var.set(str(int(minutes) * 60 + int(seconds)))
except (ValueError, TypeError):
pass
def validate(reason: str, operation_type: str, cur_value: str,
new_char: str, new_value: str):
"""Validate the values for the text.
This is called when the textbox is modified, to allow cancelling bad
inputs.
Reason is the reason this was fired: 'key', 'focusin', 'focusout', 'forced'.
operation_type is '1' for insert, '0' for delete', '-1' for programmatic changes.
cur_val is the value before the change occurs.
new_char is the added/removed text.
new_value is the value after the change, if accepted.
"""
if operation_type == '0' or reason == 'forced':
# Deleting or done by the program, allow that always.
return True
if operation_type == '1': # Inserted text.
# Disallow non number and colons
if new_char not in '0123456789:':
return False
# Only one colon.
if ':' in cur_value and new_char == ':':
return False
# Don't allow more values if it has more than 2 numbers after
# the colon - if there is one, and it's not in the last 3 characters.
if ':' in new_value and ':' not in new_value[-3:]:
return False
if reason == 'focusout':
# When leaving focus, apply range limits and set the var.
try:
str_min, str_sec = new_value.split(':')
seconds = int(str_min) * 60 + int(str_sec)
except (ValueError, TypeError):
seconds = min_value
else:
if seconds < min_value:
seconds = min_value
if seconds > max_value:
seconds = max_value
var.set(str(seconds)) # This then re-writes the textbox.
return True
validate_cmd = parent.register(validate)
spinbox = tk.Spinbox(
parent,
exportselection=False,
textvariable=disp_var,
command=set_var,
wrap=True,
values=values,
width=5,
validate='all',
# These define which of the possible values will be passed along.
# http://tcl.tk/man/tcl8.6/TkCmd/spinbox.htm#M26
validatecommand=(validate_cmd, '%V', '%d', '%s', '%S', '%P'),
)
# We need to set this after, it gets reset to the first one.
var.set(existing_value)
return spinbox
def widget_minute_seconds(parent: tk.Frame, var: tk.StringVar,
conf: Property) -> tk.Misc:
"""A widget for specifying times - minutes and seconds.
The value is saved as seconds.
Max specifies the largest amount.
"""
max_value = conf.int('max', 60)
min_value = conf.int('min', 0)
if min_value > max_value:
raise ValueError('Bad min and max values!')
values = timer_values(min_value, max_value)
default_value = conv_int(var.get(), -1)
if min_value <= default_value <= max_value:
default_text = values[default_value - min_value]
else:
LOGGER.warning('Bad timer value "{}" for "{}"!', var.get(), conf['id'])
default_text = '0:01'
var.set('1')
disp_var = tk.StringVar()
def set_var():
"""Set the variable to the current value."""
try:
minutes, seconds = disp_var.get().split(':')
var.set(int(minutes) * 60 + int(seconds))
except (ValueError, TypeError):
pass
def validate(reason: str, operation_type: str, cur_value: str,
new_char: str, new_value: str):
"""Validate the values for the text."""
if operation_type == '0' or reason == 'forced':
# Deleting or done by the program, allow that always.
return True
if operation_type == '1':
# Disallow non number and colons
if new_char not in '0123456789:':
return False
# Only one colon.
if ':' in cur_value and new_char == ':':
return False
# Don't allow more values if it has more than 2 numbers after
# the colon - if there is one, and it's not in the last 3 characters.
if ':' in new_value and ':' not in new_value[-3:]:
return False
if reason == 'focusout':
# When leaving focus, apply range limits and set the var.
try:
minutes, seconds = new_value.split(':')
seconds = int(minutes) * 60 + int(seconds)
except (ValueError, TypeError):
seconds = default_value
if seconds < min_value:
seconds = min_value
if seconds > max_value:
seconds = max_value
disp_var.set('{}:{:02}'.format(seconds // 60, seconds % 60))
var.set(seconds)
return True
validate_cmd = parent.register(validate)
spinbox = tk.Spinbox(
parent,
exportselection=False,
textvariable=disp_var,
command=set_var,
wrap=True,
values=values,
validate='all',
# %args substitute the values for the args to validate_cmd.
validatecommand=(validate_cmd, '%V', '%d', '%s', '%S', '%P'),
)
# We need to set this after, it gets reset to the first one.
disp_var.set(default_text)
return spinbox
class Gui():
"""Class for the GUI"""
def __init__(self):
self.window = Tk()
self.window.title('Ingest Failer')
self.window.geometry("250x30")
self.enter_sip_id()
@staticmethod
def is_num(value):
return value.isdigit() or value == ''
def confirm_stuck(self):
if self.sip.SubmissionInProgress:
confirm = box.askyesno(f'The SIP is appears stuck',
'Force timeout failure?')
if confirm:
if api_requests.post_callback(
self.sip.json_methods.get_CallBackURI(),
self.sip.json_methods.get_ExternalID(),
f"Forced timeout by {full_name}"):
box.showinfo('Unlocked',
f'{self.sip.title} is now able to be edited')
else:
box.showerror('Error', 'Unable to force time out failure')
if self.sip.status == 'Failed ingest':
# box.showerror('Error', f'This pSIP failed ingest\n\n{self.sip.json_methods.get_CallBackMessage()}')
title = 'Error'
message = "The pSIP has failed ingest.\n\nFix any errors and retry submission. Check details for possible clues!"
detail = f"{self.sip.json_methods.get_CallBackMessage()}"
TopErrorWindow(title, message, detail)
elif self.sip.status == 'Idle':
box.showwarning('Idle', 'This pSIP has not yet been completed.')
elif self.sip.status == 'Ingested':
box.showinfo('Ingested', 'This SIP has been sucessfully ingested')
def valid_sip_id(self, event):
self.response = api_requests.get_JSON(self.entry.get())
if self.response is None:
box.showerror('Error', 'That is not a valid SIP ID')
# self.entry.delete(0, 'end')
# confirm_SIP_ID()
else:
confirm = box.askyesno(f'Confirm SIP ID {self.entry.get()}',
f'{self.response["Title"]}')
if confirm:
self.sip = Sip(self.entry.get())
self.sip.title = self.response["Title"]
self.confirm_stuck()
self.entry.delete(0, 'end')
def enter_sip_id(self):
self.frame = Frame(self.window)
self.frame.pack(side=LEFT, padx=5)
num_check = self.frame.register(self.is_num)
self.entry = Entry(self.frame,
validate='key',
validatecommand=(num_check, '%P'))
self.entry.pack(side=LEFT)
btn = Button(self.frame,
text='Enter SIP ID',
command=self.valid_sip_id)
btn.pack(side=RIGHT, padx=5)
self.entry.bind("<Return>", self.valid_sip_id)
self.entry.focus()
class InitScreen:
def __init__(self, master):
self.funcs = {}
self.master = master
self.controller = InitScreenController(master)
self.master.title('parent')
self.master.geometry('640x480+200+150')
self.set_param_init()
self.frame.pack()
self.master.mainloop()
def set_param_init(self):
self.frame = Frame(width=400, height=300, bd=2)
self.frame.grid_bbox(2, 4 + default_fields_count)
self._buttons_init()
self.entrys = {}
_vcmd = self.frame.register(self._validate)
count = 0
for block_name, block in default_params.items():
Label(self.frame,
text=_convert(block_name),
background="#999",
justify=LEFT).grid(
row=count,
column=1
)
count += 1
for name, _default in block.items():
default, func = _default
Label(self.frame,
text=_convert(name),
justify=LEFT).grid(
row=count,
column=1
)
# self.entrys[_convert(name)] = ""
sv = StringVar(
value=default_params[block_name][name][0])
e = Entry(self.frame)
self.entrys[name] = sv
self.funcs[e] = func
e.config(validate='key',
vcmd=(_vcmd, "%P", "%W"),
textvariable=sv)
e.grid(row=count,
column=2)
count += 1
Label(self.frame,
text="Количество существ:",
justify=LEFT).grid(
row=count,
column=1
)
self.creature_count = \
Label(self.frame,
text='0',
justify=LEFT)
self.creature_count.grid(
row=count,
column=2
)
def _buttons_init(self):
self.load_button = Button(self.frame,
text='Загрузить',
command=self.load_button_press)
self.load_button.grid(row=4 + default_fields_count,
column=1)
self.start_button = Button(self.frame,
text='Старт',
command=self.start_button_press)
self.start_button.grid(row=4 + default_fields_count,
column=2)
self.master.protocol('WM_DELETE_WINDOW',
self.exit)
def _validate(self, P, W):
e = self.frame.nametowidget(W)
func = self.funcs[e]
try:
func(P)
except ValueError:
return False
else:
return True
def _collect_params(self):
params = deepcopy(default_params)
for block in params.values():
for key in block:
func = block[key][1]
block[key] = func(self.entrys[key].get())
return params
def start_button_press(self):
params = self._collect_params()
if self.controller.model:
self.game_screen = GameScreen(self.master, params, model=self.controller.model)
else:
self.game_screen = GameScreen(self.master, params)
self.frame.forget()
def load_button_press(self):
self.controller.load_button_press()
model = self.controller.model
self.creature_count.config(text=str(len(model.creatures)))
for block in model.params.values():
for k, v in block.items():
if k == "in_layers":
v = ", ".join([str(x) for x in v])
self.entrys[k].set(v)
def exit(self):
exit()
class SNMPManager:
def __init__(self, master=None):
# setup tab objects
self.master = master
self.navigation_tabs = ttk.Notebook(self.master)
self.setup = Frame(self.navigation_tabs)
self.setup.pack()
self.title_container = Frame(self.setup)
self.title = Label(self.title_container, text="SNMP Manager")
self.create_title()
self.agent_container = Frame(self.setup)
self.agent_label = Label(self.agent_container, text="Agent IP:", font=font, width=label_width)
self.agent = Entry(self.agent_container)
self.create_agent()
self.community_container = Frame(self.setup)
self.community_label = Label(self.community_container, text="Community:", font=font,
width=label_width)
self.community = Entry(self.community_container)
self.create_community()
self.object_container = Frame(self.setup)
self.object_label = Label(self.object_container, text="Object instance:", font=font, width=label_width)
self.object = Entry(self.object_container)
self.create_object()
self.time_container = Frame(self.setup)
self.time_label = Label(self.time_container, text="Refresh time (s):", font=font, width=label_width)
validation = self.time_container.register(only_numbers)
self.time = Entry(self.time_container, validate="key", validatecommand=(validation, '%S'))
self.create_charts = False
self.create_time()
self.buttons_container = Frame(self.setup)
self.get_object = Button(self.buttons_container, text="Get Object", font=font, width=button_width)
self.settings = Button(self.buttons_container, text="Settings", font=font, width=button_width)
self.start_monitor = Button(self.buttons_container, text="Start monitor", font=font, width=button_width)
self.stop_monitor = Button(self.buttons_container, text="Stop monitor", font=font, width=button_width)
self.create_setup_buttons()
# results frames
self.result_tabs = ttk.Notebook(self.setup)
self.response_label_frame = LabelFrame(self.result_tabs, font=font)
self.response_value = StringVar(self.response_label_frame)
self.response_text = Text(self.response_label_frame, font=font)
self.warning_label_frame = LabelFrame(self.result_tabs, font=font)
self.warning_value = StringVar(self.warning_label_frame)
self.warning_text = Text(self.warning_label_frame, font=font)
self.create_result()
# charts objects
self.link_chart = Frame(self.navigation_tabs)
self.ip_chart = Frame(self.navigation_tabs)
self.tcp_chart = Frame(self.navigation_tabs)
self.udp_chart = Frame(self.navigation_tabs)
self.icmp_chart = Frame(self.navigation_tabs)
self.snmp_chart = Frame(self.navigation_tabs)
self.create_charts_frames()
self.assemble_tabs()
# placeholders
self.threads = None
self.link = 0
self.input_octets = 0
self.output_octets = 0
self.link_list = []
self.ip_send = 0
self.ip_receive = 0
self.ip_send_list = []
self.ip_receive_list = []
self.tcp_send = 0
self.tcp_receive = 0
self.tcp_send_list = []
self.tcp_receive_list = []
self.udp_send = 0
self.udp_receive = 0
self.udp_send_list = []
self.udp_receive_list = []
self.icmp_send = 0
self.icmp_receive = 0
self.icmp_send_list = []
self.icmp_receive_list = []
self.snmp_send = 0
self.snmp_receive = 0
self.snmp_send_list = []
self.snmp_receive_list = []
def create_title(self):
self.title_container["pady"] = 10
self.title["font"] = title_font
self.title_container.pack()
self.title.pack()
def create_agent(self):
set_container_padding(self.agent_container)
set_entry_configuration(self.agent)
self.agent_container.pack()
self.agent_label.pack(side=LEFT)
self.agent.pack(side=LEFT)
def create_community(self):
set_container_padding(self.community_container)
set_entry_configuration(self.community)
self.community_container.pack()
self.community_label.pack(side=LEFT)
self.community.pack(side=LEFT)
def create_object(self):
set_container_padding(self.object_container)
set_entry_configuration(self.object)
self.object_container.pack()
self.object_label.pack(side=LEFT)
self.object.pack(side=LEFT)
def create_time(self):
set_container_padding(self.time_container)
set_entry_configuration(self.time)
self.time_container.pack()
self.time_label.pack(side=LEFT)
self.time.pack(side=LEFT)
def create_setup_buttons(self):
set_container_padding(self.buttons_container)
self.get_object["command"] = lambda: self.get_snmp_object()
self.start_monitor["command"] = lambda: self.start_charts_monitor()
self.stop_monitor["command"] = lambda: self.stop_charts_monitor()
self.settings["command"] = lambda: self.set_settings()
self.buttons_container.pack()
self.get_object.pack(side=LEFT)
self.start_monitor.pack(side=LEFT)
self.stop_monitor.pack(side=LEFT)
self.settings.pack(side=LEFT)
def create_result(self):
self.response_value.set("")
self.warning_value.set("")
self.response_label_frame.pack()
self.warning_label_frame.pack()
self.result_tabs.add(self.response_label_frame, text="Response")
self.result_tabs.add(self.warning_label_frame, text="Warning")
self.response_text.pack()
self.warning_text.pack()
self.result_tabs.pack()
def create_charts_frames(self):
self.link_chart.pack()
self.ip_chart.pack()
self.tcp_chart.pack()
self.udp_chart.pack()
self.icmp_chart.pack()
self.snmp_chart.pack()
def assemble_tabs(self):
self.navigation_tabs.add(self.setup, text="Setup")
self.navigation_tabs.add(self.link_chart, text="Link")
self.navigation_tabs.add(self.ip_chart, text="IP")
self.navigation_tabs.add(self.tcp_chart, text="TCP")
self.navigation_tabs.add(self.udp_chart, text="UDP")
self.navigation_tabs.add(self.icmp_chart, text="ICMP")
self.navigation_tabs.add(self.snmp_chart, text="SNMP")
self.navigation_tabs.pack()
def get_snmp_object(self):
parameters = self.extract_snmp_parameters()
snmp_response = snmp_api.run(parameters)
self.response_value.set(snmp_response)
self.update_return_value()
def extract_snmp_parameters(self):
parameters = {
"agent": self.agent.get(),
"community": self.community.get(),
"object": self.object.get()
}
return parameters
def clear_return_value(self):
self.response_text.delete("1.0", END)
def update_return_value(self):
self.clear_return_value()
self.response_text.insert(INSERT, self.response_value.get())
def start_charts_monitor(self):
self.create_charts = True
self.create_threads()
for thread in self.threads:
thread.daemon = True
thread.start()
def create_threads(self):
self.threads = [
Thread(target=self.create_link_chart),
Thread(target=self.create_ip_chart),
Thread(target=self.create_tcp_chart),
Thread(target=self.create_udp_chart),
Thread(target=self.create_icmp_chart),
Thread(target=self.create_snmp_chart)
]
def create_link_chart(self):
try:
refresh_time = self.get_refresh_time()
while self.create_charts:
self.clear_link_chart()
new_input_octets = self.get_input_octets()
new_output_octets = self.get_output_octets()
input_difference = new_input_octets - self.input_octets
output_difference = new_output_octets - self.output_octets
link_utilization = self.get_link_utilization(input_difference, output_difference)
if (self.link):
self.link_list.append(link_utilization)
self.verify_link_limits(link_utilization)
self.input_octets = new_input_octets
self.output_octets = new_output_octets
self.link = link_utilization
fig = Figure()
ax = fig.add_subplot()
ax.grid()
ax.plot(self.link_list)
ax.set_title("Link utilization")
graph = FigureCanvasTkAgg(fig, master=self.link_chart)
graph.get_tk_widget().pack()
time.sleep(refresh_time)
except Exception:
self.warning_value.set("Error creating link chart.\n")
self.update_warning_value()
def verify_link_limits(self, difference):
limits = dao.get_limits_from_link()[0]
inferior = limits[0]
superior = limits[1]
if difference < inferior or difference > superior:
self.warning_value.set("Link is out of defined limits.\n")
self.update_warning_value()
def get_link_utilization(self, input_octets, output_octets):
if_speed = self.get_if_speed()
return (input_octets + output_octets) * 8 / if_speed
def get_input_octets(self):
parameters = {
"agent": self.agent.get(),
"community": self.community.get(),
"object": "ifInOctets.2"
}
return int(snmp_api.run(parameters))
def get_output_octets(self):
parameters = {
"agent": self.agent.get(),
"community": self.community.get(),
"object": "ifOutOctets.2"
}
return int(snmp_api.run(parameters))
def get_if_speed(self):
parameters = {
"agent": self.agent.get(),
"community": self.community.get(),
"object": "ifSpeed.2"
}
return int(snmp_api.run(parameters))
def create_ip_chart(self):
try:
refresh_time = self.get_refresh_time()
while self.create_charts:
self.clear_ip_chart()
new_send = self.get_ip_send()
new_receive = self.get_ip_receive()
send_difference = new_send - self.ip_send
receive_difference = new_receive - self.ip_receive
if (self.ip_send or self.ip_receive):
self.ip_send_list.append(send_difference)
self.ip_receive_list.append(receive_difference)
self.verify_ip_limits(send_difference, receive_difference)
self.ip_send = new_send
self.ip_receive = new_receive
fig = Figure()
ax = fig.add_subplot()
ax.grid()
ax.set_ylabel("% of packets")
ax.set_title("IP send/receive")
ax.plot(self.ip_send_list, label="Send")
ax.plot(self.ip_receive_list, label="Receive")
ax.legend(loc=0)
graph = FigureCanvasTkAgg(fig, master=self.ip_chart)
graph.get_tk_widget().pack()
time.sleep(refresh_time)
except Exception:
self.warning_value.set("Error creating IP chart.\n")
self.update_warning_value()
def verify_ip_limits(self, send_difference, receive_difference):
limits = dao.get_limits_from_ip()[0]
inferior = limits[0]
superior = limits[1]
if send_difference < inferior or send_difference > superior or receive_difference < inferior or receive_difference > superior:
self.warning_value.set("IP is out of defined limits.\n")
self.update_warning_value()
def get_ip_send(self):
parameters = {
"agent": self.agent.get(),
"community": self.community.get(),
"object": "ipInDelivers.0"
}
return int(snmp_api.run(parameters))
def get_ip_receive(self):
parameters = {
"agent": self.agent.get(),
"community": self.community.get(),
"object": "ipOutRequests.0"
}
return int(snmp_api.run(parameters))
def create_tcp_chart(self):
try:
refresh_time = self.get_refresh_time()
while self.create_charts:
self.clear_tcp_chart()
new_send = self.get_tcp_send()
new_receive = self.get_tcp_receive()
send_difference = new_send - self.tcp_send
receive_difference = new_receive - self.tcp_receive
if (self.tcp_send or self.tcp_receive):
self.tcp_send_list.append(send_difference)
self.tcp_receive_list.append(receive_difference)
self.verify_tcp_limits(send_difference, receive_difference)
self.tcp_send = new_send
self.tcp_receive = new_receive
fig = Figure()
ax = fig.add_subplot()
ax.grid()
ax.set_ylabel("% of packets")
ax.set_title("TCP send/receive")
ax.plot(self.tcp_send_list, label="Send")
ax.plot(self.tcp_receive_list, label="Receive")
ax.legend(loc=0)
graph = FigureCanvasTkAgg(fig, master=self.tcp_chart)
graph.get_tk_widget().pack()
time.sleep(refresh_time)
except Exception:
self.warning_value.set("Error creating TCP chart.\n")
self.update_warning_value()
def verify_tcp_limits(self, send_difference, receive_difference):
limits = dao.get_limits_from_tcp()[0]
inferior = limits[0]
superior = limits[1]
if send_difference < inferior or send_difference > superior or receive_difference < inferior or receive_difference > superior:
self.warning_value.set("TCP is out of defined limits.\n")
self.update_warning_value()
def get_tcp_send(self):
parameters = {
"agent": self.agent.get(),
"community": self.community.get(),
"object": "tcpOutSegs.0"
}
return int(snmp_api.run(parameters))
def get_tcp_receive(self):
parameters = {
"agent": self.agent.get(),
"community": self.community.get(),
"object": "tcpInSegs.0"
}
return int(snmp_api.run(parameters))
def create_udp_chart(self):
try:
refresh_time = self.get_refresh_time()
while self.create_charts:
self.clear_udp_chart()
new_send = self.get_udp_send()
new_receive = self.get_udp_receive()
send_difference = new_send - self.udp_send
receive_difference = new_receive - self.udp_receive
if (self.udp_send or self.udp_receive):
self.udp_send_list.append(send_difference)
self.udp_receive_list.append(receive_difference)
self.verify_udp_limits(send_difference, receive_difference)
self.udp_send = new_send
self.udp_receive = new_receive
fig = Figure()
ax = fig.add_subplot()
ax.grid()
ax.set_ylabel("% of packets")
ax.set_title("UDP send/receive")
ax.plot(self.udp_send_list, label="Send")
ax.plot(self.udp_receive_list, label="Receive")
ax.legend(loc=0)
graph = FigureCanvasTkAgg(fig, master=self.udp_chart)
graph.get_tk_widget().pack()
time.sleep(refresh_time)
except Exception:
self.warning_value.set("Error creating UDP chart.\n")
self.update_warning_value()
def verify_udp_limits(self, send_difference, receive_difference):
limits = dao.get_limits_from_udp()[0]
inferior = limits[0]
superior = limits[1]
if send_difference < inferior or send_difference > superior or receive_difference < inferior or receive_difference > superior:
self.warning_value.set("UDP is out of defined limits.\n")
self.update_warning_value()
def get_udp_send(self):
parameters = {
"agent": self.agent.get(),
"community": self.community.get(),
"object": "udpOutDatagrams.0"
}
return int(snmp_api.run(parameters))
def get_udp_receive(self):
parameters = {
"agent": self.agent.get(),
"community": self.community.get(),
"object": "udpInDatagrams.0"
}
return int(snmp_api.run(parameters))
def create_icmp_chart(self):
try:
refresh_time = self.get_refresh_time()
while self.create_charts:
self.clear_icmp_chart()
new_send = self.get_icmp_send()
new_receive = self.get_icmp_receive()
send_difference = new_send - self.icmp_send
receive_difference = new_receive - self.icmp_receive
if (self.icmp_send or self.icmp_receive):
self.icmp_send_list.append(send_difference)
self.icmp_receive_list.append(receive_difference)
self.verify_icmp_limits(send_difference, receive_difference)
self.icmp_send = new_send
self.icmp_receive = new_receive
fig = Figure()
ax = fig.add_subplot()
ax.grid()
ax.set_ylabel("% of packets")
ax.set_title("ICMP send/receive")
ax.plot(self.icmp_send_list, label="Send")
ax.plot(self.icmp_receive_list, label="Receive")
ax.legend(loc=0)
graph = FigureCanvasTkAgg(fig, master=self.icmp_chart)
graph.get_tk_widget().pack()
time.sleep(refresh_time)
except Exception:
self.warning_value.set("Error creating ICMP chart.\n")
self.update_warning_value()
def verify_icmp_limits(self, send_difference, receive_difference):
limits = dao.get_limits_from_icmp()[0]
inferior = limits[0]
superior = limits[1]
if send_difference < inferior or send_difference > superior or receive_difference < inferior or receive_difference > superior:
self.warning_value.set("ICMP is out of defined limits.\n")
self.update_warning_value()
def get_icmp_send(self):
parameters = {
"agent": self.agent.get(),
"community": self.community.get(),
"object": "icmpOutMsgs.0"
}
return int(snmp_api.run(parameters))
def get_icmp_receive(self):
parameters = {
"agent": self.agent.get(),
"community": self.community.get(),
"object": "icmpInMsgs.0"
}
return int(snmp_api.run(parameters))
def create_snmp_chart(self):
try:
refresh_time = self.get_refresh_time()
while self.create_charts:
self.clear_snmp_chart()
new_send = self.get_snmp_send()
new_receive = self.get_snmp_receive()
send_difference = new_send - self.snmp_send
receive_difference = new_receive - self.snmp_receive
if (self.snmp_send or self.snmp_receive):
self.snmp_send_list.append(send_difference)
self.snmp_receive_list.append(receive_difference)
self.verify_snmp_limits(send_difference, receive_difference)
self.snmp_send = new_send
self.snmp_receive = new_receive
fig = Figure()
ax = fig.add_subplot()
ax.grid()
ax.set_ylabel("% of packets")
ax.set_title("SNMP send/receive")
ax.plot(self.snmp_send_list, label="Send")
ax.plot(self.snmp_receive_list, label="Receive")
ax.legend(loc=0)
graph = FigureCanvasTkAgg(fig, master=self.snmp_chart)
graph.get_tk_widget().pack()
time.sleep(refresh_time)
except Exception:
self.warning_value.set("Error creating SNMP chart.\n")
self.update_warning_value()
def verify_snmp_limits(self, send_difference, receive_difference):
limits = dao.get_limits_from_snmp()[0]
inferior = limits[0]
superior = limits[1]
if send_difference < inferior or send_difference > superior or receive_difference < inferior or receive_difference > superior:
self.warning_value.set("SNMP is out of defined limits.\n")
self.update_warning_value()
def get_snmp_send(self):
parameters = {
"agent": self.agent.get(),
"community": self.community.get(),
"object": "snmpOutPkts.0"
}
return int(snmp_api.run(parameters))
def get_snmp_receive(self):
parameters = {
"agent": self.agent.get(),
"community": self.community.get(),
"object": "snmpInPkts.0"
}
return int(snmp_api.run(parameters))
def clear_link_chart(self):
for child in self.link_chart.winfo_children():
child.destroy()
def clear_ip_chart(self):
for child in self.ip_chart.winfo_children():
child.destroy()
def clear_tcp_chart(self):
for child in self.tcp_chart.winfo_children():
child.destroy()
def clear_udp_chart(self):
for child in self.udp_chart.winfo_children():
child.destroy()
def clear_icmp_chart(self):
for child in self.icmp_chart.winfo_children():
child.destroy()
def clear_snmp_chart(self):
for child in self.snmp_chart.winfo_children():
child.destroy()
def get_refresh_time(self):
try:
refresh_time = int(self.time.get())
if refresh_time > 0:
self.clear_warning_value()
return refresh_time
except Exception:
self.warning_value.set("Refresh time must be higher than zero.\n")
self.update_warning_value()
return 0
def clear_warning_value(self):
self.warning_text.delete("1.0", END)
def update_warning_value(self):
self.warning_text.insert(INSERT, self.warning_value.get())
def stop_charts_monitor(self):
self.create_charts = False
def set_settings(self):
SNMPSettings(self.master)
def homescreen():
# upperframe - Conists of LabelFrame to display Connection details & Table selection option
upperframe = Frame(window, bg="#5CB040")
upperframe.place(rely=0.05, relx=0.015, relwidth=0.97, relheight=0.22)
selectbutton = Button(upperframe,
text="Select Database",
bg="#decccc",
font=("Verdana", 15),
command=lambda: selectDB(dataLabel),
bd=5,
relief="ridge")
selectbutton.place(rely=0.10, relx=0.25, relwidth=0.50, relheight=0.30)
dbEntry = Entry(upperframe, font=("Helvetica 15 "), bd=5, relief="ridge")
dbEntry.place(relx=0.10, rely=0.60, relwidth=0.40, relheight=0.25)
dbreg = upperframe.register(validateDBName)
dbEntry.config(validate="key", validatecommand=(dbreg, '%P'))
createbutton = Button(upperframe,
text="Create Database",
bg="#decccc",
font=("Verdana", 15),
command=lambda: createDB(dataLabel, dbEntry.get()),
bd=5,
relief="ridge")
createbutton.place(rely=0.60, relx=0.60, relwidth=0.32, relheight=0.25)
#combo Frame - Accomodates, table selection and creation place
comboframe = Frame(window, bg="#778472")
comboframe.place(rely=0.28, relx=0.015, relwidth=0.97, relheight=0.22)
classLabel = Label(comboframe,
text="Class",
font=("Arial", 12, "bold"),
bg="#778472")
classLabel.place(relx=0.13, rely=0.08, relwidth=0.14, relheight=0.15)
termLabel = Label(comboframe,
text="Term",
font=("Arial", 12, "bold"),
bg="#778472")
termLabel.place(relx=0.43, rely=0.08, relwidth=0.14, relheight=0.15)
yearLabel = Label(comboframe,
text="Year",
font=("Arial", 12, "bold"),
bg="#778472")
yearLabel.place(relx=0.73, rely=0.08, relwidth=0.14, relheight=0.15)
#Populating ComboList Dropdown values using Class/Term/Year options
classList = [6, 7, 8]
termList = [1, 2, 3]
currentyear = datetime.datetime.today().year
yearList = [currentyear + i for i in range(10)]
combofont = ("Courier", 15, "bold")
classCombo = ttk.Combobox(comboframe,
values=classList,
font=combofont,
state="readonly")
classCombo.current(0)
classCombo.place(relx=0.13, rely=0.26, relwidth=0.14, relheight=0.20)
termCombo = ttk.Combobox(comboframe,
values=termList,
font=combofont,
state="readonly")
termCombo.current(0)
termCombo.place(relx=0.43, rely=0.26, relwidth=0.14, relheight=0.20)
yearCombo = ttk.Combobox(comboframe,
values=yearList,
font=combofont,
state="readonly")
yearCombo.current(0)
yearCombo.place(relx=0.73, rely=0.26, relwidth=0.14, relheight=0.20)
tablebutton = Button(
comboframe,
text="Select Table",
bg="#decccc",
font=("Verdana", 15),
bd=5,
relief="ridge",
command=lambda: processtabledetails(classCombo.get(), termCombo.get(),
yearCombo.get(), dataLabel))
tablebutton.place(rely=0.65, relx=0.25, relwidth=0.50, relheight=0.25)
# Data frame which displays DB connection & Table details
global dbconn
global currdb
global currtable
dataframe = LabelFrame(window,
bg="#acdcdc",
text="DB & Table Details",
font=("Roboto", 12, "bold"))
dataframe.place(rely=0.51, relx=0.015, relwidth=0.97, relheight=0.11)
dataLabel = Label(dataframe,
text="Currently not connected to any Database",
bg="#acdcdc",
font=("Comic Sans MS", 13))
dataLabel.pack()
if dbconn:
if (currdb != None and currdb != "" and currtable != None
and currtable != ""):
dataLabel.configure(text="Connected to the Table " + currtable +
" \npresent in the Database " + currdb)
# Lower frame - Consists buttons to either Load/Update records and also Quit the application
lowerframe = Frame(window, bg="#4867EE")
lowerframe.place(rely=0.63, relx=0.015, relwidth=0.97, relheight=0.36)
loadbutton = Button(lowerframe,
text="Load Student Data",
bg="#decccc",
font=("Verdana", 15),
bd=5,
relief="raised",
command=lambda: callLoader(allframes))
loadbutton.place(relx=0.07, rely=0.20, relwidth=0.40, relheight=0.2)
updatebutton = Button(lowerframe,
text="Update Student Records",
bg="#decccc",
font=("Verdana", 15),
bd=5,
relief="raised",
command=lambda: callUpdater(allframes))
updatebutton.place(relx=0.53, rely=0.20, relwidth=0.40, relheight=0.2)
exportbutton = Button(lowerframe,
text="Export Table to CSV",
bg="#decccc",
font=("Verdana", 15),
bd=5,
relief="raised",
command=lambda: callExporter(allframes))
exportbutton.place(relx=0.07, rely=0.60, relwidth=0.40, relheight=0.2)
quitbutton = Button(lowerframe,
text="Quit",
bg="#decccc",
font=("Verdana", 15),
bd=5,
relief="raised",
command=quitapplication)
quitbutton.place(relx=0.53, rely=0.60, relwidth=0.40, relheight=0.2)
allframes = []
allframes.append(upperframe)
allframes.append(lowerframe)
allframes.append(comboframe)
allframes.append(dataframe)
def exporter():
global currtable
# topframe which provides the Export location folder defaulted to Exports folder
topframe = Frame(window, bg="#E5B25D")
topframe.place(rely=0.06, relx=0.015, relwidth=0.97, relheight=0.35)
chooseFolder = Button(topframe,
text="Choose Export Folder",
font=("Roboto", 15, "bold"),
fg="#16262E",
bg="#E952DE",
bd=5,
relief="raised",
command=lambda: chooseExportFolder(filedisplay))
chooseFolder.place(relx=0.26, rely=0.15, relwidth=0.50, relheight=0.20)
exportFileLabel = Label(topframe,
text="Export filename :",
font=("Roboto", 15, "bold"),
fg="#16262E",
bg="#E5B25D")
exportFileLabel.place(relx=0.10, rely=0.60, relwidth=0.35, relheight=0.18)
exportFileEntry = Entry(topframe,
font=("Roboto", 15),
bd=1,
relief="solid")
exportFileEntry.insert(0, currtable)
exportFileEntry.place(relx=0.50, rely=0.60, relwidth=0.40, relheight=0.18)
exportreg = topframe.register(validateExcelFileName)
exportFileEntry.config(validate="key", validatecommand=(exportreg, '%P'))
middleframe = LabelFrame(window,
fg="#F5F8DE",
bg="#391463",
text="Export Path",
font=("Roboto", 15, "bold"))
middleframe.place(rely=0.42, relx=0.015, relwidth=0.97, relheight=0.14)
filedisplay = Label(middleframe,
fg="#F5F8DE",
bg="#391463",
text="Export Folder defaulted to : " + EXPORTS +
"\n Export Excel Filename is defaulted to : " +
currtable,
font=("Comic Sans MS", 14))
filedisplay.pack(pady=10)
bottomframe = Frame(window, bg="#545E56")
bottomframe.place(rely=0.57, relx=0.015, relwidth=0.97, relheight=0.42)
loadDataButton = Button(
bottomframe,
text="Export Data to CSV File",
font=("Roboto", 15, "bold"),
fg="#16262E",
bg="#E952DE",
bd=5,
relief="raised",
command=lambda: exportData(filedisplay, exportFileEntry.get()))
loadDataButton.place(rely=0.20, relx=0.25, relheight=0.20, relwidth=0.50)
backButton = Button(bottomframe,
text="Back to Homepage",
font=("Roboto", 15, "bold"),
fg="#16262E",
bg="#E952DE",
bd=5,
relief="raised",
command=lambda: callHomescreen(allframes))
backButton.place(rely=0.55, relx=0.25, relheight=0.20, relwidth=0.50)
allframes = []
allframes.append(middleframe)
allframes.append(topframe)
allframes.append(bottomframe)
def updater():
# Upper portion which provides the Student search utility
topframe = Frame(window, bg="#80c1ff")
topframe.place(rely=0.05, relx=0.015, relwidth=0.97, relheight=0.23)
rollLabel = Label(topframe,
text="Enter Student's Roll number : ",
bg="#80c1ff",
font=("Roboto", 13, "bold"),
anchor='w')
rollLabel.place(relx=0.10, rely=0.12, relwidth=0.40, relheight=0.15)
rollEntry = Entry(topframe, font=("Calibri 15"))
rollEntry.place(relx=0.47, rely=0.12, relwidth=0.35, relheight=0.15)
rollreg = topframe.register(validateRoll)
rollEntry.config(validate="key", validatecommand=(rollreg, '%P'))
nameLabel = Label(topframe,
text="Enter Student's name : ",
bg="#80c1ff",
font=("Roboto", 13, "bold"),
anchor='w')
nameLabel.place(relx=0.10, rely=0.40, relwidth=0.30, relheight=0.15)
nameEntry = Entry(topframe, font=("Calibri 15"))
nameEntry.place(relx=0.47, rely=0.40, relwidth=0.35, relheight=0.15)
namereg = topframe.register(validateName)
nameEntry.config(validate="key", validatecommand=(namereg, '%P'))
searchButton = Button(
topframe,
text="Search",
font=("Roboto", 13, "bold"),
fg="White",
bg="#49306B",
bd=5,
relief="ridge",
command=lambda: searchStudent(rollEntry, nameEntry, dataLabel))
searchButton.place(relx=0.35, rely=0.72, relwidth=0.3, relheight=0.20)
# Middle frame which displays student record data
middleframe = LabelFrame(window,
bg="#acdcdc",
text="Student Data",
font=("Roboto", 12, "bold"))
middleframe.place(rely=0.29, relx=0.015, relwidth=0.97, relheight=0.12)
dataLabel = Label(middleframe,
text="No Student data to display currently",
bg="#acdcdc",
font=("Comic Sans MS", 13))
dataLabel.pack()
# Lower portion which enables the user to upload the scores
bottomframe = Frame(window, bg="#c4d763")
bottomframe.place(relx=0.015, rely=0.42, relwidth=0.97, relheight=0.57)
valreg = bottomframe.register(validateValues)
heightLabel = Label(bottomframe,
text="Enter Height :",
bg="#c4d763",
font=("Roboto", 13, "bold"),
anchor='w')
heightLabel.place(relx=0.10, rely=0.1, relwidth=0.35, relheight=0.07)
heightEntry = Entry(bottomframe, font=("Calibri 15"))
heightEntry.place(relx=0.47, rely=0.1, relwidth=0.35, relheight=0.07)
heightUnits = Label(bottomframe,
text="metres",
bg="#c4d763",
font=("Roboto", 11),
anchor='w')
heightUnits.place(relx=0.83, rely=0.11, relwidth=0.1, relheight=0.07)
heightEntry.config(validate="key", validatecommand=(valreg, '%P'))
speedLabel = Label(bottomframe,
text="Time taken for 50m race :",
bg="#c4d763",
font=("Roboto", 13, "bold"),
anchor='w')
speedLabel.place(relx=0.10, rely=0.2, relwidth=0.35, relheight=0.07)
speedEntry = Entry(bottomframe, font=("Calibri 15"))
speedEntry.place(relx=0.47, rely=0.2, relwidth=0.35, relheight=0.07)
speedUnits = Label(bottomframe,
text="seconds",
bg="#c4d763",
font=("Roboto", 11),
anchor='w')
speedUnits.place(relx=0.83, rely=0.21, relwidth=0.1, relheight=0.07)
speedEntry.config(validate="key", validatecommand=(valreg, '%P'))
enduranceLabel = Label(bottomframe,
text="Time taken for 800m race :",
bg="#c4d763",
font=("Roboto", 13, "bold"),
anchor='w')
enduranceLabel.place(relx=0.10, rely=0.3, relwidth=0.35, relheight=0.07)
enduranceEntry = Entry(bottomframe, font=("Calibri 15"))
enduranceEntry.place(relx=0.47, rely=0.3, relwidth=0.35, relheight=0.07)
enduranceUnits = Label(bottomframe,
text="minutes",
bg="#c4d763",
font=("Roboto", 11),
anchor='w')
enduranceUnits.place(relx=0.83, rely=0.31, relwidth=0.1, relheight=0.07)
enduranceEntry.config(validate="key", validatecommand=(valreg, '%P'))
strengthLabel = Label(bottomframe,
text="Shotput Distance Thrown :",
bg="#c4d763",
font=("Roboto", 13, "bold"),
anchor='w')
strengthLabel.place(relx=0.10, rely=0.4, relwidth=0.35, relheight=0.07)
strengthEntry = Entry(bottomframe, font=("Calibri 15"))
strengthEntry.place(relx=0.47, rely=0.4, relwidth=0.35, relheight=0.07)
strengthUnits = Label(bottomframe,
text="metres",
bg="#c4d763",
font=("Roboto", 11),
anchor='w')
strengthUnits.place(relx=0.83, rely=0.41, relwidth=0.1, relheight=0.07)
strengthEntry.config(validate="key", validatecommand=(valreg, '%P'))
explosiveLabel = Label(bottomframe,
text="LongJump Distance Jumped :",
bg="#c4d763",
font=("Roboto", 13, "bold"),
anchor='w')
explosiveLabel.place(relx=0.10, rely=0.5, relwidth=0.35, relheight=0.07)
explosiveEntry = Entry(bottomframe, font=("Calibri 15"))
explosiveEntry.place(relx=0.47, rely=0.5, relwidth=0.35, relheight=0.07)
explosiveUnits = Label(bottomframe,
text="metres",
bg="#c4d763",
font=("Roboto", 11),
anchor='w')
explosiveUnits.place(relx=0.83, rely=0.51, relwidth=0.1, relheight=0.07)
explosiveEntry.config(validate="key", validatecommand=(valreg, '%P'))
agilityLabel = Label(bottomframe,
text="Time taken for 6x10m race :",
bg="#c4d763",
font=("Roboto", 13, "bold"),
anchor='w')
agilityLabel.place(relx=0.10, rely=0.6, relwidth=0.35, relheight=0.07)
agilityEntry = Entry(bottomframe, font=("Calibri 15"))
agilityEntry.place(relx=0.47, rely=0.6, relwidth=0.35, relheight=0.07)
agilityUnits = Label(bottomframe,
text="seconds",
bg="#c4d763",
font=("Roboto", 11),
anchor='w')
agilityUnits.place(relx=0.83, rely=0.61, relwidth=0.1, relheight=0.07)
agilityEntry.config(validate="key", validatecommand=(valreg, '%P'))
submitButton = Button(
bottomframe,
text="Submit",
font=("Roboto", 13, "bold"),
fg="White",
bg="#49306B",
bd=5,
relief="ridge",
command=lambda: updateStudentData(
heightEntry, speedEntry, enduranceEntry, strengthEntry,
explosiveEntry, agilityEntry, dataLabel))
submitButton.place(relx=0.1, rely=0.82, relwidth=0.45, relheight=0.10)
backButton = Button(bottomframe,
text="Back to Homepage",
font=("Roboto", 13, "bold"),
fg="White",
bg="#49306B",
bd=5,
relief="ridge",
command=lambda: callHomescreen(allframes))
backButton.place(relx=0.65, rely=0.82, relwidth=0.25, relheight=0.10)
allframes = []
allframes.append(middleframe)
allframes.append(topframe)
allframes.append(bottomframe)
def __init__(self, *args, **kwargs):
BaseInputPage.__init__(self, "Course", *args, **kwargs)
left_frame = Frame(self.input_widgets_frame)
left_frame.pack(side="left", fill="x", expand=True)
self.name_var = StringVar(left_frame)
_, _, name_entry = BasePage.get_labeled_input_field(
left_frame,
"Course Name",
"Entry",
textvariable=self.name_var,
f_pady=5,
required=True)
self.input_widget_descriptors.append((name_entry, self.name_var, ""))
self.dept_code_var = StringVar(left_frame)
_, _, dept_code_entry = BasePage.get_labeled_input_field(
left_frame,
"Department Code",
"Entry",
textvariable=self.dept_code_var,
f_pady=5,
required=True)
self.input_widget_descriptors.append(
(dept_code_entry, self.dept_code_var, ""))
self.course_number_var = StringVar(left_frame)
_, _, course_number_entry = BasePage.get_labeled_input_field(
left_frame,
"Course Number",
"Entry",
textvariable=self.course_number_var,
f_pady=5,
validate="key",
validatecommand=(left_frame.register(self.ensure_int), "%S"),
required=True)
self.input_widget_descriptors.append(
(course_number_entry, self.course_number_var, ""))
self.num_credits_var = StringVar(left_frame)
_, _, num_credits_entry = BasePage.get_labeled_input_field(
left_frame,
"Credit Count",
"Entry",
textvariable=self.num_credits_var,
validate="key",
validatecommand=(left_frame.register(self.ensure_int), "%S"),
f_pady=5,
required=True)
self.input_widget_descriptors.append(
(num_credits_entry, self.num_credits_var, ""))
self.mins_per_week_var = StringVar(left_frame)
_, _, mins_per_week_entry = BasePage.get_labeled_input_field(
left_frame,
"Minutes/Week",
"Entry",
textvariable=self.mins_per_week_var,
validate="key",
validatecommand=(left_frame.register(self.ensure_int), "%S"),
f_pady=5,
required=True)
self.input_widget_descriptors.append(
(mins_per_week_entry, self.mins_per_week_var, ""))
self.num_sections_var = StringVar(left_frame)
_, _, num_sections_entry = BasePage.get_labeled_input_field(
left_frame,
"Section Count",
"Entry",
textvariable=self.num_sections_var,
validate="key",
validatecommand=(left_frame.register(self.ensure_int), "%S"),
f_pady=5,
required=True)
self.input_widget_descriptors.append(
(num_sections_entry, self.num_sections_var, ""))
self.room_type_options = {
t.pretty_print(): t.value
for t in ClassroomType
}
self.room_type_options_list = list(self.room_type_options.keys())
self.room_type_var = StringVar(left_frame)
_, _, room_type_menu = BasePage.get_labeled_input_field(
left_frame,
"Classroom Type",
"OptionMenu",
self.room_type_var,
*self.room_type_options_list,
f_pady=5,
required=True)
self.input_widget_descriptors.append(
(room_type_menu, self.room_type_var,
self.room_type_options_list[0]))
right_frame = Frame(self.input_widgets_frame)
right_frame.pack(side="right", fill="x", expand=True)
self.has_lab_var = IntVar(right_frame)
_, _, has_lab_checkbtn = BasePage.get_labeled_input_field(
right_frame,
"Has a Lab",
"Checkbutton",
variable=self.has_lab_var,
command=self.update_lab_widget_states,
f_pady=5,
required=True)
self.input_widget_descriptors.append(
(has_lab_checkbtn, self.has_lab_var, 0))
self.lab_num_credits_var = StringVar(right_frame)
_, _, self.lab_num_credits_entry = BasePage.get_labeled_input_field(
right_frame,
"Credit Count",
"Entry",
textvariable=self.lab_num_credits_var,
validate="key",
validatecommand=(right_frame.register(self.ensure_int), "%S"),
f_pady=5,
required=True)
self.input_widget_descriptors.append(
(self.lab_num_credits_entry, self.lab_num_credits_var, ""))
self.lab_mins_per_week_var = StringVar(right_frame)
_, _, self.lab_mins_per_week_entry = BasePage.get_labeled_input_field(
right_frame,
"Minutes/Week",
"Entry",
textvariable=self.lab_mins_per_week_var,
validate="key",
validatecommand=(right_frame.register(self.ensure_int), "%S"),
f_pady=5,
required=True)
self.input_widget_descriptors.append(
(self.lab_mins_per_week_entry, self.lab_mins_per_week_var, ""))
self.lab_num_sections_var = StringVar(right_frame)
_, _, self.lab_num_sections_entry = BasePage.get_labeled_input_field(
right_frame,
"Section Count",
"Entry",
textvariable=self.lab_num_sections_var,
validate="key",
validatecommand=(left_frame.register(self.ensure_int), "%S"),
f_pady=5,
required=True)
self.input_widget_descriptors.append(
(self.lab_num_sections_entry, self.lab_num_sections_var, ""))
self.lab_room_type_var = StringVar(right_frame)
_, _, self.lab_room_type_menu = BasePage.get_labeled_input_field(
right_frame,
"Classroom Type",
"OptionMenu",
self.lab_room_type_var,
*self.room_type_options_list,
f_pady=5,
required=True)
self.input_widget_descriptors.append(
(self.lab_room_type_menu, self.lab_room_type_var,
self.room_type_options_list[0]))
self.update_lab_widget_states()
def widget_minute_seconds(parent: tk.Frame, var: tk.StringVar, conf: Property) -> tk.Widget:
"""A widget for specifying times - minutes and seconds.
The value is saved as seconds.
Max specifies the largest amount.
"""
max_value = conf.int('max', 60)
min_value = conf.int('min', 0)
if min_value > max_value:
raise ValueError('Bad min and max values!')
values = timer_values(min_value, max_value)
# Stores the 'pretty' value in the actual textbox.
disp_var = tk.StringVar()
existing_value = var.get()
def update_disp(var_name: str, var_index: str, operation: str) -> None:
"""Whenever the string changes, update the displayed text."""
seconds = conv_int(var.get(), -1)
if min_value <= seconds <= max_value:
disp_var.set('{}:{:02}'.format(seconds // 60, seconds % 60))
else:
LOGGER.warning('Bad timer value "{}" for "{}"!', var.get(), conf['id'])
# Recurse, with a known safe value.
var.set(values[0])
# Whenever written to, call this.
var.trace_add('write', update_disp)
def set_var():
"""Set the variable to the current value."""
try:
minutes, seconds = disp_var.get().split(':')
var.set(str(int(minutes) * 60 + int(seconds)))
except (ValueError, TypeError):
pass
def validate(reason: str, operation_type: str, cur_value: str, new_char: str, new_value: str):
"""Validate the values for the text.
This is called when the textbox is modified, to allow cancelling bad
inputs.
Reason is the reason this was fired: 'key', 'focusin', 'focusout', 'forced'.
operation_type is '1' for insert, '0' for delete', '-1' for programmatic changes.
cur_val is the value before the change occurs.
new_char is the added/removed text.
new_value is the value after the change, if accepted.
"""
if operation_type == '0' or reason == 'forced':
# Deleting or done by the program, allow that always.
return True
if operation_type == '1': # Inserted text.
# Disallow non number and colons
if new_char not in '0123456789:':
return False
# Only one colon.
if ':' in cur_value and new_char == ':':
return False
# Don't allow more values if it has more than 2 numbers after
# the colon - if there is one, and it's not in the last 3 characters.
if ':' in new_value and ':' not in new_value[-3:]:
return False
if reason == 'focusout':
# When leaving focus, apply range limits and set the var.
try:
str_min, str_sec = new_value.split(':')
seconds = int(str_min) * 60 + int(str_sec)
except (ValueError, TypeError):
seconds = min_value
else:
if seconds < min_value:
seconds = min_value
if seconds > max_value:
seconds = max_value
var.set(str(seconds)) # This then re-writes the textbox.
return True
validate_cmd = parent.register(validate)
spinbox = tk.Spinbox(
parent,
exportselection=False,
textvariable=disp_var,
command=set_var,
wrap=True,
values=values,
width=5,
validate='all',
# These define which of the possible values will be passed along.
# http://tcl.tk/man/tcl8.6/TkCmd/spinbox.htm#M26
validatecommand=(validate_cmd, '%V', '%d', '%s', '%S', '%P'),
)
# We need to set this after, it gets reset to the first one.
var.set(existing_value)
return spinbox
class RulesInput():
"""
Class to manage gui and logic for entry fields of rules
in Parameters frame
"""
def __init__(self, parent_class):
"""
Initialize parent_frame to the provided class to hold self.frame
self.frame contains all the elements
self.entries is a list of dynamically generated entries
"""
self.parent_class = parent_class
# frame in parent Parameters class
self.frame = Frame(parent_class.frame)
self.preview_canvas = None # canvas to preview curve
self.entries = [] # list of dictionaries, each dictionary
# contains the keys for frame, and its children
self.add_button = None
self.sub_button = None
self.radio_angle_var = BooleanVar(
self.frame) # initially set to radians
self.radio_angle_var.set(True)
self.init_preview_canvas()
self.init_info_labels()
self.init_add_entry_button()
self.init_sub_entry_button()
# self.init_extract_rules_button()
self.frame.grid(row=7, column=0, columnspan=3, sticky='nw', pady=10)
def create_entry_dictionary(self):
"""
Creates and returns a dictionary which contains references
to a frame and entries in it
keys: ["frame", "ent_len", "ent_angle", "chk_is_flip",
"chk_is_rev", "flip_state","reverse_state"]
"""
vcmd = (self.frame.register(self.validate_float), '%P')
entry_frame = Frame(self.frame)
ent_length = Entry(entry_frame,
validate='key',
width=8,
validatecommand=vcmd)
ent_angle = Entry(entry_frame,
validate='key',
width=8,
validatecommand=vcmd)
is_reversed_state = BooleanVar(entry_frame)
is_flipped_state = BooleanVar(entry_frame)
chkbtn_is_reversed = Checkbutton(entry_frame,
text='reverse',
var=is_reversed_state)
chkbtn_is_flipped = Checkbutton(entry_frame,
text='flip',
var=is_flipped_state)
ent_angle.pack(side=LEFT)
ent_length.pack(side=LEFT)
chkbtn_is_flipped.pack(side=LEFT)
chkbtn_is_reversed.pack(side=LEFT)
entry_frame.grid(row=len(self.entries) + 3, columnspan=4)
entry_dict = {
"frame": entry_frame,
"ent_len": ent_length,
"ent_angle": ent_angle,
"chk_is_flip": chkbtn_is_flipped,
"chk_is_rev": chkbtn_is_reversed,
"flip_state": is_flipped_state,
"reverse_state": is_reversed_state
}
return entry_dict
def init_add_entry_button(self):
"""
Initialize the button which adds frames for entry of each rule
"""
def add_entry():
"""
create a new entry and add to self.entries
"""
new_entry = self.create_entry_dictionary()
self.entries.append(new_entry)
self.render_preview()
self.add_button = Button(self.frame, text='+', command=add_entry)
self.add_button.grid(row=1, column=2)
def init_sub_entry_button(self):
"""
Initialize the button to remove entry fields
"""
def sub_entry():
"""
Pop and destroy the last entry from self.entries
"""
if self.entries != []:
self.entries.pop()["frame"].destroy()
self.render_preview()
self.sub_button = Button(self.frame, text='-', command=sub_entry)
self.sub_button.grid(row=1, column=3)
def validate_float(self, p_str):
"""
Validate if input is a valid floating point number
"""
# may validate only '[+-].' which needs to be handled later
float_pattern = r"^[\+\-]?([0-9]*[.])?[0-9]*$"
if re.search(float_pattern, p_str) or p_str == "":
return True
return False
def extract_rules(self):
"""
Extract rules from the input fields to a list
"""
def get_float_value(entry_string):
"""
Get the float value out of entry strings
(function to handle corner cases)
"""
if entry_string in ['', '.', '+.', '-.', '+', '-']:
return 0.0
return float(entry_string)
extracted_rules = []
for entry in self.entries:
if self.radio_angle_var.get(
): # if true, means radians, extract as is
ent_angle = get_float_value(entry["ent_angle"].get())
else:
ent_angle = get_float_value(entry["ent_angle"].get(
)) * RAD_FAC # convert degree to radians
ent_angle = ent_angle % (2 * PI)
ent_len = get_float_value(entry["ent_len"].get())
is_reversed = entry["reverse_state"].get()
is_flipped = entry["flip_state"].get()
if ent_angle or ent_len:
# user entered something, otherwise nothing changed
extracted_rules.append(
(ent_angle, ent_len, is_flipped, is_reversed))
return extracted_rules
def fill_entries_from_rules(self, rules):
"""
Fill in the entries in GUI for user feedback
"""
for rule in rules:
angle, length, is_flipped, is_reversed = rule
new_entry = self.create_entry_dictionary()
# clear and insert angle
new_entry['ent_angle'].delete(0, END)
if self.radio_angle_var.get(): # if angle in radians
new_entry['ent_angle'].insert(0, str(angle))
else:
new_entry['ent_angle'].insert(0, str(angle * DEG_FAC))
# clear and insert length
new_entry['ent_len'].delete(0, END)
new_entry['ent_len'].insert(0, str(length))
# set booleans
new_entry['reverse_state'].set(is_reversed)
new_entry['flip_state'].set(is_flipped)
self.entries.append(new_entry)
# def init_extract_rules_button(self):
# """
# Test button to check extracted rules
# """
# def print_extracted():
# """
# Print the extracted rules to stdout
# """
# print("Extracted:")
# print(self.extract_rules())
#
# self.test_button = Button(
# self.frame, text="extract", command=print_extracted)
# self.test_button.pack()
def init_preview_canvas(self):
"""
Canvas to draw the base curve from rules and give
preview to the user
"""
self.preview_canvas = Canvas(self.frame, width=200, height=200)
self.preview_canvas.grid(row=0, columnspan=4, sticky=W)
def form_base_curve(self, rules):
"""
Form the base curve from extracted rules for previewing
Resized to fit into the preview canvas
"""
curve = [(0, 0)]
for theta, scale_fac, _, _ in rules:
last_x, last_y = curve[-1]
curve.append((last_x + scale_fac * cos(theta),
last_y + scale_fac * sin(theta)))
min_x = min(point[0] for point in curve)
min_y = min(point[1] for point in curve)
scale_y = max(point[1] - min_y for point in curve)
scale_x = max(point[0] - min_x for point in curve)
if scale_x == 0 or scale_y == 0:
return curve
canvas_width = self.preview_canvas.winfo_width()
canvas_height = self.preview_canvas.winfo_height()
to_scale = min(canvas_width / scale_x, canvas_height / scale_y) * 0.8
curve = [((point[0] - min_x) * to_scale + canvas_width / 10,
(point[1] - min_y) * to_scale + canvas_height / 10)
for point in curve]
return curve
def render_preview(self):
"""
Render the preview on canvas on calling the function
Desired to be called by some update function
"""
# Not the best way to do it but the curve size is of constant
# order, <20 segments, so it wouldnt create much difference
extracted_rules = self.extract_rules()
self.set_rules_in_curve(extracted_rules)
# set the rules in the parent curve dynamically
curve = self.form_base_curve(extracted_rules)
self.preview_canvas.delete("all")
if len(curve) > 1: # draw only if there are more than one points
self.preview_canvas.create_line(curve, arrow=LAST)
def init_info_labels(self):
"""
Initialize the labels providing info about input fields
"""
Radiobutton(self.frame,
variable=self.radio_angle_var,
value=False,
text="Degrees").grid(row=1, column=0)
Radiobutton(self.frame,
variable=self.radio_angle_var,
value=True,
text="Radians").grid(row=1, column=1)
Label(self.frame, text="Angle").grid(row=2, column=0, sticky=W)
Label(self.frame, text="Length").grid(row=2, column=1, sticky=W)
def set_rules_in_curve(self, rules):
"""
Set the rules entries received into the rules of Curve
class
"""
self.parent_class.parent_class.classes["fractal"].set_rules(rules)
def __init__(self, master):
self.tradeRecord = []
self.master = master
master.title("Option Viewer")
#Set the framework for the components
#====================================
topFrame = Frame(master)
topFrame.pack()
botFrame = Frame(master)
botFrame.pack()
swFrame = Frame(botFrame)
swFrame.pack(side=LEFT)
seFrame = Frame(botFrame)
seFrame.pack(side=RIGHT)
self.topFrame = topFrame
self.swFrame = swFrame
self.seFrame = seFrame
#Variable initialisations
self.scenWin = None
self.scenFrame = None
self.scenInputHeading = None
self.scenarioEntry = None
self.scenRecord = None
self.spot = 0.0
self.tsPlotSeries1 = "Delta"
self.tsPlotSeries2 = "Gamma"
#Input for individual trades (Top Frame)
#=====================================
#Wrap the data validator
vcmdFloat = topFrame.register(self.validateFloat)
vcmdPutCall = topFrame.register(self.validatePutCall)
#Title and spot price entry
topFrameTitleLabel = Label(topFrame, text="Option Trades")
topFrameTitleLabel.grid(row=0, column=0, columnspan=2, sticky=W)
spotLabel = Label(topFrame, text="Spot")
spotLabel.grid(row=0, column=len(self.TradeInputField) - 1, sticky=E)
self.spotEntry = Entry(topFrame,
validate="key",
validatecommand=(vcmdFloat, '%P'))
self.spotEntry.grid(row=0, column=len(self.TradeInputField), sticky=E)
#Input area for individual trades
#Labels for field names and row number
tradeInputLabel = []
for _, dispName, _ in self.TradeInputField:
tradeInputLabel.append(Label(topFrame, text=dispName))
for i in range(len(self.TradeInputField)):
tradeInputLabel[i].grid(row=1, column=i + 1, sticky=W)
for j in range(self.NTradeInput):
rowNumLabel = Label(topFrame, text=str(j + 1))
rowNumLabel.grid(row=j + 2, column=0, sticky=W)
#Individual entry box
self.tradeEntry = [[] for i in range(self.NTradeInput)]
for j in range(self.NTradeInput):
for _, _, ftype in self.TradeInputField:
if ftype == "f":
self.tradeEntry[j].append(
Entry(topFrame,
validate="key",
validatecommand=(vcmdFloat, '%P')))
elif ftype == "putCall":
self.tradeEntry[j].append(
Entry(topFrame,
validate="key",
validatecommand=(vcmdPutCall, '%P')))
for i in range(len(self.TradeInputField)):
for j in range(self.NTradeInput):
self.tradeEntry[j][i].grid(row=j + 2,
column=i + 1,
sticky=W + E)
#Control buttons
nTradeInputField = len(self.TradeInputField)
self.calcButton = Button(topFrame,
text="Calculate",
command=self.mainCalculation)
self.calcButton.grid(row=self.NTradeInput + 2,
column=nTradeInputField - 1,
sticky=W + E)
self.scenButton = Button(topFrame,
text="Scenario",
command=self.scenarioWin)
self.scenButton.grid(row=self.NTradeInput + 2,
column=nTradeInputField,
sticky=W + E)
#Setup payoff chart area (SW Frame)
#=====================================
fig = Figure(figsize=(18, 5))
fig.add_subplot(141)
ax2 = fig.add_subplot(142)
ax2.twinx()
ax3 = fig.add_subplot(143)
ax3.twinx()
ax4 = fig.add_subplot(144)
ax4.twinx()
self.canvas = FigureCanvasTkAgg(fig, master=swFrame)
self.canvas.get_tk_widget().pack(side=LEFT)
#Choose the greeks to be displayed in timeseries plot
cbFrame = Frame(swFrame)
cbFrame.pack(side=RIGHT)
self.greekChoice = [IntVar() for i in range(len(self.GreekTSField))]
Label(cbFrame, text="Select up to 2 greeks ").pack()
Label(cbFrame, text="for timeseries chart ").pack()
for i, f in enumerate(self.GreekTSField):
Checkbutton(cbFrame,
text=f,
variable=self.greekChoice[i],
command=self.cbCtrl).pack(side=TOP, anchor=W)
