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()
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)