class CheckBox: def __init__(self, root, text: str, x: int, y: int): self.varChecked = BooleanVar() self.text = text self.checkbox = Checkbutton(root, text=self.text, variable=self.varChecked, onvalue=True, offvalue=False) self.x = x self.y = y self.checkbox.pack() self.checkbox.place(x=self.x, y=self.y) @property def command(self): return self.command @command.setter def command(self, command): self.checkbox['command'] = command def isChecked(self): return True if self.varChecked.get() else False def check(self): self.checkbox.select() def uncheck(self): self.checkbox.deselect()
class ProgressCheckButton(Frame, Observable): def __init__(self, parent, model, index, status_model): Frame.__init__(self, parent) Observable.__init__(self) self.model = model self.index = index self.status_model = status_model self.var = IntVar() self.var.set(model.get_checked()) self.progress_var = IntVar() self.progress_status = ProgressStatus.undefined self.check_button = Checkbutton(self, text=model.get_label, variable=self.var, command=self._check_changed) self.progress_bar = Progressbar(self, orient='horizontal', mode='indeterminate', variable=self.progress_var) self.check_button.pack(side=LEFT, fill="both", expand=True) self.model.add_listener(self._model_changed) def _model_changed(self, new_status): model_state = self.model.get_checked() gui_state = self.var.get() if model_state is not gui_state: self.model.set_checked(gui_state) def refresh_check(self): if self.status_model.is_checked_force_reload(): self.check_button.select() else: self.check_button.deselect() def is_checked(self): return self.var.get() def _progress_status_changed(self, new_status): self._refresh_progress() def _refresh_progress(self): status = self.status_model.get_status() if not status == self.progress_status: if status == ProgressStatus.in_progress: self.progress_bar.pack(side=RIGHT, fill="both", expand=True) else: self.progress_bar.pack_forget() def _check_changed(self): new_checked = self.var.get() if new_checked is not self.model.get_checked(): self.model.set_checked(new_checked) if new_checked is not self.status_model.is_checked(): self._notify(self.index, new_checked)
class ProgressListBoxItem(Frame, Observable): def __init__(self, parent, model): Frame.__init__(self, parent) Observable.__init__(self) self._model = model # Create variables and initialise to zero self._checked_var = IntVar() self._progress_var = IntVar() self._checked_var.set(0) self._progress_var.set(0) self._current_gui_checked_state = CheckStatus.undefined self._current_gui_progress_state = ProgressStatus.undefined self.check_button = Checkbutton(self, text=model.get_label(), variable=self._checked_var, command=self._user_check_changed) self.progress_bar = Progressbar(self, orient='horizontal', mode='indeterminate', variable=self._progress_var) self.check_button.pack(side=LEFT, fill="both", expand=True) self._update() self._model.add_listener(self._model_changed) def _model_changed(self): self.update() def _update(self): # Update check status model_check_state = self._model.get_check_status() if model_check_state is not self._current_gui_checked_state: self._current_gui_checked_state = model_check_state # if self.status_model.is_checked_force_reload(): if model_check_state: self.check_button.select() else: self.check_button.deselect() # Update progress status model_progress_state = self._model.get_progress_status if not model_progress_state == self._current_gui_progress_state: self._current_gui_progress_state = model_progress_state if model_progress_state == ProgressStatus.in_progress: self.progress_bar.pack(side=RIGHT, fill="both", expand=True) else: self.progress_bar.pack_forget() def _user_check_changed(self): new_checked = self._checked_var.get() if new_checked is not self._model.get_check_status(): self._model.manual_set_checked(new_checked)
class FensterRound(Frame): def __init__(self, master, controller): super().__init__(master) self.controller = controller self.int_round = StringVar(value=self.controller.int_round) self.int_round.trace_add('write', self.callback_int) if self.controller.bool_roundActive: self.bool_roundActive = BooleanVar(value=1) else: self.bool_roundActive = BooleanVar(value=0) self.grid() self.chkb = Checkbutton(master, text="Runden", var=self.bool_roundActive, command=self.callback_chkb) self.chkb.grid(row=0, column=0, padx=3, pady=3, sticky="w") Label(master, text="Anzahl Nachkommastellen").grid(row=1, column=0, padx=3, pady=3, sticky="w") self.entry_round = Entry(master,textvariable=self.int_round, validate="all", validatecommand=self.callback_int, width=5) self.entry_round.grid(row=1, column=1, padx=3, pady=3, sticky="e") self.init_chkb() self.callback_chkb() def callback_chkb(self): if self.bool_roundActive.get() == 1: self.entry_round.config(state="normal") self.controller.bool_roundActive = True else: self.entry_round.config(state="disabled") self.controller.bool_roundActive = False def callback_int(self, *args): if self.int_round.get() != "": self.controller.int_round = int(self.int_round.get()) def init_chkb(self): if self.controller.bool_roundActive: self.chkb.select() else: self.chkb.deselect()
from tkinter import DISABLED from tkinter import SUNKEN from tkinter import HORIZONTAL from tkinter import W from tkinter import E from PIL import ImageTk from PIL import Image root = Tk() root.title("Checkboxes") root.geometry("500x500") var = StringVar() def show(): Label(root, text=var.get()).pack(pady=5) checkbox = Checkbutton(root, text="Check this box", variable=var, onvalue="On", offvalue="Off") checkbox.deselect() checkbox.pack() Button(root, text="Show Selection", command=show).pack() root.mainloop()
class GUI: currentCaptureState = False index = 0 time = None config = None def __init__(self, config): GUI.config = config self.newWindow = None self.AlertShownDOS = 0 self.AlertShownDDOS = 0 self.AlertShownFTP = 0 self.main_window = Tk() self.main_window.geometry('+{}+{}'.format( int(self.main_window.winfo_screenwidth() / 3 - self.main_window.winfo_reqwidth() / 2), int(self.main_window.winfo_screenheight() / 3 - self.main_window.winfo_reqheight() / 2))) self.main_window.geometry('750x300') self.main_window.title('Intrusion Detection System') style = ttk.Style() style.map("Treeview") self.loadTreeView() self.btnStartCapture = Button(self.main_window, text="Capture Packet", width=13, relief=RAISED, disabledforeground="black", bg='#856ff8', fg='white', font=('helvetica', 9, 'bold'), state=NORMAL, command=self.startCapture) self.btnStopCapture = Button(self.main_window, text="Stop Capture", width=13, relief=RAISED, disabledforeground="black", bg='#856ff8', fg='white', font=('helvetica', 9, 'bold'), state=DISABLED, command=self.stopCapture) self.btnConfig = Button(self.main_window, text="Configuration", relief=RAISED, width=13, disabledforeground="black", bg='#856ff8', fg='white', font=('helvetica', 9, 'bold'), state=NORMAL, command=self.configWindow) self.btnStartCapture.pack(pady=10) self.btnStopCapture.pack(pady=10) self.btnConfig.pack(pady=10) self.btnStartCapture.place(x=270, y=240) self.btnStopCapture.place(x=400, y=240) self.btnConfig.place(x=530, y=240) self.labelText = StringVar() self.label = Label(self.main_window, anchor=CENTER, textvariable=self.labelText, font=('Helvetica', 9, 'bold'), relief=GROOVE, fg="blue") self.labelText.set(" Number of Packets Captured: {} ".format( GUI.index)) self.label.place(x=25, y=243) self.main_window.protocol('WM_DELETE_WINDOW', self.onClosing) self.main_window.resizable(FALSE, FALSE) self.main_window.mainloop() def loadTreeView(self): self.frame = Frame(self.main_window) self.frame.pack(pady=20) self.tree_view = ttk.Treeview(self.frame, columns=('id', 'time', 'src_ip', 'dst_ip', 'proto', 'info'), show='headings', height=8, selectmode="browse") self.tree_view.pack(side=LEFT) # Treeview Column Config self.tree_view.column('id', anchor=CENTER, width=50) self.tree_view.column('time', anchor=CENTER, width=80) # self.tree_view.column('src_mac', anchor=CENTER, width= 140) # self.tree_view.column('dst_mac', anchor=CENTER, width = 140) self.tree_view.column('src_ip', anchor=CENTER, width=140) self.tree_view.column('dst_ip', anchor=CENTER, width=140) self.tree_view.column('proto', anchor=CENTER, width=70) self.tree_view.column('info', anchor=CENTER) # Heading self.tree_view.heading('id', text='ID') self.tree_view.heading('time', text='Time') self.tree_view.heading('src_ip', text='Source IP') self.tree_view.heading('dst_ip', text='Destination IP') self.tree_view.heading('proto', text='Protocol') self.tree_view.heading('info', text='Info') # Scrollbar self.scroll_bar = Scrollbar(self.frame, orient=VERTICAL, command=self.tree_view.yview) self.scroll_bar.pack(side=RIGHT, fill=Y) # Attaching Scrollbar self.tree_view.config(yscrollcommand=self.scroll_bar.set) # Color for Attack Detection self.tree_view.tag_configure('attack', background='red') # More Details self.tree_view.bind("<Double-1>", self.OnDoubleClick) def capturing(self): while GUI.currentCaptureState and not self.thread.stopped(): raw_packet, IPaddr = self.s.recvfrom(65536) ps_object = Sniffer(raw_packet, GUI.config, "WIN") capture = ps_object.capturePacket() if not bool(capture) and capture != None: row = ps_object.appendRowToGUI() self.appendData(GUI.index, GUI.index + 1, row) GUI.index = GUI.index + 1 elif bool(capture): row = ps_object.appendRowToGUI() self.appendData(GUI.index, GUI.index + 1, row, ('attack', )) if capture[0] == "Distributed Denial of Service": self.alertAttackDDOS(capture) if capture[0] == "Denial of Service": self.alertAttackDOS(capture) if capture[0] == "FTP Brute Force Attack": self.alertAttackFTP(capture) GUI.index = GUI.index + 1 if GUI.config["logEnabled"] and not bool( capture) and capture != None: ps_object.logPacketToFile(GUI.index + 1, self.filename) elif GUI.config["logEnabled"] and bool(capture): ps_object.logPacketToFile(GUI.index + 1, self.filename, "AttackPacket") try: self.labelText.set(" Number of Packets Captured: {} ".format( GUI.index)) except: pass def startCapture(self): self.btnStartCapture.config(state=DISABLED) self.btnConfig.config(state=DISABLED) self.btnStopCapture.config(state=NORMAL) GUI.currentCaptureState = True # HOST = socket.gethostbyname(socket.gethostname()) # HOST = socket.gethostbyname(socket.gethostname()) HOST = socket.gethostbyname_ex(socket.gethostname())[2][0] # HOST = "192.168.1.23" print("Interface IP: %s" % HOST) # Create a raw socket and bind it to the public interface self.s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_IP) self.s.bind((HOST, 0)) # Include IP headers self.s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1) # Promiscuous mode - Enabled self.s.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON) if GUI.config["logEnabled"] == True: format = "%d_%m_%Y_%H_%M_%S" self.filename = datetime.now().strftime(format) + ".txt" with open('./' + str(self.filename), 'w'): pass else: self.filename = "None.txt" if GUI.time == None: GUI.time = time.time() self.thread = StoppableThread(target=self.capturing, daemon=True) self.thread.start() def stopCapture(self): self.btnStartCapture.config(state=NORMAL) self.btnConfig.config(state=NORMAL) self.btnStopCapture.config(state=DISABLED) GUI.currentCaptureState = False self.s.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF) self.thread.stop() def disableAll(self, mainAttack): if mainAttack == "DOS": self.dospingcheckbox.config(state=DISABLED) self.dossyncheckbox.config(state=DISABLED) self.dosudpcheckbox.config(state=DISABLED) self.dping_threshold.config(state=DISABLED) self.dping_timeinterval.config(state=DISABLED) self.dsyn_threshold.config(state=DISABLED) self.dsyn_timeinterval.config(state=DISABLED) self.dudp_threshold.config(state=DISABLED) self.dudp_timeinterval.config(state=DISABLED) elif mainAttack == "DDOS": self.ddospingcheckbox.config(state=DISABLED) self.ddossyncheckbox.config(state=DISABLED) self.ddosudpcheckbox.config(state=DISABLED) self.ddping_threshold.config(state=DISABLED) self.ddping_timeinterval.config(state=DISABLED) self.ddsyn_threshold.config(state=DISABLED) self.ddsyn_timeinterval.config(state=DISABLED) self.ddudp_threshold.config(state=DISABLED) self.ddudp_timeinterval.config(state=DISABLED) def enableAll(self, mainAttack): if mainAttack == "DOS": self.dospingcheckbox.config(state=NORMAL) self.dossyncheckbox.config(state=NORMAL) self.dosudpcheckbox.config(state=NORMAL) self.dping_threshold.config(state=NORMAL) self.dping_timeinterval.config(state=NORMAL) self.dsyn_threshold.config(state=NORMAL) self.dsyn_timeinterval.config(state=NORMAL) self.dudp_threshold.config(state=NORMAL) self.dudp_timeinterval.config(state=NORMAL) elif mainAttack == "DDOS": self.ddospingcheckbox.config(state=NORMAL) self.ddossyncheckbox.config(state=NORMAL) self.ddosudpcheckbox.config(state=NORMAL) self.ddping_threshold.config(state=NORMAL) self.ddping_timeinterval.config(state=NORMAL) self.ddsyn_threshold.config(state=NORMAL) self.ddsyn_timeinterval.config(state=NORMAL) self.ddudp_threshold.config(state=NORMAL) self.ddudp_timeinterval.config(state=NORMAL) def configWindow(self): if self.newWindow == None: self.main_window.withdraw() self.newWindow = Toplevel(self.main_window) self.newWindow.focus_force() self.newWindow.geometry('300x350') self.newWindow.geometry('+{}+{}'.format( int(self.newWindow.winfo_screenwidth() / 2 - self.newWindow.winfo_reqwidth() / 2), int(self.newWindow.winfo_screenheight() / 3 - self.newWindow.winfo_reqheight() / 2))) self.newWindow.title("Edit Configuration") self.newWindow.resizable(FALSE, FALSE) Label(self.newWindow, text="Threshold", font=('helvetica', 9, 'underline')).place(x=135, y=12) Label(self.newWindow, text="Time Interval", font=('helvetica', 9, 'underline')).place(x=210, y=12) self.newWindow.protocol('WM_DELETE_WINDOW', self.configClosed) # DOS checkbox self.var_dos = IntVar(self.newWindow) self.doscheckbox = Checkbutton( self.newWindow, font=('helvetica', 9, 'bold'), text='Denial of Service', variable=self.var_dos, onvalue=1, offvalue=0, command=lambda: self.configAttack("DOS")) self.doscheckbox.pack(pady=10) self.doscheckbox.place(x=10, y=10) # DOS Ping Checkbox & Fields self.var_dos_ping = IntVar(self.newWindow) self.dospingcheckbox = Checkbutton( self.newWindow, text='Ping Flood', variable=self.var_dos_ping, onvalue=1, offvalue=0, command=lambda: self.configAttack("DOS", "ping")) self.dospingcheckbox.pack(pady=10) self.dospingcheckbox.place(x=40, y=40) self.dping_threshold = Entry(self.newWindow, width=8, relief=GROOVE) self.dping_threshold.place(x=140, y=44) self.dping_timeinterval = Entry(self.newWindow, width=8, relief=GROOVE) self.dping_timeinterval.place(x=220, y=44) # DOS SYN Checkbox & Fields self.var_dos_syn = IntVar(self.newWindow) self.dossyncheckbox = Checkbutton( self.newWindow, text='SYN Flood', variable=self.var_dos_syn, onvalue=1, offvalue=0, command=lambda: self.configAttack("DOS", "syn")) self.dossyncheckbox.pack(pady=10) self.dossyncheckbox.place(x=40, y=70) self.dsyn_threshold = Entry(self.newWindow, width=8, relief=GROOVE) self.dsyn_threshold.place(x=140, y=74) self.dsyn_timeinterval = Entry(self.newWindow, width=8, relief=GROOVE) self.dsyn_timeinterval.place(x=220, y=74) # DOS UDP Checkbox & Fields self.var_dos_udp = IntVar(self.newWindow) self.dosudpcheckbox = Checkbutton( self.newWindow, text='UDP Flood', variable=self.var_dos_udp, onvalue=1, offvalue=0, command=lambda: self.configAttack("DOS", "udp")) self.dosudpcheckbox.pack(pady=10) self.dosudpcheckbox.place(x=40, y=100) self.dudp_threshold = Entry(self.newWindow, width=8, relief=GROOVE) self.dudp_threshold.place(x=140, y=104) self.dudp_timeinterval = Entry(self.newWindow, width=8, relief=GROOVE) self.dudp_timeinterval.place(x=220, y=104) self.dping_threshold.insert(END, GUI.config["DOS"]["ping"]["threshold"]) self.dping_timeinterval.insert( END, GUI.config["DOS"]["ping"]["timeinterval"]) self.dsyn_threshold.insert(END, GUI.config["DOS"]["syn"]["threshold"]) self.dsyn_timeinterval.insert( END, GUI.config["DOS"]["syn"]["timeinterval"]) self.dudp_threshold.insert(END, GUI.config["DOS"]["udp"]["threshold"]) self.dudp_timeinterval.insert( END, GUI.config["DOS"]["udp"]["timeinterval"]) if GUI.config["DOS"]["status"] == True: self.doscheckbox.select() if GUI.config["DOS"]["ping"]["status"] == True: self.dospingcheckbox.select() self.dping_threshold.config(state=NORMAL) self.dping_timeinterval.config(state=NORMAL) else: self.dping_threshold.config(state=DISABLED) self.dping_timeinterval.config(state=DISABLED) if GUI.config["DOS"]["syn"]["status"] == True: self.dossyncheckbox.select() self.dsyn_threshold.config(state=NORMAL) self.dsyn_timeinterval.config(state=NORMAL) else: self.dsyn_threshold.config(state=DISABLED) self.dsyn_timeinterval.config(state=DISABLED) if GUI.config["DOS"]["udp"]["status"] == True: self.dosudpcheckbox.select() self.dudp_threshold.config(state=NORMAL) self.dudp_timeinterval.config(state=NORMAL) else: self.dudp_threshold.config(state=DISABLED) self.dudp_timeinterval.config(state=DISABLED) else: self.disableAll("DOS") # DDOS checkbox self.var_ddos = IntVar(self.newWindow) self.ddoscheckbox = Checkbutton( self.newWindow, font=('helvetica', 9, 'bold'), text='Distributed Denial of Service', variable=self.var_ddos, onvalue=1, offvalue=0, command=lambda: self.configAttack("DDOS")) self.ddoscheckbox.pack(pady=10) self.ddoscheckbox.place(x=10, y=130) # DDOS Ping Checkbox & Fields self.var_ddos_ping = IntVar(self.newWindow) self.ddospingcheckbox = Checkbutton( self.newWindow, text='Ping Flood', variable=self.var_ddos_ping, onvalue=1, offvalue=0, command=lambda: self.configAttack("DDOS", "ping")) self.ddospingcheckbox.pack(pady=10) self.ddospingcheckbox.place(x=40, y=160) self.ddping_threshold = Entry(self.newWindow, width=8, relief=GROOVE) self.ddping_threshold.place(x=140, y=164) self.ddping_timeinterval = Entry(self.newWindow, width=8, relief=GROOVE) self.ddping_timeinterval.place(x=220, y=164) # DDOS SYN Checkbox & Fields self.var_ddos_syn = IntVar(self.newWindow) self.ddossyncheckbox = Checkbutton( self.newWindow, text='SYN Flood', variable=self.var_ddos_syn, onvalue=1, offvalue=0, command=lambda: self.configAttack("DDOS", "syn")) self.ddossyncheckbox.pack(pady=10) self.ddossyncheckbox.place(x=40, y=190) self.ddsyn_threshold = Entry(self.newWindow, width=8, relief=GROOVE) self.ddsyn_threshold.place(x=140, y=194) self.ddsyn_timeinterval = Entry(self.newWindow, width=8, relief=GROOVE) self.ddsyn_timeinterval.place(x=220, y=194) # DDOS UDP Checkbox & Fields self.var_ddos_udp = IntVar(self.newWindow) self.ddosudpcheckbox = Checkbutton( self.newWindow, text='UDP Flood', variable=self.var_ddos_udp, onvalue=1, offvalue=0, command=lambda: self.configAttack("DDOS", "udp")) self.ddosudpcheckbox.pack(pady=10) self.ddosudpcheckbox.place(x=40, y=220) self.ddudp_threshold = Entry(self.newWindow, width=8, relief=GROOVE) self.ddudp_threshold.place(x=140, y=224) self.ddudp_timeinterval = Entry(self.newWindow, width=8, relief=GROOVE) self.ddudp_timeinterval.place(x=220, y=224) self.ddping_threshold.insert( END, GUI.config["DDOS"]["ping"]["threshold"]) self.ddping_timeinterval.insert( END, GUI.config["DDOS"]["ping"]["timeinterval"]) self.ddsyn_threshold.insert(END, GUI.config["DDOS"]["syn"]["threshold"]) self.ddsyn_timeinterval.insert( END, GUI.config["DDOS"]["syn"]["timeinterval"]) self.ddudp_threshold.insert(END, GUI.config["DDOS"]["udp"]["threshold"]) self.ddudp_timeinterval.insert( END, GUI.config["DDOS"]["udp"]["timeinterval"]) if GUI.config["DDOS"]["status"] == True: self.ddoscheckbox.select() if GUI.config["DDOS"]["ping"]["status"] == True: self.ddospingcheckbox.select() self.ddping_threshold.config(state=NORMAL) self.ddping_timeinterval.config(state=NORMAL) else: self.ddping_threshold.config(state=DISABLED) self.ddping_timeinterval.config(state=DISABLED) if GUI.config["DDOS"]["syn"]["status"] == True: self.ddossyncheckbox.select() self.ddsyn_threshold.config(state=NORMAL) self.ddsyn_timeinterval.config(state=NORMAL) else: self.ddsyn_threshold.config(state=DISABLED) self.ddsyn_timeinterval.config(state=DISABLED) if GUI.config["DDOS"]["udp"]["status"] == True: self.ddosudpcheckbox.select() self.ddudp_threshold.config(state=NORMAL) self.ddudp_timeinterval.config(state=NORMAL) else: self.ddudp_threshold.config(state=DISABLED) self.ddudp_timeinterval.config(state=DISABLED) else: self.disableAll("DDOS") # FTP Brute Force self.var_ftp = IntVar(self.newWindow) self.ftpcheckbox = Checkbutton(self.newWindow, font=('helvetica', 9, 'bold'), text='FTP Brute Force', variable=self.var_ftp, onvalue=1, offvalue=0, command=self.configFTPAttack) self.ftpcheckbox.pack(pady=10) self.ftpcheckbox.place(x=10, y=250) self.ftp_threshold = Entry(self.newWindow, width=8, relief=GROOVE) self.ftp_threshold.place(x=140, y=254) self.ftp_timeinterval = Entry(self.newWindow, width=8, relief=GROOVE) self.ftp_timeinterval.place(x=220, y=254) self.ftp_threshold.insert(END, GUI.config["FTP"]["threshold"]) self.ftp_timeinterval.insert(END, GUI.config["FTP"]["timeinterval"]) if GUI.config["FTP"]["status"] == True: self.ftpcheckbox.select() self.ftp_threshold.config(state=NORMAL) self.ftp_timeinterval.config(state=NORMAL) else: self.ftpcheckbox.deselect() self.ftp_threshold.config(state=DISABLED) self.ftp_timeinterval.config(state=DISABLED) # Packet Log self.dumy_var = IntVar(self.newWindow) self.checkbox = Checkbutton(self.newWindow, font=('helvetica', 9, 'bold'), text='Log Packets', variable=self.dumy_var, onvalue=1, offvalue=0, command=self.updateLogState) self.checkbox.pack(pady=10) self.checkbox.place(x=10, y=280) if GUI.config["logEnabled"] == True: self.checkbox.select() self.newWindow.mainloop() def configAttack(self, mainAttack, type=None): if mainAttack == "DOS" and type == None: if self.var_dos.get() == 1: GUI.config[mainAttack]["ping"]["status"] = True GUI.config[mainAttack]["syn"]["status"] = True GUI.config[mainAttack]["udp"]["status"] = True self.dospingcheckbox.select() self.dossyncheckbox.select() self.dosudpcheckbox.select() GUI.config[mainAttack]["status"] = True self.enableAll("DOS") else: GUI.config[mainAttack]["ping"]["status"] = False GUI.config[mainAttack]["syn"]["status"] = False GUI.config[mainAttack]["udp"]["status"] = False self.dospingcheckbox.deselect() self.dossyncheckbox.deselect() self.dosudpcheckbox.deselect() GUI.config[mainAttack]["status"] = False self.disableAll("DOS") elif mainAttack == "DOS" and type == "ping": if self.var_dos_ping.get() == 1: GUI.config[mainAttack][type]["status"] = True self.dping_threshold.config(state=NORMAL) self.dping_timeinterval.config(state=NORMAL) else: GUI.config[mainAttack][type]["status"] = False self.dping_threshold.config(state=DISABLED) self.dping_timeinterval.config(state=DISABLED) elif mainAttack == "DOS" and type == "syn": if self.var_dos_syn.get() == 1: GUI.config[mainAttack][type]["status"] = True self.dsyn_threshold.config(state=NORMAL) self.dsyn_timeinterval.config(state=NORMAL) else: GUI.config[mainAttack][type]["status"] = False self.dsyn_threshold.config(state=DISABLED) self.dsyn_timeinterval.config(state=DISABLED) elif mainAttack == "DOS" and type == "udp": if self.var_dos_udp.get() == 1: GUI.config[mainAttack][type]["status"] = True self.dudp_threshold.config(state=NORMAL) self.dudp_timeinterval.config(state=NORMAL) else: GUI.config[mainAttack][type]["status"] = False self.dudp_threshold.config(state=DISABLED) self.dudp_timeinterval.config(state=DISABLED) elif mainAttack == "DDOS" and type == None: if self.var_ddos.get() == 1: GUI.config[mainAttack]["ping"]["status"] = True GUI.config[mainAttack]["syn"]["status"] = True GUI.config[mainAttack]["udp"]["status"] = True self.ddospingcheckbox.select() self.ddossyncheckbox.select() self.ddosudpcheckbox.select() GUI.config[mainAttack]["status"] = True self.enableAll("DDOS") else: GUI.config[mainAttack]["ping"]["status"] = False GUI.config[mainAttack]["syn"]["status"] = False GUI.config[mainAttack]["udp"]["status"] = False self.ddospingcheckbox.deselect() self.ddossyncheckbox.deselect() self.ddosudpcheckbox.deselect() GUI.config[mainAttack]["status"] = False self.disableAll("DDOS") elif mainAttack == "DDOS" and type == "ping": if self.var_ddos_ping.get() == 1: GUI.config[mainAttack][type]["status"] = True self.ddping_threshold.config(state=NORMAL) self.ddping_timeinterval.config(state=NORMAL) else: GUI.config[mainAttack][type]["status"] = False self.ddping_threshold.config(state=DISABLED) self.ddping_timeinterval.config(state=DISABLED) elif mainAttack == "DDOS" and type == "syn": if self.var_ddos_syn.get() == 1: GUI.config[mainAttack][type]["status"] = True self.ddsyn_threshold.config(state=NORMAL) self.ddsyn_timeinterval.config(state=NORMAL) else: GUI.config[mainAttack][type]["status"] = False self.ddsyn_threshold.config(state=DISABLED) self.ddsyn_timeinterval.config(state=DISABLED) elif mainAttack == "DDOS" and type == "udp": if self.var_ddos_udp.get() == 1: GUI.config[mainAttack][type]["status"] = True self.ddudp_threshold.config(state=NORMAL) self.ddudp_timeinterval.config(state=NORMAL) else: GUI.config[mainAttack][type]["status"] = False self.ddudp_threshold.config(state=DISABLED) self.ddudp_timeinterval.config(state=DISABLED) def configFTPAttack(self): if self.var_ftp.get() == 1: GUI.config["FTP"]["status"] = True self.ftpcheckbox.select() self.ftp_threshold.config(state=NORMAL) self.ftp_timeinterval.config(state=NORMAL) else: GUI.config["FTP"]["status"] = False self.ftpcheckbox.deselect() self.ftp_threshold.config(state=DISABLED) self.ftp_timeinterval.config(state=DISABLED) def configClosed(self): try: temp = GUI.config temp["DOS"]["ping"]["threshold"] = int(self.dping_threshold.get()) temp["DOS"]["ping"]["timeinterval"] = int( self.dping_timeinterval.get()) temp["DOS"]["syn"]["threshold"] = int(self.dsyn_threshold.get()) temp["DOS"]["syn"]["timeinterval"] = int( self.dsyn_timeinterval.get()) temp["DOS"]["udp"]["threshold"] = int(self.dudp_threshold.get()) temp["DOS"]["udp"]["timeinterval"] = int( self.dudp_timeinterval.get()) temp["DDOS"]["ping"]["threshold"] = int( self.ddping_threshold.get()) temp["DDOS"]["ping"]["timeinterval"] = int( self.ddping_timeinterval.get()) temp["DDOS"]["syn"]["threshold"] = int(self.ddsyn_threshold.get()) temp["DDOS"]["syn"]["timeinterval"] = int( self.ddsyn_timeinterval.get()) temp["DDOS"]["udp"]["threshold"] = int(self.ddudp_threshold.get()) temp["DDOS"]["udp"]["timeinterval"] = int( self.ddudp_timeinterval.get()) temp["FTP"]["threshold"] = int(self.ftp_threshold.get()) temp["FTP"]["timeinterval"] = int(self.ftp_timeinterval.get()) GUI.config = temp except: pass with open('./Config.json', 'w') as file: json.dump(GUI.config, file) self.newWindow.destroy() self.main_window.deiconify() self.newWindow = None def alertAttackDOS(self, display): if self.AlertShownDOS == 0: mailer = Mailer(GUI.config["Mail"]) mailer.send( "Alert! Denial of Service detected from \nIP ~ {}\nType ~ {} Flood!" .format(display[1], display[2].upper())) self.alertdos = Tk() self.alertdos.title(display[0]) self.alertdos.geometry("350x50") self.alertdos.geometry('+{}+{}'.format( int(self.alertdos.winfo_screenwidth() / 2.3 - self.alertdos.winfo_reqwidth() / 2), int(self.alertdos.winfo_screenheight() / 2 - self.alertdos.winfo_reqheight() / 2))) self.alertdos.winfo_toplevel() self.alertdos.focus_force() Label( self.alertdos, anchor=CENTER, text= "Alert! Denial of Service detected from IP: {}\nType: {} Flood!" .format(display[1], display[2].upper()), font=('helvetica', 9)).pack() self.alertdos.protocol('WM_DELETE_WINDOW', self.alertdosClosed) self.alertdos.mainloop() def alertdosClosed(self): self.alertdos.destroy() self.AlertShownDOS = 1 def alertAttackDDOS(self, display): if self.AlertShownDDOS == 0: mailer = Mailer(GUI.config["Mail"]) mailer.send( "Alert! Distributed Denial of Service detected from \nIP's ~ {}\nType ~ {} Flood!" .format(', '.join(list(display[1])), display[2].upper())) self.alertddos = Tk() self.alertddos.title(display[0]) self.alertddos.geometry("400x50") self.alertddos.geometry('+{}+{}'.format( int(self.alertddos.winfo_screenwidth() / 2.3 - self.alertddos.winfo_reqwidth() / 2), int(self.alertddos.winfo_screenheight() / 2 - self.alertddos.winfo_reqheight() / 2))) self.alertddos.winfo_toplevel() self.alertddos.focus_force() Label( self.alertddos, anchor=CENTER, text= "Alert! Distributed Denial of Service detected from \nIP's: {}\nType: {} Flood!" .format(', '.join(list(display[1])), display[2].upper()), font=('helvetica', 9)).pack() self.alertddos.protocol('WM_DELETE_WINDOW', self.alertddosClosed) self.alertddos.mainloop() def alertddosClosed(self): self.alertddos.destroy() self.AlertShownDDOS = 1 def alertAttackFTP(self, display): if self.AlertShownFTP == 0: mailer = Mailer(GUI.config["Mail"]) mailer.send( "Alert! FTP Login-Brute Force Attack detected from \nIP ~ {}". format(display[1])) self.alertftp = Tk() self.alertftp.title(display[0]) self.alertftp.geometry("350x50") self.alertftp.geometry('+{}+{}'.format( int(self.alertftp.winfo_screenwidth() / 2.3 - self.alertftp.winfo_reqwidth() / 2), int(self.alertftp.winfo_screenheight() / 2 - self.alertftp.winfo_reqheight() / 2))) self.alertftp.winfo_toplevel() self.alertftp.focus_force() Label( self.alertftp, anchor=CENTER, text= "Alert! FTP Login-Brute Force Attack detected from \nIP: {}!". format(display[1]), font=('helvetica', 9)).pack() self.alertftp.protocol('WM_DELETE_WINDOW', self.alertftpClosed) self.alertftp.mainloop() def alertftpClosed(self): self.alertftp.destroy() self.AlertShownFTP = 1 def appendData(self, currentIndex, currentID, value_list, tags=()): try: value_list.insert(1, "{:.4f}".format(time.time() - GUI.time)) self.tree_view.insert(parent='', index=currentIndex, iid=currentID, values=value_list, tags=tags) except: pass def OnDoubleClick(self, event): item_selected = self.tree_view.identify('item', event.x, event.y) selectedID = int(self.tree_view.item(item_selected, "values")[0]) with open("./PacketLog.json", 'r') as file: storedData = json.load(file) selectedPacket = [ x for x in storedData["Packets"] if x["pacID"] == selectedID ][0] if selectedPacket["protocol"] == 1: TYPE_STR = {8: "Request", 0: "Reply", 3: "Error"} message = """Packet ID: {} Version: {} Header Length: {} bytes Time to Live: {} seconds Protocol: {} Source IP Address: {} Destination IP Address: {} Type: {} - {} Code: {} Sequence Number: {}""".format( selectedPacket["pacID"], selectedPacket['version'], selectedPacket['header_length'], selectedPacket['time_to_live'], selectedPacket['protocol'], selectedPacket['src_ip_addr'], selectedPacket['dest_ip_addr'], selectedPacket['type_icmp'], TYPE_STR[selectedPacket['type_icmp']], selectedPacket['code'], selectedPacket['sequence_number']) elif selectedPacket["protocol"] == 6: message = """Packet ID: {} Version: {} Header Length: {} bytes Time to Live: {} seconds Protocol: {} Source IP Address: {} Destination IP Address: {} Source Port: {} Destination Port: {} Sequence Number: {} Acknowlegdement Number: {} Header Length:{} Bytes URG Flag: {} ACK Flag: {} PSH Flag: {} RST Flag: {} SYN Flag: {} FIN Flag: {}""".format( selectedPacket["pacID"], selectedPacket['version'], selectedPacket['header_length'], selectedPacket['time_to_live'], selectedPacket['protocol'], selectedPacket['src_ip_addr'], selectedPacket['dest_ip_addr'], selectedPacket['src_port'], selectedPacket['dest_port'], selectedPacket['seq_number'], selectedPacket['ack_number'], selectedPacket['header_length_tcp'], selectedPacket['URG_Flag'], selectedPacket['ACK_Flag'], selectedPacket['PSH_Flag'], selectedPacket['RST_Flag'], selectedPacket['SYN_Flag'], selectedPacket['FIN_Flag']) elif selectedPacket["protocol"] == 17: message = """Packet ID: {} Version: {} Header Length: {} bytes Time to Live: {} seconds Protocol: {} Source IP Address: {} Destination IP Address: {} Source Port: {} Destination Port: {} Data Length:{} Bits""".format( selectedPacket["pacID"], selectedPacket['version'], selectedPacket['header_length'], selectedPacket['time_to_live'], selectedPacket['protocol'], selectedPacket['src_ip_addr'], selectedPacket['dest_ip_addr'], selectedPacket['src_port'], selectedPacket['dest_port'], selectedPacket['UDP_len']) else: message = "None" messagebox.showinfo("Selected Packet", message) def updateLogState(self): if self.dumy_var.get() == 1: GUI.config["logEnabled"] = True else: GUI.config["logEnabled"] = False def onClosing(self): self.main_window.withdraw() sys.exit(0)
class UI: box_colors = {'fill': 'red', 'outline': 'red'} line_color = 'red' corner_radius = 2 def __init__(self, root): # toolbar stuff # https://www.youtube.com/watch?v=AYOs78NjYfc # set up window self.root = root self.root.geometry('650x400') # self.root.resizable(width=False, height=False) self.root.title('BrilliantImagery') self.root.iconbitmap(resource_path() / 'brilliantimagery_ui' / 'logo.ico') self.sequence = None self.canvas = None self.image = None self.point1 = () self.point2 = () self.last_points = ((), ()) self.files_last_parsed = None self._make_menu_bar() # set up tabs self.tab_control = ttk.Notebook(self.root) self._make_ramp_stabilize_tab() self._make_renderer_tab() def _make_menu_bar(self): def quite_app(): self.root.quit() self.menu = Menu(self.root) # ------ File Menu ------ file_menu = Menu(self.menu, tearoff=0) file_menu.add_command(label='Open Project', accelerator='Ctrl+O', command=self._open_project) file_menu.add_command(label='Save Project', accelerator='Ctrl+S', command=self._save_project) file_menu.add_separator() file_menu.add_command(label='Exit', command=quite_app) self.menu.add_cascade(label='File', menu=file_menu) # --------- Help Menu -------- help_menu = Menu(self.menu, tearoff=0) help_menu.add_command(label='About', command=lambda: messagebox.showinfo( 'About', f"BrilliantImagery UI\n\n" f"Version: " f"{brilliantimagery.__version__}" f"\nGo to brilliantimagery.org " f"for more info.")) self.menu.add_cascade(label='Help', menu=help_menu) self.root.config(menu=self.menu) def _make_renderer_tab(self): tab_renderer = ttk.Frame(self.tab_control) self.tab_control.add(tab_renderer, text='Renderer') self.tab_control.pack(expand=1, fill='both') interface_frame = Frame(tab_renderer) interface_frame.pack(side=TOP, anchor=W) Label(interface_frame, text='Image Path:').grid(row=0, column=0, padx=10, pady=10) file_entry = Entry(interface_frame, width=70) file_entry.grid(row=0, column=1) folder_button = Button(interface_frame, text='File', command=lambda: self._open_image(file_entry)) folder_button.grid(row=0, column=2, padx=10) image_frame = Frame(tab_renderer) image_frame.pack(expand=1, fill='both') self.renderer_canvas = Canvas(image_frame, width=500, height=350, scrollregion=(0, 0, 500, 350)) horizontal_scroll_bar = Scrollbar(image_frame, orient=HORIZONTAL) vertical_scroll_bar = Scrollbar(image_frame, orient=VERTICAL) horizontal_scroll_bar.pack(side=BOTTOM, fill=X) vertical_scroll_bar.pack(side=RIGHT, fill=Y) horizontal_scroll_bar.config(command=self.renderer_canvas.xview) vertical_scroll_bar.config(command=self.renderer_canvas.yview) self.renderer_canvas.pack(side=LEFT, expand=True, fill=BOTH) self.renderer_canvas.config(xscrollcommand=horizontal_scroll_bar.set, yscrollcommand=vertical_scroll_bar.set) def _make_ramp_stabilize_tab(self): # set up tab tab_ramp_stabilize = ttk.Frame(self.tab_control) self.tab_control.add(tab_ramp_stabilize, text='Ramp & Stabilize') self.tab_control.pack(expand=1, fill='both') # self.tab_control.grid(row=0, column=0) # make image canvas self.canvas = Canvas(tab_ramp_stabilize, width=255, height=255) self.canvas.grid(row=0, column=0, columnspan=2, rowspan=4) self.canvas.bind('<Button-1>', self._process_canvas_click) # make function checkboxes procedures_frame = LabelFrame(tab_ramp_stabilize, text='Operations To Perform') procedures_frame.grid(row=0, column=2, padx=5, pady=5, sticky=NW) self.ramp = IntVar() self.ramp_checkbutton = Checkbutton(procedures_frame, text="Ramp Linear Properties", variable=self.ramp) self.ramp_checkbutton.grid(row=0, column=0, sticky=W) self.exposure = IntVar() self.exposure_checkbutton = Checkbutton(procedures_frame, text="Ramp Exposure", variable=self.exposure) self.exposure_checkbutton.grid(row=1, column=0, sticky=W) self.stabilize = IntVar() self.stabilize_checkbutton = Checkbutton(procedures_frame, text="Stabilize", variable=self.stabilize) self.stabilize_checkbutton.grid(row=2, column=0, sticky=W) # Reload and reuse reuse_frame = LabelFrame(tab_ramp_stabilize, text='Data Reuse') reuse_frame.grid(row=1, column=2, padx=5, pady=5, sticky=NW) self.reuse_misalignment = IntVar() self.reuse_mis_checkbutton = Checkbutton( reuse_frame, text='Use Previously Calculated Misalignments', variable=self.reuse_misalignment) self.reuse_mis_checkbutton.grid(row=0, column=0, sticky=NW) self.reuse_brightness = IntVar() self.reuse_bright_checkbutton = Checkbutton( reuse_frame, text='Use Previously Calculated Brightnesses', variable=self.reuse_brightness) self.reuse_bright_checkbutton.grid(row=1, column=0, sticky=NW) Button(reuse_frame, text='Reload Image', command=lambda: (self._load_sequence(self.folder_entry.get()))).grid(row=2, column=0, sticky=NW, padx=5, pady=5) # set up folder selector folder_selector_row = 4 folder_selector_column = 0 Label(tab_ramp_stabilize, text='Sequence Folder:').grid(row=folder_selector_row, column=folder_selector_column, padx=10) self.folder_entry = Entry(tab_ramp_stabilize, width=70) self.folder_entry.grid(row=folder_selector_row, column=folder_selector_column + 1, columnspan=2) self.folder_entry.bind( '<FocusOut>', lambda e: self._load_sequence(self.folder_entry.get())) folder_button = Button(tab_ramp_stabilize, text='Folder', command=self._open_sequence) folder_button.grid(row=folder_selector_row, column=folder_selector_column + 3, sticky=W, padx=10) process_button = Button( tab_ramp_stabilize, text='Process', command=lambda: self._process_sequence(message_finished.get())) process_button.grid(row=folder_selector_row + 1, column=0, sticky=W, padx=10, pady=10) message_finished = IntVar() Checkbutton(tab_ramp_stabilize, text="Show MessageBox when done.", variable=message_finished).grid(row=folder_selector_row + 1, column=1, sticky=W) def _process_sequence(self, show_finished): if not self._validate_selections(): return self._maybe_reset_misalignment_brightness() rectangle = (min(self.point1[0], self.point2[0]), min(self.point1[1], self.point2[1]), max(self.point1[0], self.point2[0]), max(self.point1[1], self.point2[1])) rectangle = [ rectangle[0] / self.image.width(), rectangle[1] / self.image.height(), rectangle[2] / self.image.width(), rectangle[3] / self.image.height() ] last_modified = files_last_updated(self.sequence.path) if last_modified > self.files_last_parsed: self.sequence.parse_sequence() self.files_last_parsed = time.time() if self.ramp.get( ) and not self.exposure.get() and not self.stabilize.get(): self.sequence.ramp_minus_exmpsure() elif not self.ramp.get() and self.exposure.get( ) and not self.stabilize.get(): self.sequence.ramp_exposure(rectangle) elif not self.ramp.get() and not self.exposure.get( ) and self.stabilize.get(): self.sequence.stabilize(rectangle) elif self.ramp.get() and self.exposure.get( ) and not self.stabilize.get(): self.sequence.ramp(rectangle) elif not self.ramp.get() and self.exposure.get( ) and self.stabilize.get(): self.sequence.ramp_exposure_and_stabilize(rectangle) elif self.ramp.get( ) and not self.exposure.get() and self.stabilize.get(): self.sequence.ramp_minus_exposure_and_stabilize(rectangle) elif self.ramp.get() and self.exposure.get() and self.stabilize.get(): self.sequence.ramp_and_stabilize(rectangle) self.sequence.save() if self.exposure.get(): self.reuse_bright_checkbutton.select() if self.stabilize.get(): self.reuse_mis_checkbutton.select() self.last_points = (self.point1, self.point2) if show_finished: messagebox.showinfo('Done', 'All done!') print('Done Processing!') def _maybe_reset_misalignment_brightness(self): folder = Path(self.folder_entry.get()) files = [ f.name for f in folder.iterdir() if (folder / f).is_file() and f.suffix.lower() == '.dng' ] if (self.point1, self.point2) != self.last_points: self.sequence.set_misalignments({f: None for f in files}) self.sequence.set_brightnesses({f: None for f in files}) else: if not self.reuse_misalignment.get(): self.sequence.set_misalignments({f: None for f in files}) if not self.reuse_brightness.get(): self.sequence.set_brightnesses({f: None for f in files}) def _open_sequence(self): folder = self._open_folder(self.folder_entry) if folder: self._load_sequence(folder) def _load_sequence(self, folder): if not Path(folder).is_dir(): return if not self.sequence or folder != self.sequence.path: self.sequence = Sequence(folder) self.files_last_parsed = time.time() image = self.sequence.get_reference_image(index_order='yxc') image = PIL.Image.fromarray(image.astype('uint8'), mode='RGB') size = (255, int(255 * image.width / image.height)) image.thumbnail(size, Image.ANTIALIAS) self.image = PhotoImage(image) self._draw_image() def _open_folder(self, entry): folder = filedialog.askdirectory(title='Select A Sequence Folder') if not folder: return self._set_text(entry, folder) return folder def _open_image(self, entry): file = self._open_file(entry) if not file: return dng = DNG(file) image_array = dng.get_image() * 255 shape = image_array.shape image_array = np.reshape(image_array, image_array.size, 'C') image_array = np.reshape(image_array, (shape[2], shape[1], shape[0]), 'F') image = PIL.Image.fromarray(image_array.astype('uint8'), mode='RGB') self.image_rendered = PhotoImage(image) self.renderer_canvas.create_image(self.image_rendered.width(), self.image_rendered.height(), image=self.image_rendered, anchor=SE) self.renderer_canvas.config(scrollregion=(0, 0, image.width, image.height)) def _open_file(self, entry): file = filedialog.askopenfilename(title='Select an Image to Render', filetypes=(('dng files', '*.dng'), ('all files', '*.*'))) if not file: return self._set_text(entry, file) return file def _set_text(self, entry, text): entry.delete(0, END) entry.insert(0, text) return def _process_canvas_click(self, click=None): if not self.image: return self._get_point(click) self._draw_image() if not self.point2: self.reuse_mis_checkbutton.deselect() self.reuse_bright_checkbutton.deselect() def _draw_image(self): if not self.image: return self.canvas.create_image(self.image.width(), self.image.height(), image=self.image, anchor=SE) if self.point1: self._draw_corner(self.point1) if self.point2: self._draw_corner(self.point2) self.canvas.create_rectangle(*self.point1, *self.point2, outline=UI.line_color) def _get_point(self, click): if not click: return if not self.point1: self.point1 = (click.x, click.y) elif not self.point2: self.point2 = (click.x, click.y) else: self.point1 = () self.point2 = () def _draw_corner(self, point): _point1 = (max(0, point[0] - UI.corner_radius), max(0, point[1] - UI.corner_radius)) _point2 = (min(self.image.width(), point[0] + UI.corner_radius), min(self.image.height(), point[1] + UI.corner_radius)) self.canvas.create_rectangle(*_point1, *_point2, **UI.box_colors) def _save_project(self): if self.sequence: misalignments = self.sequence.get_misalignments() brightnesses = self.sequence.get_brightnesses() else: misalignments = None brightnesses = None params = { 'point1': self.point1, 'point2': self.point2, 'ramp': self.ramp.get(), 'exposure': self.exposure.get(), 'stabilize': self.stabilize.get(), 'folder': self.folder_entry.get(), 'misalignments': misalignments, 'brightnesses': brightnesses, } params = json.dumps(params) file = filedialog.asksaveasfile(title='Save Project', mode='w', defaultextension='.bi', filetypes=[('BrilliantImagery Project', '.bi'), ("All Files", ".*")]) if not file: return file.write(params) file.close() def _open_project(self): file = filedialog.askopenfile(title='Open Project', mode='r', defaultextension='.bi', filetypes=[('BrilliantImagery Project', '.bi'), ("All Files", ".*")]) if not file: return params = file.read() file.close() params = json.loads(params) self.point1 = params.get('point1') self.point2 = params.get('point2') self.last_points = (self.point1, self.point2) if params.get('ramp'): self.ramp_checkbutton.select() else: self.ramp_checkbutton.deselect() if params.get('exposure'): self.exposure_checkbutton.select() else: self.exposure_checkbutton.deselect() if params.get('stabilize'): self.stabilize_checkbutton.select() else: self.stabilize_checkbutton.deselect() folder = params.get('folder') self._set_text(self.folder_entry, folder) self._load_sequence(folder) misalignments = params.get('misalignments') brightnesses = params.get('brightnesses') if misalignments: self.sequence.set_misalignments(misalignments) if list(misalignments.values())[0] != None: self.reuse_mis_checkbutton.select() if brightnesses: self.sequence.set_brightnesses(brightnesses) if list(brightnesses.values())[0] != None: self.reuse_bright_checkbutton.select() def _validate_selections(self): if self.point1 and self.point2: rectangle = True else: rectangle = False if not self.folder_entry.get(): messagebox.showerror('Oops!', 'You need to specify a Sequence Folder.') return False if rectangle and (self.exposure.get() or self.stabilize.get()): return True elif self.reuse_brightness.get() and self.exposure.get(): return True elif self.reuse_misalignment.get() and self.stabilize.get(): return True elif self.ramp.get() and not (self.exposure.get() or self.stabilize.get()): return True messagebox.showerror( 'Oops!', "You need to specify what to do (in the Operations to Perform box) " "and what information to use (either highlight a rectangle or select " "what info to reuse)") return False
class entries(main, verify): def __init__(self, root): super().__init__(root) verify.__init__(self, root) self.name1 = Label(root, text='First Name:', bg='#2B2B2B', fg='#F9F0D9', font='bold 10').place(x=10, y=80) self.name2 = Label(root, text="Second Name:", bg='#2B2B2B', fg='#F9F0D9', font='bold 10').place(x=10, y=110) self.name3 = Label(root, text="Third Name:", bg='#2B2B2B', fg='#F9F0D9', font='bold 10').place(x=10, y=140) self.name4 = Label(root, text="Fourth Name:", bg='#2B2B2B', fg='#F9F0D9', font='bold 10').place(x=10, y=170) self.year = Label(root, text='Year:', bg='#2B2B2B', fg='#B0B9D9', font='bold 10').place(x=10, y=220) self.topic = Label(root, text="Topic(s):", bg='#2B2B2B', fg='#F8D8C0', font='bold 10').place(x=10, y=250) self.book = Label(root, text="Book(s):", bg='#2B2B2B', fg='#F8D8C0', font='bold 10').place(x=10, y=330) self.volume = Label(root, text="Volume(s):", bg='#2B2B2B', fg='#B0D9D9', font='bold 10').place(x=10, y=430) self.issue = Label(root, text="Issue(s):", bg='#2B2B2B', fg='#B0D9D9', font='bold 10').place(x=10, y=460) self.page = Label(root, text="Page(s)", bg='#2B2B2B', fg='#B0D9D9', font='bold 10').place(x=10, y=490) self.req = Label(root, text='*', fg='orange', bg='#2B2B2B', bd=0).place(x=85, y=80) self.req = Label(root, text='*', fg='orange', bg='#2B2B2B', bd=0).place(x=100, y=110) self.req = Label(root, text='*', fg='orange', bg='#2B2B2B', bd=0).place(x=85, y=140) self.req = Label(root, text='*', fg='orange', bg='#2B2B2B', bd=0).place(x=95, y=170) self.req = Label(root, text='*', fg='orange', bg='#2B2B2B', bd=0).place(x=70, y=250) self.req = Label(root, text='*', fg='orange', bg='#2B2B2B', bd=0).place(x=70, y=330) vname1 = root.register(self.name1_entry) vname2 = root.register(self.name2_entry) vname3 = root.register(self.name3_entry) vname4 = root.register(self.name4_entry) vyear = root.register(self.year_entry) vtopic = root.register(self.topic_entry) vbook = root.register(self.book_entry) vvolume = root.register(self.volume_entry) vissue = root.register(self.issue_entry) vpage = root.register(self.page_entry) self.iname1 = Entry(root, validate="key", validatecommand=(vname1, '%P'), width=40, bg='#3C3F41', fg='yellow', relief=FLAT, highlightbackground='#2B2B2B', highlightthickness=0.5, highlightcolor='black') self.iname1.place(x=110, y=80) self.iname2 = Entry(root, validate="key", validatecommand=(vname2, '%P'), width=40, bg='#3C3F41', fg='yellow', relief=FLAT, highlightbackground='#2B2B2B', highlightthickness=0.5, highlightcolor='black') self.iname2.place(x=110, y=110) self.iname3 = Entry(root, validate="key", validatecommand=(vname3, '%P'), width=40, bg='#3C3F41', fg='yellow', relief=FLAT, highlightbackground='#2B2B2B', highlightthickness=0.5, highlightcolor='black') self.iname3.place(x=110, y=140) self.iname4 = Entry(root, validate="key", validatecommand=(vname4, '%P'), width=40, bg='#3C3F41', fg='yellow', relief=FLAT, highlightbackground='#2B2B2B', highlightthickness=0.5, highlightcolor='black') self.iname4.place(x=110, y=170) self.year = Entry(root, validate="key", validatecommand=(vyear, '%P'), width=20, bg='#3C3F41', fg='yellow', relief=FLAT, highlightbackground='#2B2B2B', highlightthickness=0.5, highlightcolor='black').place(x=90, y=220) self.topic = Entry(root, validate="key", validatecommand=(vtopic, '%P'), bg='#3C3F41', fg='yellow', relief=FLAT, highlightbackground='#2B2B2B', highlightthickness=0.5, highlightcolor='black').place(width=304, height=70, x=90, y=250) self.book = Entry(root, validate="key", validatecommand=(vbook, '%P'), bg='#3C3F41', fg='yellow', relief=FLAT, highlightbackground='#2B2B2B', highlightthickness=0.5, highlightcolor='black').place(width=304, height=70, x=90, y=330) self.volume = Entry(root, validate="key", validatecommand=(vvolume, '%P'), width=20, bg='#3C3F41', fg='yellow', relief=FLAT, highlightbackground='#2B2B2B', highlightthickness=0.5, highlightcolor='black').place(x=90, y=430) self.issue = Entry(root, validate="key", validatecommand=(vissue, '%P'), width=20, bg='#3C3F41', fg='yellow', relief=FLAT, highlightbackground='#2B2B2B', highlightthickness=0.5, highlightcolor='black').place(x=90, y=460) self.page = Entry(root, validate="key", validatecommand=(vpage, '%P'), width=20, bg='#3C3F41', fg='yellow', relief=FLAT, highlightbackground='#2B2B2B', highlightthickness=0.5, highlightcolor='black').place(x=90, y=490) self.verify_name1.config(text='☐') self.verify_name2.config(text='☐') self.verify_name3.config(text='☐') self.verify_name4.config(text='☐') self.verify_year.config(text='☐') self.verify_volume.config(text='☐') self.verify_issue.config(text='☐') self.verify_page.config(text='☐') self.correctname1 = self.correctname2 = self.correctname3 = self.correctname4 = self.correcttopic = self.correctbook = self.correctyear = self.correctyear = self.correctissue = self.correctpage = ' ' def name1_entry(self, name1): try: if name1 != None: self.name1 = name1 if self.et_al == True: self.name2 = self.name3 = self.name4 = None self.correctname1 = APA.nameAPA(name1, self.name2, self.name3, self.name4) if self.name1 == '': self.verify_name1.config(text='☐', state=DISABLED) else: self.verify_name1.config(text='☑', state=NORMAL) if self.correctname1 != ' ': if (self.correcttopic != ' ' or self.correctbook != ' '): main.name_value = self.correctname1 self.submitbtn.config(state=NORMAL, relief=RAISED) else: self.submitbtn.config(state=DISABLED, relief=RIDGE) print(self.correctname1) main.name_value = self.correctname1 return True else: return False except IndexError: self.name1 = None return True def name2_entry(self, name2): try: if name2 != None: self.name2 = name2 if self.et_al == True: self.name2 = self.name3 = self.name4 = None self.correctname2 = APA.nameAPA(self.name1, name2, self.name3, self.name4) if self.name2 == '': self.verify_name2.config(text='☐', state=DISABLED) else: self.verify_name2.config(text='☑', state=NORMAL) if self.correctname2 != ' ': if (self.correcttopic != ' ' or self.correctbook != ' '): main.name_value = self.correctname2 self.submitbtn.config(state=NORMAL, relief=RAISED) else: self.submitbtn.config(state=DISABLED, relief=RIDGE) main.name_value = self.correctname2 print(self.correctname2) return True else: return False except IndexError: self.name2 = None return True def name3_entry(self, name3): try: if name3 != None: self.name3 = name3 if self.et_al == True: self.name2 = self.name3 = self.name4 = None self.correctname3 = APA.nameAPA(self.name1, self.name2, name3, self.name4) if self.name3 == '': self.verify_name3.config(text='☐', state=DISABLED) else: self.verify_name3.config(text='☑', state=NORMAL) if (self.correcttopic != ' ' and self.correctbook != ' '): main.name_value = self.correctname3 self.submitbtn.config(state=NORMAL, relief=RAISED) else: self.submitbtn.config(state=DISABLED, relief=RIDGE) main.name_value = self.correctname3 print(self.correctname3) return True else: return False except IndexError: self.name3 = None return True def name4_entry(self, name4): try: if name4 != None: self.name4 = name4 if self.et_al == True: self.name2 = self.name3 = self.name4 = None self.correctname4 = APA.nameAPA(self.name1, self.name2, self.name3, name4) if self.name4 == '': self.verify_name4.config(text='☐', state=DISABLED) else: self.verify_name4.config(text='☑', state=NORMAL) if (self.correcttopic != ' ' and self.correctbook != ' '): main.name_value = self.correctname4 self.submitbtn.config(state=NORMAL, relief=RAISED) else: self.submitbtn.config(state=DISABLED, relief=RIDGE) main.name_value = self.correctname4 print(self.correctname4) return True else: return False except IndexError: self.name4 = None return True def year_entry(self, year): try: if year != None: main.year_value = '' self.year = year self.correctyear = APA.yearAPA(year) if self.correctyear == 'Invalid Year': self.verify_year.config(text='☒', fg='#8B0000', state=NORMAL) else: self.verify_year.config(text='☑', fg='green', state=NORMAL) main.year_value = self.correctyear print(self.correctyear) self.year = '' return True else: return False except IndexError: self.verify_year.config(text='☐', state=DISABLED) return True def topic_entry(self, topic): try: if topic != None: self.topic = topic self.correcttopic = APA.topicAPA(topic) if self.correcttopic != 'Err(Low)': if (self.correctname1 != ' ' or self.correctname2 != ' ' or self.correctname3 != ' ' or self.correctname4 != ' '): if self.correctbook != ' ': main.topic_value = self.correcttopic self.submitbtn.config(state=NORMAL, relief=RAISED) else: self.submitbtn.config(state=DISABLED, relief=RIDGE) main.topic_value = self.correcttopic print(self.correcttopic) return True else: self.submitbtn.config(state=DISABLED) return False except IndexError: self.topic = None return True def book_entry(self, book): try: if book != None: self.book = book self.correctbook = APA.bookAPA(book) if self.correctbook != 'Err(Low)': if (self.correctname1 != ' ' or self.correctname2 != ' ' or self.correctname3 != ' ' or self.correctname4 != ' ' and self.correcttopic != ' '): main.book_value = self.correctbook self.submitbtn.config(state=NORMAL, relief=RAISED) else: self.submitbtn.config(state=DISABLED, relief=RIDGE) main.book_value = self.correctbook print(self.correctbook) return True else: return False except: return True def volume_entry(self, volume): try: if volume != None: self.volume = volume self.correctvolume = APA.volumeAPA(volume) if self.correctvolume == 'Invalid Volume': self.verify_volume.config(text='☒', fg='#8B0000', state=NORMAL) main.volume_value = '' elif self.correctvolume == '': self.verify_volume.config(text='☐', state=DISABLED) main.volume_value = '' else: self.verify_volume.config(text='☑', fg='green', state=NORMAL) main.volume_value = self.correctvolume print(self.correctvolume) return True else: return False except IndexError: self.verify_volume.config(text='☐', state=DISABLED) return True def issue_entry(self, issue): try: if issue != None: self.issue = issue self.correctissue = APA.issueAPA(issue) if self.correctissue == 'Invalid Issue': self.verify_issue.config(text='☒', fg='#8B0000', state=NORMAL) main.issue_value = '' elif self.correctissue == '': self.verify_issue.config(text='☐', state=DISABLED) main.issue_value = '' else: self.verify_issue.config(text='☑', fg='green', state=NORMAL) main.issue_value = self.correctissue print(self.correctissue) return True else: return False except IndexError: return True def page_entry(self, page): try: if page != None: self.page = page self.correctpage = APA.pageAPA(page) if self.correctpage == 'Invalid Page': self.verify_page.config(text='☒', fg='#8B0000', state=NORMAL) main.page_value = '' elif self.correctpage == '': self.verify_page.config(text='☐', state=DISABLED) main.page_value = '' else: self.verify_page.config(text='☑', fg='green', state=NORMAL) main.page_value = self.correctpage print(self.correctpage) return True else: return False except IndexError: return True def enter_txt(self): if self.et_al == False: total_txt = main.name_value + main.year_value + main.topic_value + main.book_value + main.volume_value + main.issue_value + main.page_value + '\n' + '\n' elif self.et_al == True: total_txt = main.name_value + 'et.al. ' + main.year_value + main.topic_value + main.book_value + main.volume_value + main.issue_value + main.page_value + '\n' + '\n' APA_txt.set_txt(total_txt) APA_inputs.__init__(root) self.savebtn.config(state=NORMAL, relief=RAISED) def hide_names(self): self.et_al = True self.correctname1 = self.correctname2 = self.correctname3 = self.correctname4 = ' ' self.name1 = self.iname1.get() APA_inputs.name1_entry(self.name1) self.iname2.config(state=DISABLED, disabledbackground='#4F4B41') self.iname3.config(state=DISABLED, disabledbackground='#4F4B41') self.iname4.config(state=DISABLED, disabledbackground='#4F4B41') self.etal = Checkbutton(root, text='Et.al?', bg='#2B2B2B', fg='orange', font='bold 12', bd=0, activebackground='#2B2B2B', activeforeground='orange', command=lambda: [APA_inputs.show_names()]) self.etal.select() self.etal.place(x=110, y=195) def show_names(self): self.et_al = False self.iname2.config(state=NORMAL) self.iname3.config(state=NORMAL) self.iname4.config(state=NORMAL) self.name1 = self.iname1.get() self.name2 = self.iname2.get() self.name3 = self.iname3.get() self.name4 = self.iname4.get() APA_inputs.name1_entry(self.name1) APA_inputs.name2_entry(self.name2) APA_inputs.name3_entry(self.name3) APA_inputs.name4_entry(self.name4) self.etal = Checkbutton(root, text='Et.al?', bg='#2B2B2B', fg='orange', font='bold 12', bd=0, activebackground='#2B2B2B', activeforeground='orange', command=lambda: [APA_inputs.hide_names()]) self.etal.deselect() self.etal.place(x=110, y=195)
class ViewMac: main_view = "" current_mac = "" accepted_characters = [ 'a', 'b', 'c', 'd', 'e', 'f', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', ':' ] def __init__(self, view, spoofing_status): self.main_view = view self.spoofing_status = spoofing_status self.build_window() self.popup_gen = PopUpWindow() self.set_spoofing_checkbutton() self.root.mainloop() def build_window(self): """ Generates the window. :author: Pablo Sanz Alguacil """ self.root = Toplevel() self.root.protocol("WM_DELETE_WINDOW", self.destroy_window) self.root.geometry('440x490') self.root.resizable(width=False, height=False) self.root.title('WiCC - Mac Changer Tools') # LABELFRAME - INFO self.labelframe_info = LabelFrame(self.root, text="") self.labelframe_info.pack(fill="both", expand="no", pady=15) # LABEL - INFO self.label_info = Label( self.labelframe_info, pady=15, text="In this window you can change your MAC as you want by" "\nusing one this options. A great power comes with a" "\ngreat responsibility") self.label_info.pack(side=TOP) # LABELFRAME - CUSTOM MAC self.labelframe_custom_mac = LabelFrame(self.root, text="Write custom MAC") self.labelframe_custom_mac.pack(fill="both", expand="no", pady=10) # LABEL - CUSTOM MAC self.label_custom_mac = Label(self.labelframe_custom_mac, text="Custom MAC: ") self.label_custom_mac.grid(column=1, row=0, padx=5) # ENTRY - CUSTOM MAC self.entry_custom_mac = ttk.Entry(self.labelframe_custom_mac) self.entry_custom_mac.grid(column=2, row=0, padx=8) self.entry_custom_mac.bind('<Button-3>', rClicker, add='') # BUTTON - CUSTOM MAC self.button_custom_mac = ttk.Button(self.labelframe_custom_mac, text="Set custom MAC", command=self.customize_mac) self.button_custom_mac.grid(column=4, row=0) # LABELFRAME - RANDOM MAC self.labelframe_random_mac = LabelFrame(self.root, text="Randomize MAC") self.labelframe_random_mac.pack(fill="both", expand="no", pady=10) # LABEL - RANDOM MAC self.label_random_mac = Label( self.labelframe_random_mac, text="Changes the current MAC to a completly \nrandom MAC", justify=LEFT) self.label_random_mac.grid(column=1, row=0, rowspan=2, padx=5) # BUTTON - RANDOM MAC self.button_random_mac = ttk.Button(self.labelframe_random_mac, text="Randomize MAC", command=self.randomize_mac) self.button_random_mac.grid(column=3, row=0, padx=5) # LABELFRAME - RESTORE ORIGINAL self.labelframe_restore_original = LabelFrame( self.root, text="Restore original MAC") self.labelframe_restore_original.pack(fill="both", expand="no", pady=10) # LABEL - RESTORE ORIGINAL self.label_restore_original = Label( self.labelframe_restore_original, text="Restores the original selected interface's\nMAC address", justify=LEFT) self.label_restore_original.grid(column=1, row=0, padx=5) # BUTTON - RESTORE ORIGINAL self.button_restore_original = ttk.Button( self.labelframe_restore_original, text="Restore MAC", command=self.restore_mac) self.button_restore_original.grid(column=3, row=0, padx=5) # LABELFRAME - MAC SPOOFING self.labelframe_mac_spoofing = LabelFrame(self.root, text="MAC spoofing") self.labelframe_mac_spoofing.pack(fill="both", expand="no", pady=10) # LABEL - MAC SPOOFING) self.label_mac_spoofing = Label( self.labelframe_mac_spoofing, text="Spoof client's MAC address during attack") self.label_mac_spoofing.grid(column=1, row=0, padx=5) # CHECKBUTTON - MAC SPOOFING self.checkbutton_mac_spoofing = Checkbutton( self.labelframe_mac_spoofing, text="Active", command=self.mac_spoofing) self.checkbutton_mac_spoofing.grid(column=3, row=0, padx=5) # BUTTON - DONE self.button_done = ttk.Button(self.root, text="Done", command=self.destroy_window) self.button_done.pack(padx=15, pady=15) def customize_mac(self): """ Sends an order to the main view to set the MAC address to the sended one. Filters the address before send it (only hexadecimal values). :author: Pablo Sanz Alguacil """ address = self.entry_custom_mac.get().lower() colon_count = 0 address_length = len(self.entry_custom_mac.get()) address_splited = list(address) boolean_fg = True for character in address_splited: if character in self.accepted_characters and address_length == 17: if character == ":": colon_count = colon_count + 1 else: boolean_fg = False if boolean_fg and colon_count == 5: self.notify_view(0, self.entry_custom_mac.get()) else: self.popup_gen.warning("Warning", "Address not valid") def randomize_mac(self): """ Sends an order to the main view to randomize the MAC address. :author: Pablo Sanz Alguacil """ self.notify_view(1, "") def restore_mac(self): """ Sends an order to the main view to restore the original MAC address. :author: Pablo Sanz Alguacil """ self.notify_view(2, "") def set_spoofing_checkbutton(self): """ Selects or deselcts the MAC spoofing checkbutton. :author: Pablo Sanz Alguacil """ if self.spoofing_status: self.checkbutton_mac_spoofing.select() else: self.checkbutton_mac_spoofing.deselect() def mac_spoofing(self): """ Sends an order to the main view to set the MAC spoofing status. Saves the status in a local variable. :author: Pablo Sanz Alguacil """ if self.spoofing_status: self.spoofing_status = False self.notify_view(3, False) else: self.spoofing_status = True self.notify_view(3, True) def notify_view(self, operation, value): """ Operation values (int) [0] Custom mac [1] Random mac [2] Restore mac [3] Mac spoofing Sends and operation and value to the main view. :param self: :param operation: integer :param value: object :author: Pablo Sanz Alguacil """ self.main_view.get_notify_childs(operation, value) def destroy_window(self): """ Enables all buttons in the main window and destroys this window. :author: Pablo Sanz Alguacil """ self.main_view.disable_window(False) self.root.destroy()
def make_changable(self, name, row_id, kind='text', preVals=None): relation = StringVar() pattern = StringVar() change = StringVar() changeTo = StringVar() relMenu = OptionMenu(self.diagFrame, relation, *StringComparison.options) relMenu.grid(row=row_id, column=1, sticky=W) patEntry = Entry(self.diagFrame, textvariable=pattern) patEntry.grid(row=row_id, column=2, sticky=W) if self.entry and hasattr(self.entry, name): inString = getattr(self.entry, name) else: inString = '' chMenu = OptionMenu(self.diagFrame, change, *StringModification.options, command=self.possibleDialog(changeTo, inString)) chMenu.grid(row=row_id, column=3, sticky=W) if name == 'account': chVal = CustomMenubutton(self.diagFrame, self.ledger, self.entry, textvariable=changeTo, indicatoron=True) else: chVal = Entry(self.diagFrame, textvariable=changeTo) chVal.grid(row=row_id, column=4, sticky=W) settableItems = [relMenu, patEntry, chMenu, chVal] checkVar = IntVar() command = self.getCheckcommand(checkVar, settableItems) label = Checkbutton(self.diagFrame, text=name.title(), variable=checkVar, onvalue=True, offvalue=False, command=command) label.grid(row=row_id, column=0, sticky=E + W) if not preVals: label.deselect() else: if not preVals['pattern']: label.deselect() else: label.select() command() if preVals: if 'relation' in preVals: relation.set(preVals['relation']) if 'pattern' in preVals: pattern.set(preVals['pattern']) if 'change' in preVals: change.set(preVals['change']) if 'changeTo' in preVals: changeTo.set(preVals['changeTo']) return checkVar, relation, pattern, change, changeTo
class PlotManager: def __init__(self, controller: utils.ControllerType): self.controller = controller self.plotter = self.controller.plotter self.config_info = controller.config_info self.tk_format = utils.TkFormat(self.controller.config_info) try: with open(self.config_info.local_config_loc + "plot_config.txt", "r") as plot_config: self.plot_local_remote = plot_config.readline().strip("\n") self.plot_input_file = plot_config.readline().strip("\n") self.dataset_name = plot_config.readline().strip("\n") except OSError: print("No past plotting location found. Using default.") with open(self.config_info.local_config_loc + "plot_config.txt", "w+") as f: f.write("remote") f.write("C:\\Users\n") f.write("C:\\Users\n") self.plot_local_remote = "remote" self.dataset_name = "" self.plot_input_file = "C:\\Users" self.plot_remote = IntVar() self.plot_local = IntVar() if self.plot_local_remote == "remote": self.plot_remote.set(1) self.plot_local.set(0) else: self.plot_local.set(1) self.plot_remote.set(0) self.plot_local_check = None self.plot_remote_check = None self.dataset_name_entry = None self.plot_input_dir_entry = None self.plot_top = None def show(self) -> None: self.plot_top = Toplevel(self.controller.master) self.plot_top.wm_title("Plot") plot_frame = Frame(self.plot_top, bg=self.tk_format.bg, pady=2 * self.tk_format.pady, padx=15) plot_frame.pack() dataset_name_label = Label( plot_frame, padx=self.tk_format.padx, pady=self.tk_format.pady, bg=self.tk_format.bg, fg=self.tk_format.textcolor, text="Dataset name:", ) dataset_name_label.pack(padx=self.tk_format.padx, pady=(15, 5)) self.dataset_name_entry = Entry( plot_frame, width=50, bd=self.tk_format.bd, bg=self.tk_format.entry_background, selectbackground=self.tk_format.selectbackground, selectforeground=self.tk_format.selectforeground, ) self.dataset_name_entry.insert(0, self.dataset_name) self.dataset_name_entry.pack(pady=(5, 20)) plot_local_remote_frame = Frame(plot_frame, bg=self.tk_format.bg) plot_local_remote_frame.pack() plot_input_dir_label = Label( plot_local_remote_frame, padx=self.tk_format.padx, pady=self.tk_format.pady, bg=self.tk_format.bg, fg=self.tk_format.textcolor, text="Path to .csv file:", ) plot_input_dir_label.pack(side=LEFT, padx=self.tk_format.padx, pady=self.tk_format.pady) self.plot_local_check = Checkbutton( plot_local_remote_frame, fg=self.tk_format.textcolor, text=" Local", selectcolor=self.tk_format.check_bg, bg=self.tk_format.bg, pady=self.tk_format.pady, variable=self.plot_local, highlightthickness=0, highlightbackground=self.tk_format.bg, command=self.local_plot_cmd, ) self.plot_local_check.pack(side=LEFT, pady=(5, 5), padx=(5, 5)) self.plot_remote_check = Checkbutton( plot_local_remote_frame, fg=self.tk_format.textcolor, text=" Remote", bg=self.tk_format.bg, pady=self.tk_format.pady, highlightthickness=0, variable=self.plot_remote, command=self.remote_plot_cmd, selectcolor=self.tk_format.check_bg, ) self.plot_remote_check.pack(side=LEFT, pady=(5, 5), padx=(5, 5)) # controls whether the file being plotted is looked for locally or on the spectrometer computer if self.plot_local_remote == "remote": self.plot_remote_check.select() self.plot_local_check.deselect() if self.plot_local_remote == "local": self.plot_local_check.select() self.plot_remote_check.deselect() plot_file_frame = Frame(plot_frame, bg=self.tk_format.bg) plot_file_frame.pack(pady=(5, 10)) plot_file_browse_button = Button(plot_file_frame, text="Browse", command=self.choose_plot_file) plot_file_browse_button.config( fg=self.tk_format.buttontextcolor, highlightbackground=self.tk_format.highlightbackgroundcolor, bg=self.tk_format.buttonbackgroundcolor, ) plot_file_browse_button.pack(side=RIGHT, padx=self.tk_format.padx) self.plot_input_dir_entry = Entry( plot_file_frame, width=50, bd=self.tk_format.bd, bg=self.tk_format.entry_background, selectbackground=self.tk_format.selectbackground, selectforeground=self.tk_format.selectforeground, ) self.plot_input_dir_entry.insert(0, self.plot_input_file) self.plot_input_dir_entry.pack(side=RIGHT) plot_button_frame = Frame(plot_frame, bg=self.tk_format.bg) plot_button_frame.pack() plot_button = Button( plot_button_frame, fg=self.tk_format.textcolor, text="Plot", padx=self.tk_format.padx, pady=self.tk_format.pady, width=int(self.tk_format.button_width * 1.3), bg="light gray", command=self.plot_button_cmd, ) plot_button.config( fg=self.tk_format.buttontextcolor, highlightbackground=self.tk_format.highlightbackgroundcolor, bg=self.tk_format.buttonbackgroundcolor, ) plot_button.pack(side=LEFT, pady=(20, 20), padx=(15, 15)) process_close_button = Button( plot_button_frame, fg=self.tk_format.buttontextcolor, highlightbackground=self.tk_format.highlightbackgroundcolor, text="Close", padx=self.tk_format.padx, pady=self.tk_format.pady, width=int(self.tk_format.button_width * 1.3), bg=self.tk_format.buttonbackgroundcolor, command=self.close_plot, ) process_close_button.pack(pady=(20, 20), padx=(15, 15), side=LEFT) def close_plot(self) -> None: self.plot_top.destroy() # Toggle back and forth between plotting your data from a remote or local file def local_plot_cmd(self) -> None: if self.plot_local.get() and not self.plot_remote.get(): return if self.plot_remote.get() and not self.plot_local.get(): return if not self.plot_remote.get(): self.plot_remote_check.select() else: self.plot_remote_check.deselect() self.plot_input_dir_entry.delete(0, END) # Toggle back and forth between plotting your data from a remote or local file def remote_plot_cmd(self) -> None: if self.plot_local.get() and not self.plot_remote.get(): return if self.plot_remote.get() and not self.plot_local.get(): return if not self.plot_local.get(): self.plot_local_check.select() else: self.plot_local_check.deselect() self.plot_input_dir_entry.delete(0, END) def choose_plot_file(self) -> None: init_file = self.plot_input_dir_entry.get() relative_file = init_file.split("/")[-1].split("\\")[-1] init_dir = init_file.strip(relative_file) if self.plot_remote.get(): RemoteFileExplorer( self.controller, target=self.plot_input_dir_entry, title="Select a file", label="Select a file to plot", directories_only=False, ) else: if os.path.isdir(init_dir): file = askopenfilename(initialdir=init_dir, title="Select a file to plot") else: file = askopenfilename(initialdir=os.getcwd(), title="Select a file to plot") if file != (): self.plot_input_dir_entry.delete(0, "end") self.plot_input_dir_entry.insert(0, file) self.plot_top.lift() def plot_button_cmd(self) -> None: plot_input_file = self.plot_input_dir_entry.get() if ( self.plotter.save_dir is None ): # If the user hasn't specified a folder where they want to save plots yet, set the default folder to be # the same one they got the data from. Otherwise, leave it as is. if self.config_info.opsys == "Windows": self.plotter.save_dir = "\\".join( plot_input_file.split("\\")[0:-1]) else: self.plotter.save_dir = "/".join( plot_input_file.split("/")[0:-1]) self.dataset_name = self.dataset_name_entry.get() if self.plot_remote.get(): self.plot_local_remote = "remote" elif self.plot_local.get(): self.plot_local_remote = "local" try: with open(self.config_info.local_config_loc + "plot_config.txt", "w") as plot_config: plot_config.write(self.plot_local_remote + "\n") plot_config.write(plot_input_file + "\n") plot_config.write(self.dataset_name + "\n") except OSError: print("Error saving data location for plots.") self.plot_top.destroy() if self.plot_local_remote == "remote": self.controller.plot_remote(plot_input_file) else: self.plot(plot_input_file) def plot(self, plot_input_file): if len(self.controller.queue) > 0: if self.plot in self.controller.queue[0]: # Happens if we just transferred data from spec compy. self.controller.complete_queue_item() self.controller.wait_dialog.top.destroy() try: data_loaded = self.plotter.load_samples(self.dataset_name, plot_input_file) if not data_loaded: ErrorDialog(self.controller, "Error", "Error: Could not load data.") print("Error: Could not load data.") # pylint: disable = broad-except except (IndexError, KeyError, Exception): Dialog( self.controller, "Plotting Error", "Error: Plotting failed.\n\nDoes file exist? Is data formatted correctly?\nIf plotting a remote file," " is the server accessible?", {"ok": {}}, ) return self.plotter.new_tab()
class ProcessManager: def __init__(self, controller: utils.ControllerType): # The commander is in charge of sending all the commands for the spec compy to read # If the user has saved spectra with this program before, load in their previously used directories. self.controller = controller self.config_info = controller.config_info self.remote_directory_worker = controller.remote_directory_worker self.tk_format = utils.TkFormat(self.controller.config_info) self.process_input_dir = "" self.process_output_dir = "" # TODO: saving a spectrum should result in that directory being set # as the process directory next time the program opens. try: with open( self.config_info.local_config_loc + "process_directories.txt", "r") as process_config: self.proc_local_remote = process_config.readline().strip("\n") self.process_input_dir = process_config.readline().strip("\n") self.process_output_dir = process_config.readline().strip("\n") except OSError: with open( self.config_info.local_config_loc + "process_directories.txt", "w+") as f: f.write("remote") f.write("C:\\Users\n") f.write("C:\\Users\n") self.proc_local_remote = "remote" self.proc_input_dir = "C:\\Users" self.proc_output_dir = "C:\\Users" self.proc_remote = IntVar() self.proc_local = IntVar() if self.proc_local_remote == "remote": self.proc_remote.set(1) self.proc_local.set(0) else: self.proc_local.set(1) self.proc_remote.set(0) self.process_save_dir = IntVar() self.input_dir_var = StringVar() self.process_top = None self.input_dir_entry = None self.proc_local_check = None self.proc_remote_check = None self.output_dir_entry = None self.output_file_entry = None self.process_save_dir_check = None def show(self) -> None: self.process_top = Toplevel(self.controller.master) self.process_top.wm_title("Process Data") process_frame = Frame(self.process_top, bg=self.tk_format.bg, pady=15, padx=15) process_frame.pack() input_dir_label = Label( process_frame, padx=self.tk_format.padx, pady=self.tk_format.pady, bg=self.tk_format.bg, fg=self.tk_format.textcolor, text="Raw spectral data input directory:", ) input_dir_label.pack(padx=self.tk_format.padx, pady=(10, 5)) input_frame = Frame(process_frame, bg=self.tk_format.bg) input_frame.pack() process_input_browse_button = Button( input_frame, text="Browse", command=self.choose_process_input_dir) process_input_browse_button.config( fg=self.tk_format.buttontextcolor, highlightbackground=self.tk_format.highlightbackgroundcolor, bg=self.tk_format.buttonbackgroundcolor, ) process_input_browse_button.pack(side=RIGHT, padx=self.tk_format.padx) self.input_dir_var.trace("w", self.validate_input_dir) self.input_dir_entry = Entry( input_frame, width=50, bd=self.tk_format.bd, textvariable=self.input_dir_var, bg=self.tk_format.entry_background, selectbackground=self.tk_format.selectbackground, selectforeground=self.tk_format.selectforeground, ) if len(self.input_dir_entry.get()) == 0: self.input_dir_entry.insert(0, self.process_input_dir) self.input_dir_entry.pack(side=RIGHT, padx=self.tk_format.padx, pady=self.tk_format.pady) proc_local_remote_frame = Frame(process_frame, bg=self.tk_format.bg) proc_local_remote_frame.pack() output_dir_label = Label( proc_local_remote_frame, padx=self.tk_format.padx, pady=self.tk_format.pady, bg=self.tk_format.bg, fg=self.tk_format.textcolor, text="Processed data output directory:", ) output_dir_label.pack(padx=self.tk_format.padx, pady=(10, 5), side=LEFT) self.proc_local_check = Checkbutton( proc_local_remote_frame, fg=self.tk_format.textcolor, text=" Local", selectcolor=self.tk_format.check_bg, bg=self.tk_format.bg, pady=self.tk_format.pady, variable=self.proc_local, highlightthickness=0, highlightbackground=self.tk_format.bg, command=self.local_process_cmd, ) self.proc_local_check.pack(side=LEFT, pady=(5, 0), padx=(5, 5)) if self.proc_local_remote == "local": self.proc_local_check.select() self.proc_remote_check = Checkbutton( proc_local_remote_frame, fg=self.tk_format.textcolor, text=" Remote", bg=self.tk_format.bg, pady=self.tk_format.pady, highlightthickness=0, variable=self.proc_remote, command=self.remote_process_cmd, selectcolor=self.tk_format.check_bg, ) self.proc_remote_check.pack(side=LEFT, pady=(5, 0), padx=(5, 5)) if self.proc_local_remote == "remote": self.proc_remote_check.select() process_output_frame = Frame(process_frame, bg=self.tk_format.bg) process_output_frame.pack(pady=(5, 10)) process_output_browse_button = Button( process_output_frame, text="Browse", command=self.choose_process_output_dir) process_output_browse_button.config( fg=self.tk_format.buttontextcolor, highlightbackground=self.tk_format.highlightbackgroundcolor, bg=self.tk_format.buttonbackgroundcolor, ) process_output_browse_button.pack(side=RIGHT, padx=self.tk_format.padx) self.output_dir_entry = Entry( process_output_frame, width=50, bd=self.tk_format.bd, bg=self.tk_format.entry_background, selectbackground=self.tk_format.selectbackground, selectforeground=self.tk_format.selectforeground, ) self.output_dir_entry.insert(0, self.process_output_dir) self.output_dir_entry.pack(side=RIGHT, padx=self.tk_format.padx, pady=self.tk_format.pady) output_file_label = Label( process_frame, padx=self.tk_format.padx, pady=self.tk_format.pady, bg=self.tk_format.bg, fg=self.tk_format.textcolor, text="Output file name:", ) output_file_label.pack(padx=self.tk_format.padx, pady=self.tk_format.pady) self.output_file_entry = Entry( process_frame, width=50, bd=self.tk_format.bd, bg=self.tk_format.entry_background, selectbackground=self.tk_format.selectbackground, selectforeground=self.tk_format.selectforeground, ) self.output_file_entry.pack() process_check_frame = Frame(process_frame, bg=self.tk_format.bg) process_check_frame.pack(pady=(15, 5)) self.process_save_dir_check = Checkbutton( process_check_frame, selectcolor=self.tk_format.check_bg, fg=self.tk_format.textcolor, text="Save file configuration", bg=self.tk_format.bg, pady=self.tk_format.pady, highlightthickness=0, variable=self.process_save_dir, ) self.process_save_dir_check.select() process_button_frame = Frame(process_frame, bg=self.tk_format.bg) process_button_frame.pack() process_button = Button( process_button_frame, fg=self.tk_format.textcolor, text="Process", padx=self.tk_format.padx, pady=self.tk_format.pady, width=int(self.tk_format.button_width * 1.3), bg="light gray", command=self.controller.process_cmd, ) process_button.config( fg=self.tk_format.buttontextcolor, highlightbackground=self.tk_format.highlightbackgroundcolor, bg=self.tk_format.buttonbackgroundcolor, ) process_button.pack(padx=(15, 15), side=LEFT) process_close_button = Button( process_button_frame, fg=self.tk_format.buttontextcolor, highlightbackground=self.tk_format.highlightbackgroundcolor, text="Close", padx=self.tk_format.padx, pady=self.tk_format.pady, width=int(self.tk_format.button_width * 1.3), bg=self.tk_format.buttonbackgroundcolor, command=self.close_process, ) process_close_button.pack(padx=(15, 15), side=LEFT) # Closes process frame def close_process(self) -> None: self.process_top.destroy() # Toggle back and forth between saving your processed data remotely or locally def local_process_cmd(self) -> None: if self.proc_local.get() and not self.proc_remote.get(): return if self.proc_remote.get() and not self.proc_local.get(): return if not self.proc_remote.get(): self.proc_remote_check.select() else: self.proc_remote_check.deselect() self.proc_local_remote = "local" self.output_dir_entry.delete(0, "end") # Toggle back and forth between saving your processed data remotely or locally def remote_process_cmd(self) -> None: if self.proc_local.get() and not self.proc_remote.get(): return if self.proc_remote.get() and not self.proc_local.get(): return if not self.proc_local.get(): self.proc_local_check.select() else: self.proc_local_check.deselect() self.proc_local_remote = "remote" self.output_dir_entry.delete(0, "end") def choose_process_output_dir(self) -> None: init_dir: str = self.output_dir_entry.get() if self.proc_remote.get(): RemoteFileExplorer( self.controller, target=self.output_dir_entry, title="Select a directory", label="Select an output directory for processed data.", directories_only=True, ) else: self.process_top.lift() if os.path.isdir(init_dir): output_dir = askdirectory(initialdir=init_dir, title="Select an output directory") else: output_dir = askdirectory(initialdir=os.getcwd(), title="Select an output directory") if output_dir != (): self.output_dir_entry.delete(0, "end") self.output_dir_entry.insert(0, output_dir) self.process_top.lift() def setup_process(self) -> Tuple[str, str, str]: output_file: str = self.output_file_entry.get() if output_file == "": ErrorDialog(self.controller, label="Error: Enter an output file name") raise ProcessFileError if output_file[-4:] != ".csv": output_file = output_file + ".csv" self.output_file_entry.insert("end", ".csv") input_directory = self.input_dir_entry.get() if input_directory[-1] == "\\": input_directory = input_directory[:-1] output_directory = self.output_dir_entry.get() if self.process_save_dir.get(): file = open( self.config_info.local_config_loc + "process_directories.txt", "w+") file.write(self.proc_local_remote + "\n") file.write(input_directory + "\n") file.write(output_directory + "\n") file.write(output_file + "\n") file.close() if self.proc_local.get() == 1: self.controller.plot_manager.plot_local_remote = "local" check = self.check_local_file(self.output_dir_entry.get(), output_file, self.controller.process_cmd) if not check: raise ProcessFileError # If the file exists, controller.check_local_file_exists # gives the user the option to overwrite, in which case process_cmd gets called again. check = self.check_local_folder(output_directory, self.controller.process_cmd) if not check: raise ProcessFileError # Same deal for the folder (except existing is good). self.controller.plot_manager.plot_local_remote = "local" return input_directory, output_directory, output_file if self.proc_local.get() == 0: check = self.check_remote_folder(output_directory, self.controller.process_cmd) if not check: raise ProcessFileError self.controller.plot_manager.plot_local_remote = "remote" return input_directory, output_directory, output_file def finish_processing(self) -> Tuple[str, str]: return # #TODO: final_data_destination seems to just become log base? # final_data_destination: str = self.output_file_entry.get() # if "." not in final_data_destination: # final_data_destination = final_data_destination + ".csv" # data_base: str = ".".join(final_data_destination.split(".")[0:-1]) # # if self.config_info.opsys in ("Linux", "Mac"): # final_data_destination: str = self.output_dir_entry.get() + "/" + final_data_destination # log_base: str = self.output_dir_entry.get() + "/" + data_base + "_log" # else: # final_data_destination: str = self.output_dir_entry.get() + "\\" + final_data_destination # log_base: str = self.output_dir_entry.get() + "\\" + data_base + "_log" # # final_log_destination: str = log_base # i = 1 # while os.path.isfile(final_log_destination + ".txt"): # final_log_destination = log_base + "_" + str(i) # i += 1 # final_log_destination += ".txt" # # return final_data_destination, final_log_destination def check_local_file(self, directory: str, local_file: str, next_action: Any) -> bool: def remove_retry(file, action): try: os.remove(file) action() except OSError: ErrorDialog(self.controller, title="Error overwriting file", label="Error: Could not delete file.\n\n" + file) if self.config_info.opsys in ("Linux", "Mac"): if directory[-1] != "/": directory += "/" else: if directory[-1] != "\\": directory += "\\" full_process_output_path = directory + local_file if os.path.exists(full_process_output_path): buttons = { "yes": { remove_retry: [full_process_output_path, next_action] }, "no": {} } dialog = Dialog( self.controller, title="Error: File Exists", label="Error: Specified output file already exists.\n\n" + full_process_output_path + "\n\nDo you want to overwrite this data?", buttons=buttons, ) width = len(full_process_output_path) * 5 + 100 dialog.top.wm_geometry(f"{width}x160") return False return True def check_local_folder(self, local_dir: str, next_action: Any) -> bool: def try_mk_dir(dir_to_make: str, action: Any) -> None: try: os.makedirs(dir_to_make) action() except OSError: ErrorDialog(self.controller, title="Cannot create directory", label="Cannot create directory:\n\n" + dir_to_make) exists = os.path.exists(local_dir) if exists: # If the file exists, try creating and deleting a new file there to make sure we have permission. try: if self.config_info.opsys in ("Linux", "Mac"): if local_dir[-1] != "/": local_dir += "/" else: if local_dir[-1] != "\\": local_dir += "\\" existing = os.listdir(local_dir) i = 0 delme = "delme" + str(i) while delme in existing: i += 1 delme = "delme" + str(i) os.mkdir(local_dir + delme) os.rmdir(local_dir + delme) return True except OSError: ErrorDialog( self.controller, title="Error: Cannot write", label="Error: Cannot write to specified directory.\n\n" + local_dir, ) return False else: if ( self.controller.script_running ): # If we're running a script, just try making the directory automatically. try_mk_dir(local_dir, next_action) else: # Otherwise, ask the user. buttons = { "yes": { try_mk_dir: [local_dir, next_action] }, "no": {} } ErrorDialog( self.controller, title="Directory does not exist", label=local_dir + "\n\ndoes not exist. Do you want to create this directory?", buttons=buttons, ) # TODO: check these return statements make sense. return exists # Checks if the given directory exists and is writeable. If not writeable, gives user option to create. def check_remote_folder(self, remote_dir: str, next_action: Any) -> bool: print(remote_dir) def inner_mkdir(dir_to_make: str, action: Any): mkdir_status = self.remote_directory_worker.mkdir(dir_to_make) print("MKDIR STATUS!!") print(mkdir_status) if mkdir_status == "mkdirsuccess": action() elif mkdir_status == "mkdirfailedfileexists": ErrorDialog( self.controller, title="Error", label="Could not create directory:\n\n" + dir_to_make + "\n\nFile exists.", ) elif mkdir_status == "mkdirfailedpermission": ErrorDialog( self.controller, title="Error", label="Could not create directory:\n\n" + dir_to_make + "\n\nPermission denied.", ) elif "mkdirfailed" in mkdir_status: ErrorDialog(self.controller, title="Error", label="Could not create directory:\n\n" + dir_to_make) status = self.remote_directory_worker.get_dirs(remote_dir) if status == "listdirfailed": buttons = { "yes": { inner_mkdir: [remote_dir, next_action] }, "no": {} } ErrorDialog( self.controller, title="Directory does not exist", label=remote_dir + "\ndoes not exist. Do you want to create this directory?", buttons=buttons, ) return False if status == "listdirfailedpermission": ErrorDialog(self.controller, label="Error: Permission denied for\n" + remote_dir) return False if status == "timeout": if not self.controller.text_only: buttons = { "cancel": {}, "retry": { self.controller.spec_commander.remove_from_listener_queue: [["timeout"]], self.controller.next_in_queue: [], }, } dialog = ErrorDialog( self.controller, label= "Error: Operation timed out.\n\nCheck that the automation script is running on the" " spectrometer\n computer and the spectrometer is connected.", buttons=buttons, ) for button in dialog.tk_buttons: button.config(width=15) else: self.controller.log("Error: Operation timed out.") return False self.controller.spec_commander.check_writeable(remote_dir) t = 3 * utils.BUFFER while t > 0: if "yeswriteable" in self.controller.spec_listener.queue: self.controller.spec_listener.queue.remove("yeswriteable") return True if "notwriteable" in self.controller.spec_listener.queue: self.controller.spec_listener.queue.remove("notwriteable") ErrorDialog( self.controller, label= "Error: Permission denied.\nCannot write to specified directory." ) return False time.sleep(utils.INTERVAL) t = t - utils.INTERVAL if t <= 0: ErrorDialog(self.controller, label="Error: Operation timed out.") return False def choose_process_input_dir(self) -> None: RemoteFileExplorer( self.controller, label= "Select the directory containing the data you want to process.\nThis must be on a drive mounted on" " the spectrometer control computer.\n E.g. R:\\RiceData\\MarsGroup\\YourName\\spectral_data", target=self.input_dir_entry, ) def validate_input_dir(self, *args) -> None: # TODO: understand mystery args. print(args) pos = self.input_dir_entry.index(INSERT) input_dir = utils.rm_reserved_chars(self.input_dir_entry.get()) if len(input_dir) < len(self.input_dir_entry.get()): pos = pos - 1 self.input_dir_entry.delete(0, "end") self.input_dir_entry.insert(0, input_dir) self.input_dir_entry.icursor(pos)
class DistanceFuncFrame(Frame): def __init__(self, parent): Frame.__init__(self, parent) self.parent = parent self.isCalcDistanceMode = BooleanVar() self.isCriticalShortest = BooleanVar() self.cbCalcDistance = Checkbutton( self, variable=self.isCalcDistanceMode, text="calculate distance mode", command=self.on_calc_distance_mode_clicked) self.cbCriticalShortest = Checkbutton(self, variable=self.isCriticalShortest, text="critical") self.cbCalcDistance.deselect() self.cbCriticalShortest.deselect() self.lblStartPos = Label(self) self.lblEndPos = Label(self) self.lblDistance = Label(self) self.firstPosRow = INVALID_ROW self.firstPosCol = INVALID_COL Label(self).pack(expand=1) Label(self).pack(expand=1) self.cbCalcDistance.pack(expand=1) self.cbCriticalShortest.pack(expand=1) self.lblStartPos.pack(expand=1) self.lblEndPos.pack(expand=1) self.lblDistance.pack(expand=1) evtDispatcher.register(EvtIds.EVT_FIRST_POSITION_SELECTED, self.handle_first_position_selected) evtDispatcher.register(EvtIds.EVT_SECOND_POSITION_SELECTED, self.handle_second_position_selected) evtDispatcher.register(EvtIds.EVT_SHORTEST_DISTANCE_CALCULATED, self.handle_shortest_distance_calculated) def handle_first_position_selected(self, content): if content is None or content["row"] is None or content["col"] is None: return self.lblEndPos.config(text="") self.lblDistance.config(text="") self.lblStartPos.config(text="POS1: (%d, %d)" % (content["col"], content["row"])) self.firstPosRow = content["row"] self.firstPosCol = content["col"] def handle_second_position_selected(self, content): if content is None or content["row"] is None or content["col"] is None: return self.lblEndPos.config(text="POS2: (%d, %d)" % (content["col"], content["row"])) self.lblDistance.config(text="calculating...") self.update() evtDispatcher.dispatch( EvtIds.EVT_INFORM_CALC_DISTANCE, { "row1": self.firstPosRow, "col1": self.firstPosCol, "row2": content["row"], "col2": content["col"], "isCriticalShortest": self.isCriticalShortest.get() }) def handle_shortest_distance_calculated(self, content): if content is None or content["distance"] is None: return if content["distance"] == UNREACH_DISTANCE: self.lblDistance.config(text="UNREACHABLE") return res = "Shortest Distance: %d" % content["distance"] if not self.isCriticalShortest.get(): res = "Possible Shortest Distance: %d" % content["distance"] self.lblDistance.config(text=res) def on_calc_distance_mode_clicked(self): if not self.isCalcDistanceMode.get(): self.clean() self.cbCriticalShortest.deselect() evtDispatcher.dispatch(EvtIds.EVT_SET_CALC_DISTANCE_MODE, {"mode": self.isCalcDistanceMode.get()}) def clean(self): self.lblStartPos.config(text="") self.lblEndPos.config(text="") self.lblDistance.config(text="")
def choice_proxy(): global prx def proxy_save(): set_dict = {} if login.get() == '' or password.get() == '': set_dict[ 'http'] = f'"http": "http://{proxy_address.get()}:{port.get()}"' set_dict[ 'https'] = f'"https": "https://{proxy_address.get()}:{port.get()}"' set_dict['login'] = '' set_dict['pass'] = '' set_dict['proxy'] = f'"{prx.get()}"' enc_str = str(set_dict).encode('utf-8') enc_str_b64 = base64.b64encode(enc_str) else: set_dict[ 'http'] = f'"http": "http://{proxy_address.get()}:{port.get()}"' set_dict[ 'https'] = f'"https": "https://{proxy_address.get()}:{port.get()}"' set_dict['login'] = login.get() set_dict['pass'] = password.get() set_dict['proxy'] = f'"{prx.get()}"' enc_str = str(set_dict).encode('utf-8') enc_str_b64 = base64.b64encode(enc_str) egrul_parser_path = create_folders() proxy_settings_path = egrul_parser_path + '/proxy_settings' proxy_settings = open(proxy_settings_path, 'wb') proxy_settings.write(enc_str_b64) proxy_settings.close() pw.destroy() window.deiconify() def on_close_proxy(): pw.destroy() window.deiconify() def change_check(): if prx.get(): prx.set(0) else: prx.set(1) window.withdraw() pw = tk.Tk() width = 300 height = 150 pw.title("Настройки прокси") pw.geometry(f'{str(width)}x{str(height)}') pw.resizable(0, 0) proxy_lbl = Label(pw, text="адрес: ") proxy_lbl.grid(column=0, row=0) proxy_address = Entry(pw, width=30) proxy_address.grid(column=1, row=0, sticky='w') prx = BooleanVar() prx.set(0) proxy_check = Checkbutton(pw, text='Прокси:', variable=prx, onvalue=1, offvalue=0, command=change_check) proxy_check.grid(column=3, row=0, sticky='e') port_lbl = Label(pw, text="порт: ") port_lbl.grid(column=0, row=1) port = Entry(pw, width=5) port.grid(column=1, row=1, sticky='w') login_lbl = Label(pw, text="логин: ") login_lbl.grid(column=0, row=2) login = Entry(pw, width=20) login.grid(column=1, row=2, sticky='w') passwrd_lbl = Label(pw, text="пароль: ") passwrd_lbl.grid(column=0, row=3) password = Entry(pw, show="*", width=20) password.grid(column=1, row=3, sticky='w') btn = Button(pw, text="Сохранить", command=proxy_save) btn.grid(column=1, row=5) btn = Button(pw, text="Закрыть", command=on_close_proxy) btn.grid(column=0, row=5) egrul_parser_path = create_folders() proxy_settings_path = egrul_parser_path + '/proxy_settings' if os.path.exists(proxy_settings_path): file = open(proxy_settings_path, 'rb') proxies_enc = file.read() proxies_dec = base64.b64decode(proxies_enc) proxies_dec = proxies_dec.decode('utf-8') proxies_dec = proxies_dec.replace('"', '\\"') proxies_dec = proxies_dec.replace("'", '"') proxies_dec = json.loads(proxies_dec) file.close() _login = proxies_dec.get('login') _pass = proxies_dec.get('pass') if _login is None or _pass is None: logger('Ошибка с парсингом параметров логина и пароля прокси') _login = '' _pass = '' _proxy = proxies_dec.get('http') try: _address = re.findall('(http:\W\W|@|)([a-z0-9.-]+):\d+', _proxy)[0][1] _port = re.findall(':(\d+)', _proxy)[0] except IndexError: logger('Ошибка с парсингом параметров адреса и порта прокси') _address = '' _port = '' proxy_address.insert(0, _address) port.insert(0, _port) login.insert(0, _login) password.insert(0, _pass) if getboolean(proxies_dec.get('proxy')[1:-1]): proxy_check.select() prx.set(1) else: proxy_check.deselect() prx.set(0) pw.protocol("WM_DELETE_WINDOW", on_close_proxy) pw.mainloop()
class PyRegexEvaluator(Frame): def centre_window(self): """ Display's your gui in the centre of the screen """ w = 685 # Sets your gui's width h = 635 # Sets your gui's height sw = self.root.winfo_screenwidth() sh = self.root.winfo_screenheight() x = (sw - w) // 2 # Use integer devision to avoid having to convert y = (sh - h) // 2 # float to int self.root.geometry('{:d}x{:d}+{:d}+{:d}'.format(w, h, x, y)) def __init__(self, parent, *args, **kwargs): Frame.__init__(self, parent, *args, **kwargs) self.root = parent self.centre_window() centre_title_text = (' ' * 40) # Uses spaces to center Title title_text = 'Python Regular Expression Checker - By Jack Ackermann' self.root.title(centre_title_text + title_text) self.root.iconbitmap('images\icon.ico') self.grid(column=0, row=0, sticky='nsew', padx=12, pady=5) self.create_widgets() self.create_right_click_menu() def create_widgets(self): '''Create and load all widgets''' # Entry widget and Label Section label_text = 'Please enter regex expression to find: ' self.regex_label = tk.Label(self, text=label_text) self.regex_label.grid(row=0, column=0, sticky="w", pady=15) self.regex_pattern = tk.StringVar() self.regex_string = Entry(self, textvariable=self.regex_pattern) self.regex_string.config(borderwidth=2, relief='sunken', width=70) self.regex_string.grid(row=0, column=0, sticky="e", pady=15) # Data widget and Label Section. Data to be searched. label_data1 = 'Enter data below that you want to search. ' label_data2 = 'Results are then highlighted using re.finditer' self.data_label = tk.Label(self, text=label_data1 + label_data2) self.data_label.grid(row=1, column=0, sticky="w") self.data_textbox = Text(self, borderwidth=2, relief='sunken') self.data_textbox.config(height=15, width=80) self.data_textbox.grid(row=2, column=0, sticky="new") self.scrollbar = Scrollbar(self, command=self.data_textbox.yview) self.scrollbar.grid(row=2, column=1, sticky='ns') self.data_textbox['yscrollcommand'] = self.scrollbar.set # Display regex results and Label section label_output = 'All the matches below were found using re.findall' self.label_output = tk.Label(self, text=label_output) self.label_output.grid(row=3, column=0, sticky="w") self.output_textbox = Text(self, borderwidth=2, relief='sunken') self.output_textbox.config(height=15, width=80) self.output_textbox.grid(row=4, column=0, sticky="new") self.scrollbar2 = Scrollbar(self, command=self.output_textbox.yview) self.scrollbar2.grid(row=4, column=1, sticky='ns') self.output_textbox['yscrollcommand'] = self.scrollbar2.set # Create Two Button Widgets self.find_btn = ttk.Button(self, text='Find', command=self.on_find) self.find_btn.grid(row=5, sticky='E') self.exit_btn = ttk.Button(self, text='Exit', command=self.on_exit) self.exit_btn.grid(row=5, column=0, sticky='W', pady=15) # Create a Checkbutton Widget self.auto_var = tk.IntVar() self.auto_find = Checkbutton(self, variable=self.auto_var, command=self.on_auto, background='pink') self.auto_find.config(text='Turns on Auto Search as you type') self.auto_find.grid(row=5, column=0, sticky='') self.auto_find.deselect() def create_right_click_menu(self): '''Creates and binds the right click popup menu''' # Instanciate the imported popup class self.popup = RightClickMenu(self.master, self.regex_pattern) self.popup2 = RightClickMenu(self.master, self.data_textbox) self.popup3 = RightClickMenu(self.master, self.output_textbox) # Bind the popup menus and Enter Key to the appropriate widgets. self.regex_string.bind("<Button-3>", self.popup.entry_popup) self.data_textbox.bind("<Button-3>", self.popup2.text_popup) self.output_textbox.bind("<Button-3>", self.popup3.text_popup) self.regex_string.bind("<Return>", lambda _: self.on_find()) # Method for the find_btn, <Return> bind and Checkbutton def on_find(self, a=None, b=None, c=None): """ Takes three arguments with default values: a, b, c These arguments are needed for the trace method of StringVar() Instanciate and use the Highlighter class """ self.highlighter = Highlighter(self.regex_pattern, self.data_textbox, self.output_textbox) self.highlighter.find_matches() # Method for the self.auto_find checkbutton def on_auto(self): """ If the self.auto_find Checkbox is selected, the find button is disabled and the <Return> key is unbound The self.regex_pattern.trace is created that calls the on_find method everytime the variable changes. If the self.auto_find Checkbox is unselected, the find button gets re-enabled and the <Return> key bind is set. And the self.regex_pattern.trace is deleted """ trace_id = '' if self.auto_var.get() == 1: self.find_btn.config(state='disabled') self.regex_string.unbind("<Return>") self.regex_pattern.trace_id = self.regex_pattern.trace("w", self.on_find) else: self.find_btn.config(state='enabled') self.regex_string.bind("<Return>", lambda _: self.on_find()) self.regex_pattern.trace_vdelete("w", self.regex_pattern.trace_id) # Exits the program. Linked to the Exit Button def on_exit(self): self.root.destroy()
class AnalysisToolsManager: def __init__(self, controller): self.tab = None self.controller = controller self.tk_format = utils.TkFormat(self.controller.config_info) self.analysis_dialog = None self.exclude_artifacts = IntVar() self.abs_val = IntVar() self.use_max_for_centers = IntVar() self.use_delta = IntVar() self.neg_depth = IntVar() self.normalize_entry = None self.right_zoom_entry = None self.right_zoom_entry2 = None self.left_zoom_entry = None self.left_zoom_entry2 = None self.left_slope_entry = None self.right_slope_entry = None self.slopes_listbox = None self.abs_val_check = None self.use_max_for_centers_check = None self.use_delta_check = None self.neg_depth_check = None self.exclude_artifacts_check = None self.extra_analysis_check_frame = None self.plot_slope_var = None self.offset_entry = None self.offset_sample_var = None self.plot_slope_menu = None self.plot_slope_button = None self.analyze_var = None self.outer_slope_frame = None self.slope_results_frame = None def show(self, tab): self.tab = tab self.tab.freeze( ) # You have to finish dealing with this before, say, opening another analysis box. buttons = { "reset": { self.select_tab: [], self.tab.reset: [], self.uncheck_exclude_artifacts: [], self.disable_plot: [], # utils.thread_lift_widget: [], }, "close": {}, } self.analysis_dialog = VerticalScrolledDialog(self.controller, "Analyze Data", "", buttons=buttons, button_width=13) self.analysis_dialog.top.attributes("-topmost", True) outer_normalize_frame = Frame(self.analysis_dialog.interior, bg=self.tk_format.bg, padx=self.tk_format.padx, pady=15, highlightthickness=1) outer_normalize_frame.pack(expand=True, fill=BOTH) slope_title_label = Label(outer_normalize_frame, text="Normalize:", bg=self.tk_format.bg, fg=self.tk_format.textcolor) slope_title_label.pack() normalize_frame = Frame(outer_normalize_frame, bg=self.tk_format.bg, padx=self.tk_format.padx, pady=15) normalize_frame.pack() normalize_label = Label(normalize_frame, text="Wavelength (nm):", bg=self.tk_format.bg, fg=self.tk_format.textcolor) self.normalize_entry = Entry( normalize_frame, width=7, bd=self.tk_format.bd, bg=self.tk_format.entry_background, selectbackground=self.tk_format.selectbackground, selectforeground=self.tk_format.selectforeground, ) normalize_button = Button( normalize_frame, text="Apply", command=self.normalize, width=6, fg=self.tk_format.buttontextcolor, bg=self.tk_format.buttonbackgroundcolor, bd=self.tk_format.bd, ) normalize_button.config( fg=self.tk_format.buttontextcolor, highlightbackground=self.tk_format.highlightbackgroundcolor, bg=self.tk_format.buttonbackgroundcolor, ) normalize_button.pack(side=RIGHT, padx=(10, 10)) self.normalize_entry.pack(side=RIGHT, padx=self.tk_format.padx) normalize_label.pack(side=RIGHT, padx=self.tk_format.padx) outer_offset_frame = Frame(self.analysis_dialog.interior, bg=self.tk_format.bg, padx=self.tk_format.padx, pady=15, highlightthickness=1) outer_offset_frame.pack(expand=True, fill=BOTH) slope_title_label = Label(outer_offset_frame, text="Add offset to sample:", bg=self.tk_format.bg, fg=self.tk_format.textcolor) slope_title_label.pack(pady=(0, 15)) offset_sample_frame = Frame(outer_offset_frame, bg=self.tk_format.bg, padx=self.tk_format.padx, pady=self.tk_format.pady) offset_sample_frame.pack() offset_sample_label = Label(offset_sample_frame, text="Sample: ", bg=self.tk_format.bg, fg=self.tk_format.textcolor) offset_sample_label.pack(side=LEFT) self.offset_sample_var = StringVar() sample_names = [] repeats = False max_len = 0 for sample in self.tab.samples: if sample.name in sample_names: repeats = True else: sample_names.append(sample.name) max_len = np.max([max_len, len(sample.name)]) if repeats: sample_names = [] for sample in self.tab.samples: sample_names.append(sample.title + ": " + sample.name) max_len = np.max([max_len, len(sample_names[-1])]) self.offset_sample_var.set(sample_names[0]) # pylint: disable = no-value-for-parameter offset_menu = OptionMenu(offset_sample_frame, self.offset_sample_var, *sample_names) offset_menu.configure( width=max_len, highlightbackground=self.tk_format.highlightbackgroundcolor) offset_menu.pack(side=LEFT) offset_frame = Frame(outer_offset_frame, bg=self.tk_format.bg, padx=self.tk_format.padx, pady=15) offset_frame.pack() offset_label = Label(offset_frame, text="Offset:", bg=self.tk_format.bg, fg=self.tk_format.textcolor) self.offset_entry = Entry( offset_frame, width=7, bd=self.tk_format.bd, bg=self.tk_format.entry_background, selectbackground=self.tk_format.selectbackground, selectforeground=self.tk_format.selectforeground, ) offset_button = Button( offset_frame, text="Apply", command=self.offset, width=6, fg=self.tk_format.buttontextcolor, bg=self.tk_format.buttonbackgroundcolor, bd=self.tk_format.bd, ) offset_button.config( fg=self.tk_format.buttontextcolor, highlightbackground=self.tk_format.highlightbackgroundcolor, bg=self.tk_format.buttonbackgroundcolor, ) offset_button.pack(side=RIGHT, padx=(10, 10)) self.offset_entry.pack(side=RIGHT, padx=self.tk_format.padx) offset_label.pack(side=RIGHT, padx=self.tk_format.padx) outer_outer_zoom_frame = Frame(self.analysis_dialog.interior, bg=self.tk_format.bg, padx=self.tk_format.padx, pady=15, highlightthickness=1) outer_outer_zoom_frame.pack(expand=True, fill=BOTH) zoom_title_frame = Frame(outer_outer_zoom_frame, bg=self.tk_format.bg) zoom_title_frame.pack(pady=(5, 10)) zoom_title_label = Label(zoom_title_frame, text="Adjust plot x and y limits:", bg=self.tk_format.bg, fg=self.tk_format.textcolor) zoom_title_label.pack(side=LEFT, pady=(0, 4)) outer_zoom_frame = Frame(outer_outer_zoom_frame, bg=self.tk_format.bg, padx=self.tk_format.padx) outer_zoom_frame.pack(expand=True, fill=BOTH, pady=(0, 10)) zoom_frame = Frame(outer_zoom_frame, bg=self.tk_format.bg, padx=self.tk_format.padx) zoom_frame.pack() zoom_label = Label(zoom_frame, text="x1:", bg=self.tk_format.bg, fg=self.tk_format.textcolor) self.left_zoom_entry = Entry( zoom_frame, width=7, bd=self.tk_format.bd, bg=self.tk_format.entry_background, selectbackground=self.tk_format.selectbackground, selectforeground=self.tk_format.selectforeground, ) zoom_label2 = Label(zoom_frame, text="x2:", bg=self.tk_format.bg, fg=self.tk_format.textcolor) self.right_zoom_entry = Entry( zoom_frame, width=7, bd=self.tk_format.bd, bg=self.tk_format.entry_background, selectbackground=self.tk_format.selectbackground, selectforeground=self.tk_format.selectforeground, ) zoom_button = Button( zoom_frame, text="Apply", command=self.apply_x, width=7, fg=self.tk_format.buttontextcolor, bg=self.tk_format.buttonbackgroundcolor, bd=self.tk_format.bd, ) zoom_button.config( fg=self.tk_format.buttontextcolor, highlightbackground=self.tk_format.highlightbackgroundcolor, bg=self.tk_format.buttonbackgroundcolor, ) zoom_button.pack(side=RIGHT, padx=(10, 10)) self.right_zoom_entry.pack(side=RIGHT, padx=self.tk_format.padx) zoom_label2.pack(side=RIGHT, padx=self.tk_format.padx) self.left_zoom_entry.pack(side=RIGHT, padx=self.tk_format.padx) zoom_label.pack(side=RIGHT, padx=self.tk_format.padx) outer_zoom_frame2 = Frame(outer_outer_zoom_frame, bg=self.tk_format.bg, padx=self.tk_format.padx) outer_zoom_frame2.pack(expand=True, fill=BOTH, pady=(0, 10)) zoom_frame2 = Frame(outer_zoom_frame2, bg=self.tk_format.bg, padx=self.tk_format.padx) zoom_frame2.pack() zoom_label3 = Label(zoom_frame2, text="y1:", bg=self.tk_format.bg, fg=self.tk_format.textcolor) self.left_zoom_entry2 = Entry( zoom_frame2, width=7, bd=self.tk_format.bd, bg=self.tk_format.entry_background, selectbackground=self.tk_format.selectbackground, selectforeground=self.tk_format.selectforeground, ) zoom_label4 = Label(zoom_frame2, text="y2:", bg=self.tk_format.bg, fg=self.tk_format.textcolor) self.right_zoom_entry2 = Entry( zoom_frame2, width=7, bd=self.tk_format.bd, bg=self.tk_format.entry_background, selectbackground=self.tk_format.selectbackground, selectforeground=self.tk_format.selectforeground, ) zoom_button2 = Button( zoom_frame2, text="Apply", command=self.apply_y, width=7, fg=self.tk_format.buttontextcolor, bg=self.tk_format.buttonbackgroundcolor, bd=self.tk_format.bd, ) zoom_button2.config( fg=self.tk_format.buttontextcolor, highlightbackground=self.tk_format.highlightbackgroundcolor, bg=self.tk_format.buttonbackgroundcolor, ) zoom_button2.pack(side=RIGHT, padx=(10, 10)) self.right_zoom_entry2.pack(side=RIGHT, padx=self.tk_format.padx) zoom_label4.pack(side=RIGHT, padx=self.tk_format.padx) self.left_zoom_entry2.pack(side=RIGHT, padx=self.tk_format.padx) zoom_label3.pack(side=RIGHT, padx=self.tk_format.padx) outer_outer_slope_frame = Frame(self.analysis_dialog.interior, bg=self.tk_format.bg, padx=self.tk_format.padx, pady=15, highlightthickness=1) outer_outer_slope_frame.pack(expand=True, fill=BOTH) self.outer_slope_frame = Frame(outer_outer_slope_frame, bg=self.tk_format.bg, padx=self.tk_format.padx) self.outer_slope_frame.pack(expand=True, fill=BOTH, pady=(0, 10)) slope_title_frame = Frame(self.outer_slope_frame, bg=self.tk_format.bg) slope_title_frame.pack(pady=(5, 5)) slope_title_label = Label(slope_title_frame, text="Analyze ", bg=self.tk_format.bg, fg=self.tk_format.textcolor) slope_title_label.pack(side=LEFT, pady=(0, 4)) self.analyze_var = StringVar() self.analyze_var.set("slope") analyze_menu = OptionMenu( slope_title_frame, self.analyze_var, "slope", "band depth", "band center", "reflectance", # "reciprocity", "difference", command=self.disable_plot, ) analyze_menu.configure( width=10, highlightbackground=self.tk_format.highlightbackgroundcolor) analyze_menu.pack(side=LEFT) # We'll put checkboxes for additional options into this frame at the time the user selects a given option (e.g. # select 'difference' from menu, add option to calculate differences based on absolute value self.extra_analysis_check_frame = Frame(self.outer_slope_frame, bg=self.tk_format.bg, padx=self.tk_format.padx) self.extra_analysis_check_frame.pack() # Note that we are not packing this checkbutton yet. self.abs_val_check = Checkbutton( self.extra_analysis_check_frame, selectcolor=self.tk_format.check_bg, fg=self.tk_format.textcolor, text=" Use absolute values for average differences", bg=self.tk_format.bg, pady=self.tk_format.pady, highlightthickness=0, variable=self.abs_val, ) self.use_max_for_centers_check = Checkbutton( self.extra_analysis_check_frame, selectcolor=self.tk_format.check_bg, fg=self.tk_format.textcolor, text= " If band max is more prominent than\nband min, use to find center.", bg=self.tk_format.bg, pady=self.tk_format.pady, highlightthickness=0, variable=self.use_max_for_centers, ) self.use_max_for_centers_check.select() self.use_delta_check = Checkbutton( self.extra_analysis_check_frame, selectcolor=self.tk_format.check_bg, fg=self.tk_format.textcolor, text=" Center at max \u0394" + "R from continuum \nrather than spectral min/max. ", bg=self.tk_format.bg, pady=self.tk_format.pady, highlightthickness=0, variable=self.use_delta, ) self.use_delta_check.select() self.neg_depth_check = Checkbutton( self.extra_analysis_check_frame, selectcolor=self.tk_format.check_bg, fg=self.tk_format.textcolor, text= " If band max is more prominent than \nband min, report negative depth.", bg=self.tk_format.bg, pady=self.tk_format.pady, highlightthickness=0, variable=self.neg_depth, ) self.neg_depth_check.select() slope_frame = Frame(self.outer_slope_frame, bg=self.tk_format.bg, padx=self.tk_format.padx, highlightthickness=0) slope_frame.pack(pady=(15, 0)) slope_label = Label(slope_frame, text="x1:", bg=self.tk_format.bg, fg=self.tk_format.textcolor) self.left_slope_entry = Entry( slope_frame, width=7, bd=self.tk_format.bd, bg=self.tk_format.entry_background, selectbackground=self.tk_format.selectbackground, selectforeground=self.tk_format.selectforeground, ) slope_label_2 = Label(slope_frame, text="x2:", bg=self.tk_format.bg, fg=self.tk_format.textcolor) self.right_slope_entry = Entry( slope_frame, width=7, bd=self.tk_format.bd, bg=self.tk_format.entry_background, selectbackground=self.tk_format.selectbackground, selectforeground=self.tk_format.selectforeground, ) slope_button = Button( slope_frame, text="Calculate", command=self.calculate, width=7, fg=self.tk_format.buttontextcolor, bg=self.tk_format.buttonbackgroundcolor, bd=self.tk_format.bd, ) slope_button.config( fg=self.tk_format.buttontextcolor, highlightbackground=self.tk_format.highlightbackgroundcolor, bg=self.tk_format.buttonbackgroundcolor, ) slope_button.pack(side=RIGHT, padx=(10, 10)) self.right_slope_entry.pack(side=RIGHT, padx=self.tk_format.padx) slope_label_2.pack(side=RIGHT, padx=self.tk_format.padx) self.left_slope_entry.pack(side=RIGHT, padx=self.tk_format.padx) slope_label.pack(side=RIGHT, padx=self.tk_format.padx) self.slope_results_frame = Frame(self.outer_slope_frame, bg=self.tk_format.bg) self.slope_results_frame.pack( fill=BOTH, expand=True ) # We'll put a listbox with slope info in here later after calculating. outer_plot_slope_frame = Frame(outer_outer_slope_frame, bg=self.tk_format.bg, padx=self.tk_format.padx, pady=10) outer_plot_slope_frame.pack(expand=True, fill=BOTH) plot_slope_frame = Frame(outer_plot_slope_frame, bg=self.tk_format.bg, padx=self.tk_format.padx) plot_slope_frame.pack(side=RIGHT) plot_slope_label = Label(plot_slope_frame, text="Plot as a function of", bg=self.tk_format.bg, fg=self.tk_format.textcolor) self.plot_slope_var = StringVar() self.plot_slope_var.set("e") self.plot_slope_menu = OptionMenu(plot_slope_frame, self.plot_slope_var, "e", "i", "g", "e,i", "theta", "az, e") self.plot_slope_menu.configure( width=2, highlightbackground=self.tk_format.highlightbackgroundcolor) self.plot_slope_button = Button( plot_slope_frame, text="Plot", command=self.plot, width=7, fg=self.tk_format.buttontextcolor, bg=self.tk_format.buttonbackgroundcolor, bd=self.tk_format.bd, ) self.plot_slope_button.config( fg=self.tk_format.buttontextcolor, highlightbackground=self.tk_format.highlightbackgroundcolor, bg=self.tk_format.buttonbackgroundcolor, state=DISABLED, ) self.plot_slope_button.pack(side=RIGHT, padx=(10, 10)) self.plot_slope_menu.pack(side=RIGHT, padx=self.tk_format.padx) plot_slope_label.pack(side=RIGHT, padx=self.tk_format.padx) exclude_artifacts_frame = Frame(self.analysis_dialog.interior, bg=self.tk_format.bg, padx=self.tk_format.padx, pady=15, highlightthickness=1) exclude_artifacts_frame.pack(fill=BOTH, expand=True) self.exclude_artifacts_check = Checkbutton( exclude_artifacts_frame, selectcolor=self.tk_format.check_bg, fg=self.tk_format.textcolor, text= " Exclude data susceptible to artifacts\n (high g, 1000-1400 nm) ", bg=self.tk_format.bg, pady=self.tk_format.pady, highlightthickness=0, variable=self.exclude_artifacts, # TODO: check if the comma is meant to be there in the lambda definition command=lambda x="foo", : self.tab.set_exclude_artifacts( self.exclude_artifacts.get()), ) self.exclude_artifacts_check.pack() if self.tab.exclude_artifacts: self.exclude_artifacts_check.select() self.analysis_dialog.interior.configure(highlightthickness=1, highlightcolor="white") def calculate(self): try: self.controller.view_notebook.select(self.tab.top) except TclError: print("Error selecting tab in analysis_tools_manager.calculate().") print(self.tab) pass artifact_warning = False if self.analyze_var.get() == "slope": left, right, slopes, artifact_warning = self.tab.calculate_slopes( self.left_slope_entry.get(), self.right_slope_entry.get()) self.update_entries(left, right) self.populate_listbox(slopes) self.update_plot_menu(["e", "i", "g", "e,i", "theta", "az, e"]) elif self.analyze_var.get() == "band depth": left, right, depths, artifact_warning = self.tab.calculate_band_depths( self.left_slope_entry.get(), self.right_slope_entry.get(), self.neg_depth.get(), self.use_delta.get(), ) self.update_entries(left, right) self.populate_listbox(depths) self.update_plot_menu(["e", "i", "g", "e,i", "theta", "az, e"]) elif self.analyze_var.get() == "band center": left, right, centers, artifact_warning = self.tab.calculate_band_centers( self.left_slope_entry.get(), self.right_slope_entry.get(), self.use_max_for_centers.get(), self.use_delta.get(), ) self.update_entries(left, right) self.populate_listbox(centers) self.update_plot_menu(["e", "i", "g", "e,i", "theta", "az, e"]) elif self.analyze_var.get() == "reflectance": left, right, reflectance, artifact_warning = self.tab.calculate_avg_reflectance( self.left_slope_entry.get(), self.right_slope_entry.get()) self.update_entries(left, right) self.populate_listbox(reflectance) self.update_plot_menu(["e", "i", "g", "e,i", "theta", "az, e"]) elif self.analyze_var.get() == "reciprocity": left, right, reciprocity, artifact_warning = self.tab.calculate_reciprocity( self.left_slope_entry.get(), self.right_slope_entry.get()) self.update_entries(left, right) self.populate_listbox(reciprocity) self.update_plot_menu(["e", "i", "g", "e,i"]) elif self.analyze_var.get() == "difference": left, right, error, artifact_warning = self.tab.calculate_error( self.left_slope_entry.get(), self.right_slope_entry.get(), self.abs_val.get()) # Tab validates left and right values. If they are no good, put in min and max wavelengths available. self.update_entries(left, right) self.populate_listbox(error) self.update_plot_menu(["\u03bb", "e,i"]) if artifact_warning: ErrorDialog( self, "Warning", "Warning: Excluding data potentially\ninfluenced by artifacts from 1000-1400 nm." ) self.analysis_dialog.min_height = 1000 self.analysis_dialog.update() def update_plot_menu(self, plot_options): self.plot_slope_var.set(plot_options[0]) self.plot_slope_menu["menu"].delete(0, "end") # Insert list of new options (tk._setit hooks them up to var) max_len = len(plot_options[0]) for option in plot_options: max_len = np.max([max_len, len(option)]) # pylint: disable = protected-access self.plot_slope_menu["menu"].add_command(label=option, command=tkinter._setit( self.plot_slope_var, option)) self.plot_slope_menu.configure(width=max_len) def update_entries(self, left, right): self.left_slope_entry.delete(0, "end") self.left_slope_entry.insert(0, str(left)) self.right_slope_entry.delete(0, "end") self.right_slope_entry.insert(0, str(right)) def populate_listbox(self, results): if len(results) > 0: self.slope_results_frame.pack(fill=BOTH, expand=True, pady=(10, 10)) try: self.slopes_listbox.delete(0, "end") except (AttributeError, TclError): self.slopes_listbox = utils.ScrollableListbox( self.slope_results_frame, self.tk_format.bg, self.tk_format.entry_background, self.tk_format.listboxhighlightcolor, selectmode=EXTENDED, ) self.slopes_listbox.configure(height=8) for result in results: self.slopes_listbox.insert("end", result) self.slopes_listbox.pack(fill=BOTH, expand=True) self.plot_slope_button.configure(state=NORMAL) def plot(self): if self.analyze_var.get() == "slope": self.tab.plot_slopes(self.plot_slope_var.get()) elif self.analyze_var.get() == "band depth": self.tab.plot_band_depths(self.plot_slope_var.get()) elif self.analyze_var.get() == "band center": self.tab.plot_band_centers(self.plot_slope_var.get()) elif self.analyze_var.get() == "reflectance": self.tab.plot_avg_reflectance(self.plot_slope_var.get()) elif self.analyze_var.get() == "reciprocity": self.tab.plot_reciprocity(self.plot_slope_var.get()) elif self.analyze_var.get() == "difference": new = self.tab.plot_error(self.plot_slope_var.get()) if self.plot_slope_var.get() == "\u03bb": x1 = float(self.left_slope_entry.get()) x2 = float(self.right_slope_entry.get()) new.adjust_x(x1, x2) # TODO: plots not always fully updating # (e.g. contour plot labels not showing up until you do a screen wiggle. # utils.thread_lift_widget(self.analysis_dialog.top) def normalize(self): self.select_tab() try: self.slopes_listbox.delete(0, "end") self.plot_slope_button.configure(state="disabled") except (AttributeError, TclError): pass self.tab.normalize(self.normalize_entry.get()) # thread = Thread(target=utils.lift_widget, args=(self.analysis_dialog.top,)) # thread.start() def offset(self): self.tab.offset(self.offset_sample_var.get(), self.offset_entry.get()) # This doesn't work - it hangs between thread.start() and thread.join(). Likely because of calls to canvas.draw() # thread = Thread(target=self.tab.offset, args=(self.offset_sample_var.get(), self.offset_entry.get())) # thread.start() # thread.join() # utils.lift_widget(self.analysis_dialog.top) def remove_topmost(self): print("removing!!") self.analysis_dialog.top.attributes("-topmost", False) def apply_x(self): self.controller.view_notebook.select(self.tab.top) try: x1 = float(self.left_zoom_entry.get()) x2 = float(self.right_zoom_entry.get()) self.tab.adjust_x(x1, x2) # utils.lift_widget(self.analysis_dialog.top) except ValueError: # utils.lift_widget(self.analysis_dialog.top) ErrorDialog( self, title="Invalid Zoom Range", label="Error! Invalid x limits: " + self.left_zoom_entry.get() + ", " + self.right_zoom_entry.get(), ) def apply_y(self): self.controller.view_notebook.select(self.tab.top) try: y1 = float(self.left_zoom_entry2.get()) y2 = float(self.right_zoom_entry2.get()) self.tab.adjust_y(y1, y2) # utils.lift_widget(self.analysis_dialog.top) except ValueError: # utils.lift_widget(self.analysis_dialog.top) ErrorDialog( self, title="Invalid Zoom Range", label="Error! Invalid y limits: " + self.left_zoom_entry2.get() + ", " + self.right_zoom_entry2.get(), ) def uncheck_exclude_artifacts(self): self.exclude_artifacts.set(0) self.exclude_artifacts_check.deselect() # utils.lift_widget(self.analysis_dialog.top) def disable_plot(self, analyze_var="None"): try: self.slopes_listbox.delete(0, "end") except (AttributeError, TclError): pass self.plot_slope_button.configure(state="disabled") if analyze_var == "difference": self.analysis_dialog.frame.min_height = 850 self.neg_depth_check.pack_forget() self.use_max_for_centers_check.pack_forget() self.use_delta_check.pack_forget() self.abs_val_check.pack() self.extra_analysis_check_frame.pack() elif analyze_var == "band center": self.analysis_dialog.frame.min_height = 1000 self.neg_depth_check.pack_forget() self.abs_val_check.pack_forget() self.use_delta_check.pack_forget() self.use_max_for_centers_check.pack() self.use_delta_check.pack() self.extra_analysis_check_frame.pack() elif analyze_var == "band depth": self.analysis_dialog.frame.min_height = 1000 self.abs_val_check.pack_forget() self.use_max_for_centers_check.pack_forget() self.use_delta_check.pack_forget() self.neg_depth_check.pack() self.use_delta_check.pack() self.extra_analysis_check_frame.pack() else: self.analysis_dialog.frame.min_height = 850 self.abs_val_check.pack_forget() self.neg_depth_check.pack_forget() self.use_max_for_centers_check.pack_forget() self.use_delta_check.pack_forget() self.extra_analysis_check_frame.grid_propagate(0) self.extra_analysis_check_frame.configure( height=1) # for some reason 0 doesn't work. self.extra_analysis_check_frame.pack() self.outer_slope_frame.pack() # utils.lift_widget(self.analysis_dialog.top) # def calculate_photometric_variability(self): # photo_var = self.tab.calculate_photometric_variability( # self.right_photo_var_entry.get(), self.left_photo_var_entry.get() # ) # try: # self.photo_var_listbox.delete(0, "end") # except: # self.photo_var_listbox = utils.ScrollableListbox( # self.photo_var_results_frame, # self.tk_format.bg, # self.tk_format.entry_background, # self.tk_format.listboxhighlightcolor, # selectmode=EXTENDED, # ) # for var in photo_var: # self.photo_var_listbox.insert("end", var) # self.photo_var_listbox.pack(fill=BOTH, expand=True) def select_tab(self): self.controller.view_notebook.select(self.tab.top)
def _deselectCheckbutton(cb: tk.Checkbutton): cb.deselect()
class EvernoteDumpFrame(Frame): def __init__(self, master: EvernoteDump): super().__init__(master) self.master = master self.pack(fill="both") self.open_button = Button( text='Choose Evernote Export File(s) (.enex)', command=self.open_file_picker) self.open_button.pack(fill='x', padx=10, pady=10) self.export_files_list = Listbox(height=4) self.export_files_list.insert(0, "No files selected.") self.export_files_list.pack(fill='x', padx=10, pady=10) self.preserve = IntVar() self.preserve_names = Checkbutton( text='Preserve file names for attachments if found', variable=self.preserve, command=self.toggle_preserve) self.preserve_names.pack(anchor='nw', padx=10, pady=10) self.use_title = IntVar() self.use_title_for_names = Checkbutton( text='Use the note\'s title for file attachments', variable=self.use_title, command=self.toggle_use_title) self.use_title_for_names.pack(anchor='nw', padx=10, pady=10) self.export_dir_button = Button(text='Choose Export Directory', command=self.open_directory_picker) self.export_dir_button.pack(fill='x', padx=10, pady=10) self.export_dir_label = Label(text="Please select an export directory") self.export_dir_label.pack(fill='x', padx=10, pady=10) self.run_button = Button(text='Start Evernote Conversion to Markdown', state=DISABLED, command=self.run) self.run_button.pack(fill='x', padx=10, pady=10) self.log_box = scrolledtext.ScrolledText() self.log_box.pack(fill='x', padx=10, pady=10) def check(self): if len(self.master.settings.files ) > 0 and self.master.settings.export_path != '': self.run_button.config(state=NORMAL) else: self.run_button.config(state=DISABLED) def open_directory_picker(self): self.master.settings.path = filedialog.askdirectory() self.export_dir_label.config(text=f"{self.master.settings.path}") self.check() def open_file_picker(self): self.master.settings.enex = filedialog.askopenfilenames() self.export_files_list.delete(0, END) for file in self.master.settings.enex: self.export_files_list.insert(0, file) self.check() def run(self): self.run_button.config(state=DISABLED) def print_callback(print_text: str): self.log_box.insert(END, f"{print_text}\n") self.log_box.see(END) threading.Thread(target=run_parse, args=(self.master.settings, print_callback)).start() def toggle_preserve(self): self.master.settings.p = bool(self.preserve) self.master.settings.n = False self.use_title_for_names.deselect() def toggle_use_title(self): self.master.settings.n = bool(self.preserve) self.master.settings.p = False self.preserve_names.deselect()
class Page1(Frame): def __init__(self, master): super().__init__(master, relief='flat', borderwidth=20) self.business_logic = BusinessLogic() self.init_ui() def chk_btn1_onclick(self): checked = self.chk_btn_var1.get() if checked: self.qty_entry1.configure(state=NORMAL) else: self.qty_entry1.configure(state=NORMAL) self.enable_btn() def chk_btn2_onclick(self): checked = self.chk_btn_var2.get() if checked: self.qty_entry2.configure(state=NORMAL) else: self.qty_entry2.configure(state=NORMAL) self.enable_btn() def chk_btn3_onclick(self): checked = self.chk_btn_var3.get() if checked: self.qty_entry3.configure(state=NORMAL) else: self.qty_entry3.configure(state=NORMAL) self.enable_btn() def chk_btn4_onclick(self): checked = self.chk_btn_var4.get() if checked: self.qty_entry4.configure(state=NORMAL) else: self.qty_entry4.configure(state=NORMAL) self.enable_btn() def chk_btn5_onclick(self): checked = self.chk_btn_var5.get() if checked: self.qty_entry5.configure(state=NORMAL) else: self.qty_entry5.configure(state=NORMAL) self.enable_btn() def enable_btn(self): if any((self.chk_btn_var1.get(), self.chk_btn_var2.get(), self.chk_btn_var3.get(), self.chk_btn_var4.get(), self.chk_btn_var5.get())): self.gen_receipt_btn.configure(state=NORMAL) else: self.gen_receipt_btn.configure(state=DISABLED) def qty_entry1_keybind(self, event): self.validate_for_int(event, self.qty_entry1) def qty_entry2_keybind(self, event): self.validate_for_int(event, self.qty_entry2) def qty_entry3_keybind(self, event): self.validate_for_int(event, self.qty_entry3) def qty_entry4_keybind(self, event): self.validate_for_int(event, self.qty_entry4) def qty_entry5_keybind(self, event): self.validate_for_int(event, self.qty_entry5) def validate_for_int(self, event, widget): val = widget.get() try: float(widget.get()) except ValueError as verr: print(str(verr)) if not event.char.isdigit(): widget.delete(0, END) widget.insert(0, val[:-1]) def _set_header(self): for col, item in enumerate(self.business_logic.header): Label(self, text=item, font='Helvetica 12 bold').grid(row=0, column=col, sticky='NW') def _set_body(self): self.chk_btn_var1 = BooleanVar() self.chk_btn_var2 = BooleanVar() self.chk_btn_var3 = BooleanVar() self.chk_btn_var4 = BooleanVar() self.chk_btn_var5 = BooleanVar() # order column self.chk_btn1 = Checkbutton(self, text="", variable=self.chk_btn_var1, command=self.chk_btn1_onclick) self.chk_btn1.grid(row=1, column=0, sticky='NW') self.chk_btn2 = Checkbutton(self, text="", variable=self.chk_btn_var2, command=self.chk_btn2_onclick) self.chk_btn2.grid(row=2, column=0, sticky='NW') self.chk_btn3 = Checkbutton(self, text="", variable=self.chk_btn_var3, command=self.chk_btn3_onclick) self.chk_btn3.grid(row=3, column=0, sticky='NW') self.chk_btn4 = Checkbutton(self, text="", variable=self.chk_btn_var4, command=self.chk_btn4_onclick) self.chk_btn4.grid(row=4, column=0, sticky='NW') self.chk_btn5 = Checkbutton(self, text="", variable=self.chk_btn_var5, command=self.chk_btn5_onclick) self.chk_btn5.grid(row=5, column=0, sticky='NW') # item column for row, item in enumerate(self.business_logic.items.keys()): _row = row + 1 Label(self, text=f"{item}").grid(row=_row, column=1, sticky='NW') # unit price column for row, unit_price in enumerate(self.business_logic.items.values()): _row = row + 1 Label(self, text=f"{unit_price}₹").grid(row=_row, column=2, sticky='NW') # quantity column self.qty_entry1 = Entry(self, state=DISABLED) self.qty_entry1.grid(row=1, column=3) self.qty_entry2 = Entry(self, state=DISABLED) self.qty_entry2.grid(row=2, column=3) self.qty_entry3 = Entry(self, state=DISABLED) self.qty_entry3.grid(row=3, column=3) self.qty_entry4 = Entry(self, state=DISABLED) self.qty_entry4.grid(row=4, column=3) self.qty_entry5 = Entry(self, state=DISABLED) self.qty_entry5.grid(row=5, column=3) self.qty_entry1.bind('<KeyRelease>', self.qty_entry1_keybind) self.qty_entry2.bind('<KeyRelease>', self.qty_entry2_keybind) self.qty_entry3.bind('<KeyRelease>', self.qty_entry3_keybind) self.qty_entry4.bind('<KeyRelease>', self.qty_entry4_keybind) self.qty_entry5.bind('<KeyRelease>', self.qty_entry5_keybind) self.gen_receipt_btn = Button(self, text="Generate Receipt", command=self.on_gen_receipt_btn_click) self.gen_receipt_btn.grid(row=8, column=2, padx=20, pady=20) self.gen_receipt_btn.configure(state=DISABLED) self.cancel_btn = Button(self, text="Clear", command=self.on_cancel_btn_click) self.cancel_btn.grid(row=8, column=3, padx=20, pady=20) Label(self, text='(Select your orders and then enter the quantities)', font='Helvetica 8 italic').grid(row=9, columnspan=4, sticky='NW') def init_ui(self): self.master.title(self.business_logic.title) self.pack(fill=None, expand=False) self._set_header() self._set_body() def on_cancel_btn_click(self): self.clear_all() def on_gen_receipt_btn_click(self): qty1 = self.qty_entry1.get().strip() qty2 = self.qty_entry2.get().strip() qty3 = self.qty_entry3.get().strip() qty4 = self.qty_entry4.get().strip() qty5 = self.qty_entry5.get().strip() if any((qty1, qty2, qty3, qty4, qty5)): for item, qty in zip(self.business_logic.items, (qty1, qty2, qty3, qty4, qty5)): if bool(qty): self.business_logic.set(item, qty) Page2(self.master, self).show() else: messagebox.showwarning("Quantities", "Empty quantity fields") def clear_all(self): self.chk_btn1.deselect() self.chk_btn2.deselect() self.chk_btn3.deselect() self.chk_btn4.deselect() self.chk_btn5.deselect() self.qty_entry1.delete(0, END) self.qty_entry2.delete(0, END) self.qty_entry3.delete(0, END) self.qty_entry4.delete(0, END) self.qty_entry5.delete(0, END) self.qty_entry1.configure(state=DISABLED) self.qty_entry2.configure(state=DISABLED) self.qty_entry3.configure(state=DISABLED) self.qty_entry4.configure(state=DISABLED) self.qty_entry5.configure(state=DISABLED) self.gen_receipt_btn.configure(state=DISABLED) self.business_logic = BusinessLogic()
def _create_windowview(self, parent, playlistTable): label = tk.Label(self.editPlaylistNameWindow, text="リスト名 :") label.grid(row=0, column=0, sticky="w", padx=10, pady=(10, 10)) self.entry_list_name = Entry(self.editPlaylistNameWindow) self.entry_list_name.grid(row=0, column=1, columnspan=3, sticky="we") label = tk.Label(self.editPlaylistNameWindow, text="定型文 :") label.grid(row=1, column=0, sticky="w", padx=10) self.cb_regular_gate = Combobox(self.editPlaylistNameWindow, state="readonly") self.refresh_cb_regular_gate() self.cb_regular_gate.current(0) self.cb_regular_gate.grid(row=1, column=1, columnspan=3, sticky="wens") self.set_entry_list_name(playlistTable) settingBtnFrame = tk.Frame(self.editPlaylistNameWindow) settingBtnFrame.grid(row=0, column=4, rowspan=3, sticky='ens') btn_setting_playlist = Button( settingBtnFrame, text="設定", command=lambda: self.update_playlist_name(playlistTable)) btn_setting_playlist.grid(sticky='wens', row=0, column=0, padx=5, pady=(10, 10), ipadx=5, ipady=3) btn_cancel = Button(settingBtnFrame, text="キャンセル", command=self.close_window) btn_cancel.grid(sticky='wens', row=1, column=0, padx=5, ipadx=5, ipady=3) regularGateFrame = tk.Frame(self.editPlaylistNameWindow) regularGateFrame.grid(row=2, column=0, sticky='wens') ck_apply_only_regular_gate = Checkbutton( regularGateFrame, variable=self.ckValue_apply_only_reguar_gate, text="定型文のみ変更", onvalue=True, offvalue=False) ck_apply_only_regular_gate.deselect() ck_apply_only_regular_gate.grid(row=0, column=0, padx=(6, 0), pady=(10, 0), sticky="") btn_update_regular_gates = Button( regularGateFrame, text="定型文編集", command=lambda: self.regular_gate_list(parent, playlistTable)) btn_update_regular_gates.grid(row=1, column=0, padx=(10, 0), pady=(5, 0), ipady=3, sticky='we') updateModeFrame = tk.LabelFrame(self.editPlaylistNameWindow, text='変更モード') updateModeFrame.grid(row=2, column=2, columnspan=2, rowspan=2, sticky='wens', padx=(10, 0), pady=10) rb_selection_update = tk.Radiobutton( updateModeFrame, text="選択行のみ", value=1, variable=self.rbPlayListNameUpdateModeValue) rb_samename_update = tk.Radiobutton( updateModeFrame, text="同ー名のみ", value=2, variable=self.rbPlayListNameUpdateModeValue) rb_all_update = tk.Radiobutton( updateModeFrame, text="全て", value=3, variable=self.rbPlayListNameUpdateModeValue) rb_selection_update.grid(row=0, column=0, sticky='w', padx=10, pady=(10, 0)) rb_samename_update.grid(row=1, column=0, sticky='w', padx=10, pady=(5, 0)) rb_all_update.grid(row=2, column=0, sticky='w', padx=10, pady=(5, 0))
def __init__(self, masterwin, songindex=None, url=None): if songindex == None: self.new = True else: self.new = False self.songindex = songindex self.masterwin = masterwin self.t = Toplevel(masterwin.master) self.t.wm_title('Lägg till ny låt') self.t.pack_propagate(0) lab = Label(self.t, text="Spotify Link", width=10, height=2) lab.grid(row=0, column=0, columnspan=2) self.spotifylink = Entry(self.t, width=25) self.spotifylink.grid(row=1, column=0, columnspan=1) self.spotifylink.focus_set() self.spotifylink.delete(0, END) Button(self.t, text="Lägg till", width=10, height=1, command=self.spotifysearch).grid(row=1, column=1) lab = Label(self.t, text="Artist", width=10, height=2) lab.grid(row=2, column=0, columnspan=2) self.artist = Entry(self.t, width=40) self.artist.grid(row=3, column=0, columnspan=2) self.artist.focus_set() self.artist.delete(0, END) self.artist.insert(0, "") lab = Label(self.t, text="Sång", width=10, height=2) lab.grid(row=4, column=0, columnspan=2) self.song = Entry(self.t, width=40) self.song.grid(row=5, column=0, columnspan=2) self.song.focus_set() self.song.delete(0, END) self.song.insert(0, "") lab = Label(self.t, text="BPM", width=10, height=2) lab.grid(row=6, column=0, columnspan=2) self.bpm = Entry(self.t, width=30) self.bpm.grid(row=7, column=0, columnspan=2) self.bpm.focus_set() self.song.delete(0, END) self.song.insert(0, "") self.isused = StringVar() check = Checkbutton(self.t, text='Redan använd', variable=self.isused) check.grid(row=8, column=0, columnspan=2) check.deselect() self.chosen_genres = [] self.chosen_blocks = [] Button(self.t, text="Genre", width=20, height=2, command=self.addGenre).grid(row=9, column=0) Button(self.t, text="Block", width=20, height=2, command=self.addBlock).grid(row=9, column=1) if not self.new: self.artist.insert( END, self.masterwin.fsongs.allsongs[self.songindex].artist) self.song.insert( END, self.masterwin.fsongs.allsongs[self.songindex].song) self.bpm.insert( END, str(self.masterwin.fsongs.allsongs[self.songindex].bpm)) self.spotifylink.insert( END, self.masterwin.fsongs.allsongs[self.songindex].spotifylink) self.chosen_genres = self.masterwin.fsongs.allsongs[ self.songindex].genre self.chosen_blocks = self.masterwin.fsongs.allsongs[ self.songindex].fits if self.masterwin.fsongs.allsongs[self.songindex].used: check.select() Button(self.t, text="Spara", width=15, height=2, command=self.addAndSave).grid(row=10, column=0) Button(self.t, text="Avbryt", width=15, height=2, command=self.t.destroy).grid(row=10, column=1) if url != None: print(url) self.spotifylink.insert(0, url) self.spotifysearch() else: self.spotifylink.insert(0, "")
class MyFirstGUI1: symptoms = [] Sym = [] symp_val = [] i = 2 j = 0 k = 0 result = "" def __init__(self, master): self.master = master master.title("Disease Predictor") self.dataloading() self.label = Label(master, text="select the problems you are facing:") self.label.grid(column=0, row=1) for feel in self.symptoms: self.symp_val.append(IntVar()) self.l = Checkbutton(self.master, text=feel, variable=self.symp_val[self.k]) self.l.grid(column=self.j, row=self.i, sticky='w') self.l.deselect() self.k = self.k+1 if(self.j < 5): self.j =self.j+1 else: self.j = 0 self.i = self.i + 1 self.Diagnosis = Button(master, text="Start Diagnosis", command=self.diagnosis) self.Diagnosis.grid(column=10, row=2) self.close_button = Button(master, text="Close", command=master.quit) self.close_button.grid(column=10, row=3) """self.scrollbar = Scrollbar(master) self.scrollbar.grid(column=5)""" def mlalgo(self): import pandas as pd import numpy as np # importing data dataset = pd.read_csv('Training.csv') dataset1 = pd.read_csv('Testing.csv') # matrix of features X_train = dataset.iloc[:, 0:-1].values Y_train = dataset.iloc[:, 132] X_test = dataset1.iloc[:, 0:-1].values Y_test = dataset1.iloc[:, 132] # categorizing the data from sklearn.preprocessing import LabelEncoder lblenc_train = LabelEncoder() lblenc_test = LabelEncoder() lblenc_train.fit_transform(Y_train) lblenc_test.fit_transform(Y_test) from sklearn.tree import DecisionTreeClassifier # create naive byes object nB = DecisionTreeClassifier(criterion='entropy') # train the model using the training sets nB.fit(X_train, Y_train) # making predictions on the testing set y_pred = nB.predict(X_test) # processing user data to make it fit in algorithm arr = np.asarray(self.Sym) mat = np.zeros((132, 132), dtype=int) mat[0] = arr # print(mat) new_df = pd.DataFrame(columns=self.symptoms, data=mat) print(new_df) new_df1 = pd.DataFrame() new_df1 = new_df[0:1] print(new_df1) # making prediction on user data Y_check = nB.predict(new_df1) print(Y_check) self.result = Y_check[0] def diagnosis(self): print("keep calm nothing serious!") for i in range(0, 132): if self.symp_val[i].get() == 1: self.Sym[i] = 1 self.disp() self.mlalgo() variable = messagebox.askquestion('your diaganosis', self.result) if variable: self.master.quit() def disp(self): print(len(self.Sym)) def dataloading(self): import pandas as pd dataset = pd.read_csv('Training.csv') self.symptoms = list(dataset) self.symptoms = self.symptoms[:-1] print(len(self.symptoms)) # crating numeric array which is checked in model for i in range(0, 132): #print(i) self.Sym.append(0)
def __init__(self, master, songfile): self.songfile = songfile self.master = master self.width = master.winfo_screenwidth() self.height = master.winfo_screenheight() if self.width > self.height: self.width = self.width * 2 / 5 else: self.width = self.width * 2 / 3 self.height = self.height * 2 / 3 # self.master.geometry(str(int(self.width)) + 'x' + str(int(self.height))) frame = Frame(self.master) self.fsongs = fsongs.friskissongs() self.fsongs.loadSongsFromYaml(songfile) self.master.title("Friskismusik") # bpm search critera bpmwin = LabelFrame(self.master, text="BPM sökning", padx=5, pady=3) bpmwin.pack(padx=10, pady=10) lab = Label(bpmwin, text="BPM", width=20, height=2) lab.grid(row=0, column=0) self.bpm = Entry(bpmwin, width=20) self.bpm.grid(row=1, column=0) self.bpm.focus_set() self.bpm.delete(0, END) self.bpm.insert(0, "0") lab = Label(bpmwin, text="BPM tolerans", width=10, height=2) lab.grid(row=0, column=1) self.bpmtol = Entry(bpmwin, width=10) self.bpmtol.grid(row=1, column=1) self.bpmtol.focus_set() self.bpmtol.delete(0, END) self.bpmtol.insert(0, "5") self.showused = StringVar() check = Checkbutton(bpmwin, text='Visa använda', variable=self.showused) check.grid(row=0, column=2) check.deselect() self.doublebpm = StringVar() check = Checkbutton(bpmwin, text='Visa Dubbla BPM', variable=self.doublebpm) check.grid(row=1, column=2) check.deselect() # artist seach artistwin = LabelFrame(self.master, text="Sång preferenser", padx=5, pady=3) artistwin.pack(padx=10, pady=10) lab = Label(artistwin, text="Artist", width=10, height=2) lab.grid(row=0, column=0) self.artist = Entry(artistwin, width=30) self.artist.grid(row=1, column=0) self.artist.focus_set() self.artist.delete(0, END) self.artist.insert(0, "") lab = Label(artistwin, text="Song", width=10, height=2) lab.grid(row=0, column=1) self.song = Entry(artistwin, width=30) self.song.grid(row=1, column=1) self.song.focus_set() self.song.delete(0, END) self.song.insert(0, "") # typer typewin = LabelFrame(self.master, text="Typ av musik", padx=5, pady=3) typewin.pack(padx=10, pady=10) lab = Label(typewin, text="Passar till", width=20, height=2) lab.grid(row=0, column=0) StringVar, Checkbutton, OptionMenu self.fitsfor = StringVar() self.fitsfor.set('Välj Block') fitsforlist = OptionMenu(typewin, self.fitsfor, *set(jtypes.blocktypes + ['Välj Block'])) fitsforlist.grid(row=1, column=0) lab = Label(typewin, text="Genre", width=20, height=2) lab.grid(row=0, column=1) self.genre = StringVar() self.genre.set('Välj Genre') genrelist = OptionMenu(typewin, self.genre, *set(jtypes.genres + ['Välj Genre'])) genrelist.grid(row=1, column=1) searchwindow = LabelFrame(self.master, text="Val", padx=1, pady=3) searchwindow.pack(padx=10, pady=10) Button(searchwindow, text="Sök", width=15, height=2, command=self.search).grid(row=0, column=0) Button(searchwindow, text="Lägg till låt", width=15, height=2, command=self.add_song).grid(row=0, column=1) Button(searchwindow, text="Välj från låtlista", width=15, height=2, command=self.from_list).grid(row=0, column=2) Button(searchwindow, text="Stäng", width=15, height=2, command=frame.quit).grid(row=0, column=3)
class ControlAnnouncement: def __init__(self, parent): self.announcement = Announcement( sorted(list(users.keys()))[0], sorted(list(mail.keys()))[0]) self.initializeGui(parent) def initializeGui(self, parent): self.parent = parent self.frame = Frame(self.parent) self.frame.grid(column=0, row=0) Label(self.frame, text="User").grid(row=0, sticky=W) Label(self.frame, text="Type").grid(row=1, sticky=W) userList = sorted(list(users.keys())) self.comboBoxUser = Combobox(self.frame, state="readonly", width=20, values=userList) self.comboBoxUser.set(userList[0]) self.comboBoxUser.grid(row=0, column=1, sticky=W) self.comboBoxUser.bind('<<ComboboxSelected>>', self.updateUser) announcementTypes = sorted(list(mail.keys())) self.comboBoxType = Combobox(self.frame, state="readonly", width=35, values=announcementTypes) self.comboBoxType.set(announcementTypes[0]) self.comboBoxType.grid(row=1, column=1, sticky=W) self.comboBoxType.bind('<<ComboboxSelected>>', self.updateType) self.scolledText = ScrolledText(self.frame, wrap=WORD, width=80, height=15) self.scolledText.grid(row=2, column=1, columnspan=2) self.scolledText.config(state=NORMAL) self.scolledText.insert(INSERT, self.announcement.message.as_string()) self.scolledText.config(state=DISABLED) self.buttonSendTestMail = Button(self.frame, text='Send Test Mail', command=self.sendTestMail) self.buttonSendTestMail.grid(row=4, column=1) self.buttonSendMail = Button(self.frame, text='Send Mail', command=self.sendMail) self.buttonSendMail.grid(row=4, column=2) self.checkButtonAttachmentAvailable = Checkbutton( self.frame, text="Attachments available") self.checkButtonAttachmentAvailable.grid(row=3, sticky=W) self.checkAttachments() def checkAttachments(self): key = self.announcement.getAttachmentKey() print("Info: Attachment key is " + str(key)) self.checkButtonAttachmentAvailable.config(state=NORMAL) if key is None: self.checkButtonAttachmentAvailable.deselect() self.buttonSendTestMail.config(state=NORMAL) self.buttonSendMail.config(state=NORMAL) else: if not self.announcement.attachmentsMissing(): self.checkButtonAttachmentAvailable.select() self.buttonSendTestMail.config(state=NORMAL) self.buttonSendMail.config(state=NORMAL) else: self.checkButtonAttachmentAvailable.deselect() # self.buttonSendTestMail.config(state=DISABLED) self.buttonSendMail.config(state=DISABLED) self.checkButtonAttachmentAvailable.config(state=DISABLED) def updateUser(self, *args): print(__class__.__name__ + "::" + sys._getframe().f_code.co_name) self.announcement.setUser(self.comboBoxUser.get()) self.scolledText.config(state=NORMAL) self.scolledText.delete(1.0, END) self.scolledText.insert(INSERT, self.announcement.message.as_string()) self.scolledText.config(state=DISABLED) self.checkAttachments() def updateType(self, *args): print(__class__.__name__ + "::" + sys._getframe().f_code.co_name) self.announcement.setMailType(self.comboBoxType.get()) self.scolledText.config(state=NORMAL) self.scolledText.delete(1.0, END) self.scolledText.insert(INSERT, self.announcement.message.as_string()) self.scolledText.config(state=DISABLED) self.checkAttachments() def sendTestMail(self): print(__class__.__name__ + "::" + sys._getframe().f_code.co_name) self.announcement.sendTestMail() def sendMail(self): print(__class__.__name__ + "::" + sys._getframe().f_code.co_name) pwDialog = PasswordDialog( self.frame, title=self.announcement.getFullAddressList()[0]) # print(pwDialog.result) if pwDialog.result: self.announcement.attach() self.announcement.sendMail(pwDialog.result) self.announcement.renderMessage()
check_button2 = Checkbutton(root, text="Квадрат", variable=var1, onvalue="square", offvalue="-") check_button3 = Checkbutton(root, text="Треугольник", variable=var2, onvalue="triangle", offvalue="-") list_box = Listbox(root, height=3) button = Button(root, text="Получить значения") button.bind('<Button-1>', result) check_button1.deselect() # "по умолчанию" флажки сняты check_button2.deselect() check_button3.deselect() v = StringVar() ent1 = Entry(root, textvariable=v, bg="black", fg="white") ent2 = Entry(root, textvariable=v) ent1.pack() ent2.pack() check_button1.pack() check_button2.pack() check_button3.pack() button.pack() list_box.pack()