def load_to_serv(self): """ Загрузить что-то на сервер """ try: file_name: str = filedialog.askopenfilename( initialdir="/home/snorcros", title="Select a File", filetypes=(("Text files", "*.txt*"), ("all files", "*.*"))) if file_name: print(file_name) progressbar = Progressbar(self, orient='horizontal', length=200, mode='indeterminate') progressbar.grid(row=2, column=2) progressbar.config(maximum=100, value=0) load_thread = threading.Thread(target=self.client.load, args=(file_name, )) load_thread.start() progressbar.start(interval=50) while load_thread.is_alive(): self.master.update_idletasks() time.sleep(0.05) file_name = file_name.split(sep='/')[-1] progressbar.stop() progressbar.destroy() ft_done("File " + file_name + " was load to server") self.add_file_to_root(file_name) except ConnectionResetError: ft_error("Server died :c") self.disconnect() except Exception as e: ft_error(e)
def save(self, file_name, row): """ Скачать что-то с сервера """ try: path: str = filedialog.askdirectory( initialdir="/home/snorcros", title="Select a dir for download", mustexist=1) if path: progressbar = Progressbar(self, orient='horizontal', length=150, mode='indeterminate') progressbar.grid(row=row, column=4) progressbar.config(maximum=100, value=0) save_thread = threading.Thread(target=self.client.save, args=(file_name, path)) save_thread.start() progressbar.start(interval=50) while save_thread.is_alive(): self.master.update_idletasks() time.sleep(0.05) progressbar.stop() progressbar.destroy() ft_done("File " + file_name + " was download to " + path) except ConnectionResetError: ft_error("Server died :c") self.disconnect() except Exception as e: ft_error(e)
class SomeClass1(threading.Thread): def __init__(self, q, root, total_rows, loop_time=1.0 / 60): self.q = q self.timeout = loop_time self.total_rows = 50 self.root1 = tk.Tk() self.root_ref = root self.processed = 0 self.progress = Progressbar(root, orient=HORIZONTAL, variable=1, length=120) self.progress.config(maximum=MAX, mode='determinate', value=1) self.progress.step(1) self.progress.grid(row=0, column=1) super(SomeClass1, self).__init__() def onThread(self, function, *args, **kwargs): self.q.put((function, args, kwargs)) def run(self): while True: try: function, args, kwargs = self.q.get(timeout=self.timeout) function(*args, **kwargs) print("run processed") except queue.Empty: self.idle() print("run empty") def idle(self): # put the code you would have put in the `run` loop here print("idle") self.progress = Progressbar(self.root_ref, orient=HORIZONTAL, variable=self.processed, length=120) self.progress.config(maximum=MAX, mode='determinate', value=1) def doSomething(self, processed_row): global processed print("waiting in increment_progress_bar...", processed_row, ":", self.total_rows) #int_processed_row = int(processed_row,10) if (processed_row >= self.total_rows): print("in progress stop") self.progress.stop() self.progress.grid_forget() else: print("in progress step") #self.progress.step(processed_row) self.processed = processed_row print("updated progress bar...") def doSomethingElse(self, b): print("doSomethingElse", b) self.progress.step(1) time.sleep(2)
def Progress(root, **options): progress = Progressbar(root, orient=HORIZONTAL, length=100, mode='determinate') props = {'value': 20} props.update(**options) progress.config(props) progress.pack()
class Loading_class: def __init__(self): self.top = Tk() self.top.geometry("791x376+268+88") self.top.title("BANKING SOLUTIONS") self.top.configure(background="#FFFFCC") self.Label1 = Label(self.top) self.Label1.place(relx=0.24, rely=0.0, height=82, width=443) self.Label1.configure(background="#FFFFCC") img1 = ImageTk.PhotoImage(Image.open("images/rahul2.jpg")) self.Label1.configure(image=img1) self.v1 = IntVar() #it will hold the current value of progress bar self.Label2 = Label(self.top) self.Label2.place(relx=0.08, rely=0.43, height=41, width=374) self.Label2.configure(background="#FFFFCC") self.Label2.configure(width=374) self.pb = Progressbar(self.top, orient=HORIZONTAL) self.pb.config(mode='determinate', maximum=100) self.pb.config(variable=self.v1) self.pb.place(relx=0.08, rely=0.56, relwidth=0.87, relheight=0.0, height=22) self.pb.configure(length="690") tup = (101, ) self.t1 = threading.Thread(target=self.move, args=tup, name='first') self.t1.start() self.top.after(500, self.check) self.top.mainloop() def move(self, a): for i in range(a): self.v1.set(i) self.Label2.configure(text='LOADING ' + str(self.v1.get()) + '%') time.sleep(.05) def check(self): if self.v1.get() != 100: self.top.after(500, self.check) else: self.top.destroy() o1 = Login.Login_Class() #obj = Loading_class()
def progress(self, column, thread): progressbar = Progressbar(self, orient='horizontal', length=150, mode='indeterminate') progressbar.grid(column=column) progressbar.config(maximum=100, value=0) progressbar.start() while thread.is_alive(): self.master.update_idletasks() time.sleep(0.05) progressbar.stop() progressbar.destroy()
class PantallaEsperaView(View): def __init__(self, controller): super().__init__(Toplevel(), controller) self.construir_main_frame() self.construir_progressbar_frame() self.ocultar_vista() def configurar_root(self): super(PantallaEsperaView, self).configurar_root() self.root.geometry("250x150") def construir_main_frame(self): self.main_frame = Frame(self.root) self.main_frame.pack() def construir_progressbar_frame(self): self.label = Label(self.main_frame) self.label.config(pady=20, padx=20, font=("Helvetica", 10)) self.label.grid(row=0, column=0) self.pb_frame = Frame(self.main_frame) self.pb_frame.config(padx=20, pady=20) # self.pb_frame.grid(row=1, column=0) self.progressbar = Progressbar(self.pb_frame) self.progressbar.config(mode="indeterminate", length=150) self.progressbar.pack() def ocultar_vista(self): self.progressbar.stop() super(PantallaEsperaView, self).ocultar_vista() self.pb_frame.grid_remove() def mostrar_vista(self): self.pb_frame.grid(row=1, column=0) super(PantallaEsperaView, self).mostrar_vista() self.progressbar.start(10)
class loading: def __init__(self): self.root = Tk() self.root.geometry("550x400+200+125") self.root.resizable(False, False) self.l1 = Label(self.root, text="Welcome to Banking Solutions") self.i1 = ImageTk.PhotoImage(Image.open("images\\logo1edited.png")) self.l1.config(image=self.i1) self.l1.pack(fill="both", expand="True") self.v1 = IntVar() self.pb = Progressbar(self.root, orient=HORIZONTAL, length=550) self.pb.pack() self.pb.config(mode="determinate", maximum=100) self.pb.config(variable=self.v1) tup = (100, ) self.t1 = threading.Thread(target=self.show, args=tup, name="update_progress_bar") self.t1.start() self.root.after(500, self.check()) self.root.mainloop() def check(self): if int(self.v1.get()) == 100: self.root.destroy() obj2 = Login.Login_class1() else: self.root.after(500, self.check) def show(self, a): for i in range(a + 1): self.v1.set(i) time.sleep(0.05)
def makeModel(window): ProblemSelect = page(window, 'Problem Type') ProblemSelect.pack() problemType = StringVar(value="Text (Classification) -- Default") continueVar = BooleanVar() explanationBox = Label(ProblemSelect.contentFrame) problemTypeChoices = { 'Numbers (Regression)': 'Numerical data with continuous numerical output e.g. stock market data', 'Numbers (Classification)': 'Numerical data with fixed outputs e.g even and odd numbers', 'Text (Regression)': 'Text data with continuous numerical output e.g sentiment analysis', 'Text (Classification) -- Default': 'Text data with fixed outputs e.g spam filtering. Default option' } for choice, description in problemTypeChoices.items(): option = Radiobutton(ProblemSelect.contentFrame, text=choice, variable=problemType, value=choice, command=lambda description=description: explanationBox.config(text=description)) option.grid(column=0, sticky='w', padx=5, pady=5) map(lambda x: x.deselect(), list(ProblemSelect.contentFrame.children.values())) list(ProblemSelect.contentFrame.children.values())[-1].invoke() explanationBox.grid(column=1, row=3, sticky='e') nxtBtn = Button(ProblemSelect.contentFrame, text="next", command=lambda: continueVar.set(True)) nxtBtn.grid(column=1, columnspan=2, padx=10, ipadx=30, ipady=5) ProblemSelect.wait_variable(continueVar) ProblemSelect.pack_forget() # select which columns to use DataCollecting = page(window, 'Select Training Data') DataCollecting.pack() # load data fileNotLoaded = True counter = 0 while fileNotLoaded: if counter == 10: messagebox.showerror(title='Error', message=retryError) sys.exit() try: counter += 1 filename = askopenfilename(title='Choose Training Data', filetypes=dataFiletypes) if path.splitext(filename)[1].lower() == '.csv': trainingDataDF = read_csv(filename) else: trainingDataDF = read_excel(filename) # If you didn't clean your data, I'm just going to destroy it. Serves you right. trainingDataDF = trainingDataDF.apply( lambda x: x.interpolate(method='pad')) trainingDataDF = trainingDataDF.dropna(how='any') if len(trainingDataDF.index) < 50: raise ValueError( ': Not enough data. Have to have at least 50 samples of data.\n' 'If you think you have enough, it might be because there were' 'invalid values that were automatically taken out.') except Exception as e: messagebox.showerror(title='Error', message=str(type(e)).split('\'')[1] + str(e)) continue fileNotLoaded = False # listbox with all the column names columnListbox = ScrollingListbox(DataCollecting.contentFrame, 20) columnListbox.grid(column=0, row=0, rowspan=8, padx=10, pady=10, sticky='ns') for columName in trainingDataDF.columns: columnListbox.listbox.insert('end', columName) featureListbox = ScrollingListbox(DataCollecting.contentFrame) featureListbox.grid(column=2, row=0, rowspan=4, padx=10, pady=10) featureAddButton = Button( DataCollecting.contentFrame, text='Add >>>', command=lambda: addToListBox(columnListbox, featureListbox)) featureAddButton.grid(column=1, row=1) featureRemoveButton = Button( DataCollecting.contentFrame, text='<<< Remove', command=lambda: deleteFromListBox(featureListbox)) featureRemoveButton.grid(column=1, row=2) targetListbox = ScrollingListbox(DataCollecting.contentFrame) targetListbox.grid(column=2, row=4, rowspan=4, padx=10, pady=10) targetAddButton = Button( DataCollecting.contentFrame, text='Add >>>', command=lambda: addToListBox(columnListbox, targetListbox)) targetAddButton.grid(column=1, row=5) targetRemoveButton = Button( DataCollecting.contentFrame, text='<<< Remove', command=lambda: deleteFromListBox(targetListbox)) targetRemoveButton.grid(column=1, row=6) collectDataButton = Button( DataCollecting.contentFrame, text='Create', command=lambda: continueVar.set(True) if len(featureListbox.listbox.get(0, 'end')) > 0 and len( targetListbox.listbox.get(0, 'end') ) > 0 else messagebox.showwarning( title='Warning', message='You must have at least one feature and one target')) collectDataButton.grid(column=2, row=8, pady=20, ipadx=20) DataCollecting.wait_variable(continueVar) DataCollecting.pack_forget() creating = page(window, 'Creating') creating.pack() progress = Progressbar(creating.contentFrame) progress.pack() progress.config(mode='indeterminate') progress.start() sleep(2) featureColumnNames = featureListbox.listbox.get(0, 'end') targetColumnNames = targetListbox.listbox.get(0, 'end') featureTrain = trainingDataDF[list(featureColumnNames)] targetTrain = trainingDataDF[list(targetColumnNames)] featureEncoder = LabelEncoder() targetEncoder = LabelEncoder() if 'Text' in problemType.get(): featureEncoder.fit( array(list( set(featureTrain.to_numpy().flatten().tolist()))).reshape( -1, 1).ravel()) featureTrain = featureTrain.applymap( lambda x: featureEncoder.transform(array(x).reshape(1, 1))[0]) if 'Classification' in problemType.get(): targetEncoder.fit( array(list( set(targetTrain.to_numpy().flatten().tolist()))).reshape( -1, 1).ravel()) targetTrain = targetTrain.applymap( lambda x: targetEncoder.transform(array(x).reshape(1, 1))[0]) model = chooseAlgorithm(problemType.get(), featureTrain, targetTrain) progress.stop() progress.pack_forget() modelname = str(model.__class__).split('.')[-1][:-2] filename = modelname + ' ' + datetime.now().strftime("%Y-%m-%d-%H-%M-%S") fileNotLoaded = True counter = 0 while fileNotLoaded: if counter == 10: messagebox.showerror(title='Error', message=retryError) sys.exit() try: counter += 1 filepath = asksaveasfilename( initialfile=filename, defaultextension='.mlmc', filetypes=[('Edward Machine Learning Creater Model', '*.emlcm') ], title='Save As') dump([ model, problemType.get(), featureEncoder, targetEncoder, featureTrain.columns, targetTrain.columns ], filepath, 5) except Exception as e: messagebox.showerror(title='Error', message=str(type(e)).split('\'')[1] + str(e)) continue fileNotLoaded = False backButton = Button( creating.contentFrame, text='Back to Home Page', font=('Helvetica', 30), command=lambda: [continueVar.set(True), creating.destroy(), HomePage(window)]) backButton.pack(pady=20) quitButton = Button( creating.contentFrame, text='Quit', font=('Helvetica', 30), command=lambda: [continueVar.set(True), window.destroy()]) quitButton.pack(pady=20) creating.wait_variable(continueVar)
class UploadItem(CanvasItem): def __init__(self, qcopyoverpc, name="<UNKNOWN>", description="<UNKNOWN>", **kw): if qcopyoverpc is None: raise ValueError("qcopyoverpc must be specified.") title = "Upload" super().__init__(qcopyoverpc.frames[-1], **kw) title_font = ("Helvetica", 20) info_font = ("Helvetica", 10) # noinspection PyProtectedMember self._id = qcopyoverpc._id self.canvass = qcopyoverpc.canvass self.names = qcopyoverpc.names self.frames = qcopyoverpc.frames self.onError: Callable[[Exception], None] = lambda exc: None self.onComplete: Callable[[], None] = lambda: None self.canvass.append(self) # canv: Canvas = self.canvass[-1] self._id[self.canvass[-1]] = {} self.title = self._id[ self.canvass[-1]]["Title"] = self.canvass[-1].create_text( 10, 10, text=title, fill="#bfbfbf", anchor="nw", font=title_font) self.name = self._id[ self.canvass[-1]]["Filename"] = self.canvass[-1].create_text( 10, 40, text=name, fill="#bfbfbf", anchor="nw", font=info_font) self.desc = self._id[ self.canvass[-1]]["Description"] = self.canvass[-1].create_text( 10, 60, text=description, fill="#bfbfbf", anchor="nw", font=info_font) self.canvass[-1].create_rectangle(-1, 0, 790, 149, outline="#676767") self.canvass[-1].bind( "<ButtonRelease-1>", lambda event, c=self.canvass[-1]: self._on_canvas_l_click(c)) # self.canvass[-1].bind("<Double-Button-1>", lambda event, n_=name: self.open_direct(n_)) self.canvass[-1].bind( "<Motion>", lambda event, c=self.canvass[-1]: self._on_canvas_motion(c)) self.canvass[-1].bind( "<Leave>", lambda event, c=self.canvass[-1]: self._on_canvas_leave(c)) self.progressbar = Progressbar(self.frames[-1], maximum=10, value=0) self.create_window(10, 110, window=self.progressbar, width=770, height=30, anchor="nw") self.names[self.canvass[-1]] = name def set_description(self, text: str): self.itemconfigure(self.desc, text=text) def set_title(self, text: str): self.itemconfigure(self.title, text=text) def update_progress(self, value: int): self.progressbar.config(value=value) def set_file_size(self, size: int): self.progressbar.config(maximum=size) def set_color(self, color: ColorType) -> None: """ @param color: the color """ if color == ColorType.ERROR: background = "#7f0000" text = "#bf0000" elif color == ColorType.WARNING: background = "#7f3f00" text = "#bf5f00" elif color == ColorType.INFO: background = "#00007f" text = "#0000bf" elif color == ColorType.SUCCESS: background = "#007f00" text = "#00bf00" else: background = "7f7f7f" text = "#bfbfbf" self.configure(bg=background) self.itemconfig(self.title, fill=text) self.itemconfig(self.desc, fill=text) self.itemconfig(self.name, fill=text)
def addDownloadItem(url): if url != None: req = requests.get(url, stream=True) if "Content-Length" in req.headers: total_size = req.headers['Content-Length'] else: total_size = None if "Content-Disposition" in req.headers.keys(): fname = re.findall("filename=(.+)", req.headers["Content-Disposition"])[0] else: fname = url.split("/")[-1] progress = Progressbar(root) progress['value'] = 0 progress.place(x=10, column=100, sticky="nsew", mode="intermediate") labelPercentage = Label(root, text="0 %", padx="5", anchor="w", bg="#E67E22", fg="white") labelPercentage.grid(row=0, column=2) labelsize = Label(root, text="0 KB", padx="5", anchor="w", bg="#E67E22", fg="white") labelsize.grid(row=1, column=2) with open(fname, "wb") as obj: for chunk in req.iter_content(chunk_size=1024): if chunk: obj.write(chunk) current_size = os.path.getsize(fname) labelsize.config(text=str(getStandardSize(current_size))) if total_size != None: percentge = round( (int(current_size) / int(total_size)) * 100) labelPercentage.config(text=str(percentge) + " %") progress['value'] = percentge else: percentge = "Infinte" progress.config(mode="indeterminate") progress.start() labelPercentage.config(text=str(percentge) + " %") if total_size != None: current_size = os.path.getsize(fname) labelsize.config(text=str(getStandardSize(current_size))) labelPercentage.config(text=str(percentge) + " %") percentge = round((int(current_size) / int(total_size)) * 100) progress['value'] = percentge else: current_size = os.path.getsize(fname) labelsize.config(text=str(getStandardSize(current_size))) labelPercentage.config(text="100 %") progress['value'] = 100
class Gui: def __init__(self, master=None): self.master = Tk() if not master else master self.master.title("Book Finder") self.master.resizable(0, 0) #We change the window icon directly with Tk self.master.tk.call('wm', 'iconphoto', self.master, '::tk::icons::question') self.stext = ScrolledText(master=self.master, bg='white', height=25, width=100) #We disable the edition self.stext.config(state="disabled") menu = Menu() menu_tools = Menu(tearoff=0) menu_tools.add_command(label="Search book", command=lambda: self.search_book()) menu_tools.add_command(label="Exit", command=self.master.destroy) menu.add_cascade(label="Menu", menu=menu_tools) menu_option = Menu(tearoff=0) menu_option.add_checkbutton( label="Don't download img", command=lambda: self.cmd2() if self.cmd2 else print("cmd2 not configured")) menu.add_cascade(label="Option", menu=menu_option) #We create a message box with Tk menu.add_command( label="About", command=lambda: self.master.tk.eval( "tk_messageBox -message {Book Finder} -detail {Make by pythonbrad} -icon info -title About" )) self.master.config(menu=menu) self.stext.pack() #This widget will print status self.label_status = Label(self.master, text="STATUS", font=('Arial', 14)) self.label_status.pack() self.progress_bar = Progressbar() self.progress_bar.pack() self.is_searching = False #It will contains widget in memory self.temp = [] #It will contains an external function #Who will be used by the function search_book self.cmd1 = None self.cmd2 = None def insert_img(self, data): #We convert image date in tk image data self.stext.image_create(END, image=self.get_img_tk(data)) def insert_text(self, text, tag=None): #We insert the text self.stext.config(state="normal") self.stext.insert(END, text, tag) self.stext.config(state="disabled") def create_tag(self, tag_name, **args): self.stext.tag_config(tag_name, **args) def get_img_tk(self, data): img = ImageTk.PhotoImage(data=data) self.temp.append(img) return img def progress_bar_reset(self, max_value): self.progress_bar.config(max=max_value, value=0) def progress_bar_step(self): self.progress_bar.step(1) def search_book(self): try: self.win_search_book.destroy() except: pass if not self.is_searching: self.win_search_book = Toplevel() self.win_search_book.tk.call('wm', 'iconphoto', self.win_search_book, '::tk::icons::question') Label(self.win_search_book, image='::tk::icons::question').pack() Label(self.win_search_book, text="Enter a keyword").pack() search_entry = Entry(self.win_search_book) search_entry.pack() def _(self, search_entry): #the data will return in the arg data to this command self.cmd1(search_entry.get()) self.win_search_book.destroy() Button( self.win_search_book, text="Search", #We given the self and the search text #The self will give the access to this object command=lambda: _(self, search_entry) if self.cmd1 else print("cmd1 not configured")).pack() self.win_search_book.mainloop() else: self.master.tk.eval( "tk_messageBox -message {A research aleady running} -icon warning" ) def update(self): self.master.update() def mainloop(self): self.master.mainloop()
class LoadingScreen(Toplevel): def __init__(self, master, determinate=True, *args, **kwargs): self._queue = queue.Queue() super().__init__(master, *args, **kwargs) self.withdraw() # if master.winfo_viewable(): # self.transient(master) # style = Style() # style.configure('LoadingScreen.TFrame', padding=0, bg='black') self.determinate = determinate self.columnconfigure(0, weight=1) self.rowconfigure(0, weight=1) self.frm_border = Frame(self, borderwidth=2, relief=SOLID) self.frm_border.columnconfigure(0, weight=1) self.frm_border.rowconfigure(0, weight=1) self.frm_border.grid(sticky='nsew') self.frm = Frame(self.frm_border) self.frm.grid(row=0, column=0, padx=20, pady=20, sticky='nsew') self.lbl_info = Label(self.frm) self.frm.columnconfigure(0, weight=1, minsize=250) self.lbl_info.grid(row=0, column=0, sticky='ew') pb_mode = 'determinate' if self.determinate else 'indeterminate' self.pb_progress = Progressbar(self.frm, mode=pb_mode) self.pb_progress.grid(row=1, column=0, sticky='ew') self.update_idletasks() self.wm_overrideredirect(1) self.master.bind('<Configure>', self.updatePosition, add='+') self.updatePosition() self.deiconify() self.wait_visibility() self.grab_set() self.focus_set() if not self.determinate: # self.pb_progress.config(mode='determinate') self.pb_progress.start(10) self.after(10, self.processMessages) def updatePosition(self, event=None): if self.winfo_exists(): self.update_idletasks() x = self.master.winfo_rootx() + self.master.winfo_width() / 2 - self.winfo_width() / 2 y = self.master.winfo_rooty() + self.master.winfo_height() / 2 - self.winfo_height() / 2 self.geometry('+%d+%d' % (x, y)) def processMessages(self): try: while True: type, args = self._queue.get_nowait() if type == _MSG_UPDATE: text, progress = args self.lbl_info.config(text=text) if self.determinate: self.pb_progress.config(value=progress) elif type == _MSG_CLOSE: self.destroy() elif type == _MSG_NOTIFY: title, message = args messagebox.showwarning(title, message, parent=self) except queue.Empty: pass self.after(100, self.processMessages) def close(self): self._queue.put((_MSG_CLOSE, None)) def updateStatus(self, text, progress=0): self._queue.put((_MSG_UPDATE, (text, progress))) def notifyMessage(self, title, message): self._queue.put((_MSG_NOTIFY, (title, message)))
class OptimizeGroup(Group): def __init__(self, *args, **kwargs): self._app = kwargs.pop('wavesyn_root') self.__topwin = kwargs.pop('topwin') super().__init__(*args, **kwargs) parameter_frame = Frame(self) parameter_frame.pack(side='left', expand='yes', fill='y') self.__num = LabeledEntry(parameter_frame) set_attributes(self.__num, label_text = 'num', entry_text = '1', label_width = 5, entry_width = 8, checker_function = self._app.gui.value_checker.check_int ) self.__num.entry.bind('<Return>', lambda event: self._on_solve_click()) self.__num.pack(side='top') self.__pci = LabeledEntry(parameter_frame) set_attributes(self.__pci, label_text = 'PCI', entry_text = '100', label_width = 5, entry_width = 8, checker_function = self._app.gui.value_checker.check_int ) self.__pci.pack(side='top') self.__parallel_checker_variable = IntVar() self.__parallel_checker = Checkbutton(parameter_frame, text="Parallel", variable=self.__parallel_checker_variable, command=self._on_parallel_checker_click) self.__parallel_checker.pack() progfrm = Frame(self) progfrm.pack(side='left', expand='yes', fill='y') self.__genbtn = Button(progfrm, text='Generate', command=self._on_solve_click) self.__genbtn.pack(side='top') Button(progfrm, text='Stop', command=self._on_stop_button_click).pack(side='top') self.__progressbar_variable = IntVar() self.__finishedwav = IntVar() self.__progressbar = Progressbar(progfrm, orient='horizontal', variable=self.__progressbar_variable, maximum=100) self.__progressbar.pack(side='left') self.__progressbar.config(length=55) self.__finishedwavbar = Progressbar(progfrm, orient='horizontal', variable=self.__finishedwav) self.__finishedwavbar.pack(side='left') self.__finishedwavbar.config(length=30) self.name = 'Generate' self.getparams = None self.__stopflag = False def _on_solve_click(self): params = self.__topwin.parameter_group.get_parameters() repeat_times = self.__num.get_int() if self.__parallel_checker_variable.get(): run = self.__topwin.current_algorithm.process_run else: run = self.__topwin.current_algorithm.thread_run with code_printer(): run(on_finished=['store', 'plot'], progress_indicator='progress_dialog', repeat_times=repeat_times, **params) def _on_stop_button_click(self): self.__stopflag = True def _on_parallel_checker_click(self): topwin = self.__topwin if topwin.current_algorithm.need_cuda: self.__parallel_checker_variable.set(0) topwin.root_node.gui.dialogs.report(f'''{topwin.node_path}: Current algorithm "{topwin.current_algorithm.meta.name}" need CUDA worker, which does not support multi-cpu parallel. ''') def _cancel_parallel(self): self.__parallel_checker_variable.set(0)
class BulkDownloader(object): def __init__(self, window, running, data, count, progress_value): # variables self.running = running self.data = data self.count = count self.progress_value = progress_value # master/parent window contains all gui elements self.window = window window.title("TNRIS DataHub Bulk Download Utility") # frame variables - parent is window self.top_frame = tk.Frame(window, borderwidth=10) self.middle_frame_1 = tk.Frame(window, borderwidth=10) self.middle_frame_2 = tk.Frame(window, borderwidth=10) self.middle_left_frame_2 = tk.Frame(self.middle_frame_2, borderwidth=10) self.middle_left_frame_2.pack(side='left', expand=1) self.middle_right_frame_2 = tk.Frame(self.middle_frame_2, borderwidth=10) self.middle_right_frame_2.pack(side='right', expand=1) self.middle_frame_3 = tk.Frame(window, borderwidth=10, padx=10) self.middle_frame_4 = tk.Frame(window, borderwidth=10) self.bottom_frame = tk.Frame(window, borderwidth=10, pady=10) self.frame_list = [ self.top_frame, self.middle_frame_1, self.middle_frame_2, self.middle_frame_3, self.middle_frame_4, self.bottom_frame ] # for loop to pack all frames for f in self.frame_list: f.pack(fill='both') # label variables self.label_1 = tk.Label(self.top_frame, text="Enter a TNRIS DataHub Collection ID: ") self.label_2 = tk.Label(self.middle_frame_1, text="If the collection entered has multiple resource types, filter them here.") self.label_3 = tk.Label(self.middle_frame_1, text="No filter selection will result in all collection resources downloaded.") self.label_list = [self.label_1, self.label_2, self.label_3] # for loop to configure all labels with font for l in self.label_list: l.configure(font=('Courier', 10, 'bold')) l.pack(fill='both') # collection id entry self.collection_id = tk.Entry(self.top_frame, width=45, font=('Courier', 10)) self.collection_id.pack() self.collection_id.focus() self.label_4 = tk.Label(self.top_frame, text="Browse to a directory where you can save your downloaded data.") self.label_5 = tk.Label(self.middle_left_frame_2, text="Lidar") self.label_6 = tk.Label(self.middle_right_frame_2, text="Imagery") self.lbl_list = [self.label_4, self.label_5, self.label_6] for lbl in self.lbl_list: lbl.config(font=('Courier', 10, 'bold'), pady=10) lbl.pack(fill='both') # resource types check box variables - onvalue string is used in the api query (resource_type_abbreviation) self.type_value = tk.StringVar() self.type_value.set("") self.type_1 = tk.Checkbutton(self.middle_left_frame_2, text="Lidar Point Cloud", var=self.type_value, onvalue="LPC", offvalue="") self.type_2 = tk.Checkbutton(self.middle_left_frame_2, text="Hypsography", var=self.type_value, onvalue="HYPSO", offvalue="") self.type_3 = tk.Checkbutton(self.middle_left_frame_2, text="Digital Elevation Model", var=self.type_value, onvalue="DEM", offvalue="") self.type_placeholder = tk.Label(self.middle_left_frame_2, text="") # this empty label is used for alignment self.type_4 = tk.Checkbutton(self.middle_right_frame_2, text="Color Infrared (3 Band)", var=self.type_value, onvalue="CIR", offvalue="") self.type_5 = tk.Checkbutton(self.middle_right_frame_2, text="Natural Color (3 Band)", var=self.type_value, onvalue="NC", offvalue="") self.type_6 = tk.Checkbutton(self.middle_right_frame_2, text="Natural Color/Color Infrared (4 Band)", var=self.type_value, onvalue="NC-CIR", offvalue="") self.type_7 = tk.Checkbutton(self.middle_right_frame_2, text="Black & White (1 Band)", var=self.type_value, onvalue="BW", offvalue="") self.type_list = [self.type_1, self.type_2, self.type_3, self.type_placeholder, self.type_4, self.type_5, self.type_6, self.type_7] # for loop to pack & configure checkbuttons for t in self.type_list: t.config(font=('Courier', 10)) t.pack(fill="both") # Progress bar widget self.progress = Progressbar(self.middle_frame_3, orient='horizontal') self.progress.pack(fill='both') # Progress bar config self.progress.config(mode='determinate', value=0, maximum=100) # print messages from the downloader method self.display_message_1 = tk.StringVar() self.display_message_2 = tk.StringVar() self.error_message = tk.StringVar() self.display_message_1.set("Messages here provide download progress feedback.") self.message_area_1 = tk.Label(self.middle_frame_4, textvariable=self.display_message_1, font=('Courier', 10)) self.message_area_2 = tk.Label(self.middle_frame_4, textvariable=self.display_message_2, font=('Courier', 10), fg='green') self.message_area_3 = tk.Label(self.middle_frame_4, textvariable=self.error_message, font=('Courier', 10), fg='red') self.message_area_list = [self.message_area_1, self.message_area_2, self.message_area_3] # for loop to pack message areas for a in self.message_area_list: a.pack(fill='both') self.folder_path = tk.StringVar() self.label_4 = tk.Label(self.top_frame, textvariable=self.folder_path) self.label_4.configure(font=('Courier', 10), pady=10) self.label_4.pack(fill='both') # pack buttons that run methods self.browse = tk.Button(self.top_frame, text="Browse", command=self.browse_button) self.browse.pack() self.getdata = tk.Button(self.bottom_frame, text="Get Data", command=self.start) self.getdata.pack(side='right', expand=1) self.stop_it = tk.Button(self.bottom_frame, text="Stop", command=self.stop) self.stop_it.pack(side='left', expand=1) # Allow user to select a directory and store it in global var called folder_path def browse_button(self): self.folder_path self.filename = filedialog.askdirectory() self.folder_path.set(self.filename) print('folder_path variable:', self.folder_path.get()) return self.folder_path # fires the main method on its own separate thread def start(self): self.main_thread = threading.Thread(name='starter', target=self.get_data) self.main_thread.start() # method to set up separate thread and target for kill method # fired when the stop button is clicked def stop(self): self.kill_thread = threading.Thread(name='killer', target=self.kill(self.running)) self.kill_thread.start() # this method changes the running variable from True to None and stops the main # downloader method from running / breaks the for loop when running = None def kill(self, running): response = messagebox.askokcancel(title="Stop Downloading", message="Are you sure you want to stop downloading?") # if ok button clicked to quit, set running var to None which will stop the for loop if response: print("stopping bulk downloader...") self.running = None # method to check if a valid uuid is provided def valid_uuid(self, val): try: UUID(str(val)) return True except ValueError: return False # progress bar update method def p_bar(self, value): self.progress['value'] = value self.progress.update_idletasks() def get_data(self): self.display_message_1.set("Messages here provide download progress feedback.") # reset feedback message self.display_message_2.set("") # reset feedback message self.error_message.set("") # reset any error messages c = self.collection_id.get() t = self.type_value.get() self.count = 0 base_url = "https://api.tnris.org/api/v1/resources/" id_query = "?collection_id=" type_query = "&resource_type_abbreviation=" # area_query = "&area_type=" # first check to make sure the collection id string is a valid using valid_uuid method # then check if the folder_path directory to save the data exists # then assign data variable based on checkbox selections (build the url string requests needs to get data from rest endpoint) if self.valid_uuid(c): if os.path.exists(self.folder_path.get()): if c and not t: # if no selections made, build url string to get all resources for that collection id print('no selections made') self.data = requests.get(base_url + id_query + c).json() elif c and t: # if type selection made but not area, build the url string print('type selection made. type = {}'.format(t)) ''' possible future enhancement here to add ability to handle multiple resource type filters ''' self.data = requests.get(base_url + id_query + c + type_query + t).json() else: # retrun message to the user that there was a problem with the directory chosen to save downloaded data print("Error. Check the directory provided to save data.") self.error_message.set("Error. Check the directory provided to save data.") self.message_area_3.update_idletasks() return else: print("Error. Check the collection id provided.") self.error_message.set("Error. Check the collection id provided.") self.message_area_3.update_idletasks() return # run the downloader method if self.data: self.downloader(self.running, self.data, self.count) def downloader(self, running, data, count): # main method that iterates over api results and downloads collection resources api_num_count = self.data['count'] api_str_count = str(self.data['count']) if self.data['count'] > 0: for obj in self.data['results']: if self.running: try: # count each file written self.count += 1 print("{} | downloading resource id: {}".format(self.count, obj['resource'].rsplit('/', 1)[-1])) # update progress_value variable by dividing new count number by total api object count self.progress_value = round((self.count/api_num_count)*100) # feed new progress value into p_bar function to update gui self.p_bar(self.progress_value) # show display message/text as progress percentage string self.display_message_1.set("{}/{} resources downloaded".format(self.count, api_str_count)) self.display_message_2.set("download progress: " + str(self.progress_value) + "%") # make sure message area/labels are updated self.message_area_1.update_idletasks() self.message_area_2.update_idletasks() # assign next object['resource'] url to file variable if os.path.exists('{}/{}'.format(self.folder_path.get(), obj['resource'].rsplit('/', 1)[-1])): continue file = requests.get(obj["resource"], stream=True) # write file variable to actual local zipfile saving to user provided directory and doing it in chunks with open('{}/{}'.format(self.folder_path.get(), obj['resource'].rsplit('/', 1)[-1]), 'wb') as zipfile: for chunk in file.iter_content(chunk_size=1024): if chunk: zipfile.write(chunk) # sepcific requests library exceptions to catch any errors getting data from the api except requests.exceptions.HTTPError as http_error: print ("http error:", http_error) self.error_message.set("http error: ", http_error) self.message_area_3.update_idletasks() os.remove('{}/{}'.format(self.folder_path.get(), obj['resource'].rsplit('/', 1)[-1])) except requests.exceptions.ConnectionError as connection_error: print ("error connecting:", connection_error) self.error_message.set("error connecting: ", connection_error) self.message_area_3.update_idletasks() os.remove('{}/{}'.format(self.folder_path.get(), obj['resource'].rsplit('/', 1)[-1])) except requests.exceptions.Timeout as timeout_error: print ("timeout error:", timeout_error) self.error_message.set("timeout error: ", timeout_error) self.message_area_3.update_idletasks() os.remove('{}/{}'.format(self.folder_path.get(), obj['resource'].rsplit('/', 1)[-1])) # general catch all requests library exception to catch an error if it is outside the above exceptions except requests.exceptions.RequestException as general_error: print ("OOps, there was some error: ", general_error) self.error_message.set("OOps, there was some error: ", general_error) self.message_area_3.update_idletasks() os.remove('{}/{}'.format(self.folder_path.get(), obj['resource'].rsplit('/', 1)[-1])) else: # if user stops program, display message print("Bulk Downloader stopped.") self.error_message.set("Bulk Downloader stopped.") self.message_area_3.update_idletasks() if os.path.exists('{}/{}'.format(self.folder_path.get(), obj['resource'].rsplit('/', 1)[-1])): os.remove('{}/{}'.format(self.folder_path.get(), obj['resource'].rsplit('/', 1)[-1])) return else: # return a message to the user that there is an error with either the collection id string or the filter applied print("Error. No resource results. Check your collection id or filters applied.") self.error_message.set("Error. No resource results. Check your collection id or filters applied.") self.message_area_3.update_idletasks() # if first page of resources downloaded successfully, run paginator method to see if there are additional pages self.paginator(self.running, self.count) def paginator(self, running, count): # check if next value present for pagination; if so, use it as data variable and re-run downloader method while self.data['next']: self.data = requests.get(self.data['next']).json() count = self.downloader(running, self.data, count)
class TkApp(Tk): """ The main Tk class for the gui of simplebackup """ def __init__(self, **kwargs): super().__init__() title = "Simple Backup | V" + __version__ self.wm_title(title) self.protocol("WM_DELETE_WINDOW", self.on_closing) self.__thread = None self.__files_found = 0 self.__files_copied = 0 config_fn = kwargs.get("config_fn", user_config_filepath()) self.__app_config = Config_Handler(config_fn) self.__curr_config = self.__app_config.default_config_i self.__menu = Menu(self) self.__menu_file = Menu(self.__menu, tearoff=0) self.__menu_file.add_command(label="Quit", command=self.quit) self.__menu_config = Menu(self.__menu, tearoff=0) self.__menu_config.add_command(label="New", command=self.new_config) self.__menu_config.add_command(label="Load", command=self.switch_config) self.__menu_config.add_command(label="Change Default", command=self.change_default_config) self.__menu_config.add_command(label="Rename Current", command=self.rename_curr_conf) self.__menu_config.add_separator() self.__menu_config.add_command(label="Delete Current", command=self.delete_current_config) self.__menu_config.add_command(label="Delete All", command=self.reset_config) self.__menu_help = Menu(self.__menu, tearoff=0) self.__menu_help.add_command(label="Check for Updates", command=self.show_update_popup) self.__menu_help.add_command(label="About", command=self.show_about_popup) self.__menu.add_cascade(label="File", menu=self.__menu_file) self.__menu.add_cascade(label="Config", menu=self.__menu_config) self.__menu.add_cascade(label="Help", menu=self.__menu_help) self.__title_l = Label(self, text=title, font=(16)) self.__curr_config_name_l = Label(self) self.__last_backup_l = Label(self) self.__set_versions_to_keep = Button( self, text="Set Versions To Keep", command=self.update_versions_to_keep) self.__versions_to_keep_l = Label(self) self.__inc_folder_bnt = Button(self, text="Include Another Folder", command=self.add_included_folder) self.__included_folders_lb = Listbox(self, height=4) self.__included_folders_lb.bind("<<ListboxSelect>>", self.remove_selected_included_folder) self.__included_folders_lb.bind('<FocusOut>', self.deselect_included_folder) self.__excl_folder_bnt = Button(self, text="Exclude Another Folder", command=self.add_excluded_folder) self.__excluded_folders_lb = Listbox(self, height=4) self.__excluded_folders_lb.bind("<<ListboxSelect>>", self.remove_selected_excluded_folder) self.__excluded_folders_lb.bind('<FocusOut>', self.deselect_excluded_folder) self.__backup_to_bnt = Button(self, text="Backup Folder", command=self.set_backup_folder) self.__backup_folder_l = Label(self) self.__use_tar_l = Label(self, text="Use Tar") self.__use_tar_var = BooleanVar(self) self.__use_tar_var.trace_add("write", self.use_tar_changed) self.__use_tar = Checkbutton(self, variable=self.__use_tar_var) self.__backup_start_bnt = Button(self, text="Start Backup", command=self.start_backup) self.__progress = Progressbar(self) self.__statusbar = Label(self, text="ok", relief=SUNKEN, anchor=W) self._load_display() self._layout() if self.__app_config.show_help: self.show_help_popup() def on_closing(self): """ called on window close """ if self.__files_found != self.__files_copied: if messagebox.askyesno("Backup Running", "Do you want to stop the backup?"): self.destroy() else: self.destroy() def _load_display(self): """ load the widgets with data from the current backup config, should be run after loading a config from file and at app launch """ self.__versions_to_keep = self.__app_config.get_versions_to_keep( self.__curr_config) self.__included_folders = self.__app_config.get_included_folders( self.__curr_config) self.__excluded_folders = self.__app_config.get_excluded_folders( self.__curr_config) self.__backup_location = self.__app_config.get_backup_path( self.__curr_config) curr_conf_name = self.__app_config.get_config_name(self.__curr_config) self.__curr_config_name_l.config(text=f"Config Name: {curr_conf_name}") self.__last_backup_l.config( text= f"Last Known Backup: {self.__app_config.get_human_last_backup(self.__curr_config)}" ) self.__versions_to_keep_l.config(text=self.__versions_to_keep) self.__included_folders_lb.delete(0, END) self.__included_folders_lb.insert(0, *self.__included_folders) self.__excluded_folders_lb.delete(0, END) self.__excluded_folders_lb.insert(0, *self.__excluded_folders) self.__backup_folder_l.config(text=str(self.__backup_location)) self.__use_tar_var.set( self.__app_config.get_use_tar(self.__curr_config)) def switch_config(self): """ switches what config to use for backup, asks the user for a config to load, then loads the display """ next_combo = ask_combobox("Load Config", "Config Name", self.__app_config.get_config_names()) if next_combo != None: self.__curr_config = next_combo self._load_display() def change_default_config(self): """ switches what config to use for the default backup, asks the user for a config to load """ next_combo = ask_combobox("Default Config", "Config Name", self.__app_config.get_config_names()) if next_combo != None: self.__app_config.default_config_i = next_combo def rename_curr_conf(self): """ rename a existing config, will ask the user in a popup string input """ new_name = simpledialog.askstring("Rename Config", "New Name") if new_name: self.__app_config.rename_config(self.__curr_config, new_name) self._load_display() def new_config(self): """ creates a new empty backup config, asks the user for config name """ name = simpledialog.askstring("New Config", "Config Name") if name: self.__app_config.create_config(name) def delete_current_config(self): """ deletes the current selected config, asks the user to confirm """ if messagebox.askyesno( "Confirm Delete", "Are you sure you want to delete the current config?"): self.__app_config.remove_config(self.__curr_config) self.__curr_config = self.__app_config.default_config_i self._load_display() def reset_config(self): """ resets all the user configs, asks the user to confirm """ if messagebox.askyesno( "Confirm Reset", "Are you sure you want to reset the all configurations?"): self.__app_config.reset_config() self.__curr_config = self.__app_config.default_config_i self._load_display() def use_tar_changed(self, *args): """ called each time the __use_tar_var is called """ self.__app_config.set_use_tar(self.__curr_config, self.__use_tar_var.get()) def update_versions_to_keep(self): """ update the number of versions to keep, asks the user for a integer """ new_val = simpledialog.askinteger( "Versions To Keep", "How many backups do you want to keep", minvalue=0) if new_val != self.__versions_to_keep and new_val != None: self.__versions_to_keep = new_val self.__app_config.set_versions_to_keep(self.__curr_config, self.__versions_to_keep) self.__versions_to_keep_l.config(text=self.__versions_to_keep) def deselect_included_folder(self, *args): """ deselects the selected element in included folder """ self.__included_folders_lb.selection_clear(0, END) def deselect_excluded_folder(self, *args): """ deselects the selected element in excluded folder """ self.__excluded_folders_lb.selection_clear(0, END) def add_included_folder(self): """ add a folder to include in the backup, will ask user for a directory """ folder = filedialog.askdirectory(initialdir="/", title="Select Folder To Backup") if folder: folder_path = Path(folder) if folder_path != self.__backup_location: self.__included_folders.append(folder_path) self.__included_folders_lb.insert(END, folder_path) self.__app_config.set_included_folders(self.__curr_config, self.__included_folders) else: messagebox.showwarning( title="Folder Same As Backup Path", message= "You selected a folder that was the same as the backup path!" ) def remove_selected_included_folder(self, *args): """ remove the currently selected item in the included folders ListBox, will ask the user to confirm """ curr_selection = self.__included_folders_lb.curselection() # check if there is a selection if curr_selection: if messagebox.askyesno("Confirm Delete", "Are you want to delete this folder?"): index_to_del = curr_selection[0] self.__included_folders.pop(index_to_del) self.__app_config.set_included_folders(self.__curr_config, self.__included_folders) self.__included_folders_lb.delete(index_to_del) self.deselect_included_folder() def add_excluded_folder(self): """ add a folder to exclude in the backup, will ask user for a directory """ folder = filedialog.askdirectory(initialdir="/", title="Select Folder To Exclude") if folder: folder_path = Path(folder) self.__excluded_folders.append(folder_path) self.__excluded_folders_lb.insert(END, folder_path) self.__app_config.set_excluded_folders(self.__curr_config, self.__excluded_folders) def remove_selected_excluded_folder(self, *args): """ remove the currently selected item in the excluded folders ListBox, will ask the user to confirm """ curr_selection = self.__excluded_folders_lb.curselection() # check if there is a selection if curr_selection: if messagebox.askyesno("Confirm Delete", "Are you want to delete this folder?"): index_to_del = curr_selection[0] self.__excluded_folders.pop(index_to_del) self.__app_config.set_excluded_folders(self.__curr_config, self.__excluded_folders) self.__excluded_folders_lb.delete(index_to_del) self.deselect_excluded_folder() def set_backup_folder(self): """ sets the backup folder by asking the user for a base directory """ folder = filedialog.askdirectory(initialdir="/", title="Select Where To Backup To") if folder: self.__backup_location = Path(folder) self.__backup_folder_l.config(text=folder) self.__app_config.set_backup_path(self.__curr_config, self.__backup_location) def enable_gui(self): """ enable the gui buttons, run when a backup has completed """ self.__set_versions_to_keep.config(state=NORMAL) self.__inc_folder_bnt.config(state=NORMAL) self.__included_folders_lb.config(state=NORMAL) self.__excl_folder_bnt.config(state=NORMAL) self.__excluded_folders_lb.config(state=NORMAL) self.__backup_to_bnt.config(state=NORMAL) self.__use_tar.config(state=NORMAL) self.__backup_start_bnt.config(state=NORMAL) def disable_gui(self): """ disable the gui buttons, run when a backup is started """ self.__set_versions_to_keep.config(state=DISABLED) self.__inc_folder_bnt.config(state=DISABLED) self.__included_folders_lb.config(state=DISABLED) self.__excl_folder_bnt.config(state=DISABLED) self.__excluded_folders_lb.config(state=DISABLED) self.__backup_to_bnt.config(state=DISABLED) self.__use_tar.config(state=DISABLED) self.__backup_start_bnt.config(state=DISABLED) def progress_find_incr(self, finished=False): """ increment the progress bar for finding files by 1 or mark as finished :param finished: mark the progressbar as finished """ if finished: self.__progress.config(mode="determinate") self.__progress.config(value=0, maximum=self.__files_found) self.__statusbar.config(text=f"Found {self.__files_found} Files") else: self.__files_found += 1 self.__progress.config(value=self.__files_found) self.__statusbar.config( text=f"Searching For Files, Found {self.__files_found} Files") def progress_copy_incr(self): """ increment the progress bar for copying files by 1 or mark as finished """ self.__files_copied += 1 self.__progress.config(value=self.__files_copied) self.__statusbar.config( text=f"Copying Files {self.__files_copied} of {self.__files_found}" ) if self.__files_copied == self.__files_found: self.__app_config.set_last_backup(self.__curr_config, datetime.utcnow()) self.__last_backup_l.config( text= f"Last Known Backup: {self.__app_config.get_human_last_backup(self.__curr_config)}" ) self.__statusbar.config(text=f"Finished Copying Files") messagebox.showinfo(title="Finished Copying Files", message="Finished copying all found files") # reset counters self.__files_found = 0 self.__files_copied = 0 self.__progress.config(value=0, maximum=100) self.enable_gui() def start_backup(self): """ starts the backup """ if not self.__backup_location: # no backup location was selected messagebox.showwarning( title="Backup Location Not Selected", message="You did not select a backup location!") elif not self.__included_folders: # no folders where found to backup messagebox.showwarning( title="No Folders To Backup", message="You did not add any folders to backup!") else: # basic checks passed self.disable_gui() # prep for search of files self.__progress.config(mode="indeterminate") self.__statusbar.config(text=f"Searching For Files") self.__thread = BackupThread( self.__included_folders, self.__excluded_folders, self.__backup_location, self.__versions_to_keep, self.progress_find_incr, self.progress_copy_incr, self.handle_error_message, self.__use_tar_var.get()) # start the background backup thread so GUI wont appear frozen self.__thread.start() def show_about_popup(self): """ show the about popup """ messagebox.showinfo( "About", "simplebackup V" + __version__ + """ is cross-platform backup program written in python. This app was made by enchant97/Leo Spratt. It is licenced under GPL-3.0""") def show_update_popup(self): """ open the default webbrowser to the update url """ webbrowser.open(UPDATE_URL) def show_help_popup(self): messagebox.showinfo( "Welcome", """Welcome to simplebackup, here is some help to get you started: \nIncluding a folder to backup - Press the 'Include Folder' button to add a folder to backup - Remove a entry by clicking on the list below \nExcluding a folder from the backup - Press the 'Exclude Folder' button to skip a folder to backup - Remove a entry by clicking on the list below \nSetting where backups are stored - Click the 'Backup Folder' button to set where backups should be placed \nMultiple backup configs Use the 'Config' button in the titlebar to change varius settings like creating a new config \nVersions to keep This will be the number of backup to keep in the backup folder """) self.__app_config.show_help = False def handle_error_message(self, error_type: ERROR_TYPES): self.__statusbar.config(text="Failed") if error_type is ERROR_TYPES.NO_BACKUP_WRITE_PERMISION: messagebox.showerror("No Write Permission", ERROR_TYPES.NO_BACKUP_WRITE_PERMISION.value) elif error_type is ERROR_TYPES.NO_BACKUP_READ_PERMISION: messagebox.showerror("No Read Permission", ERROR_TYPES.NO_BACKUP_READ_PERMISION.value) elif error_type is ERROR_TYPES.NO_FILES_FOUND_TO_BACKUP: messagebox.showerror("No Files Found", ERROR_TYPES.NO_FILES_FOUND_TO_BACKUP.value) elif error_type is ERROR_TYPES.NO_BACKUP_PATH_FOUND: messagebox.showerror("No Backup Path Found", ERROR_TYPES.NO_BACKUP_PATH_FOUND.value) self.__progress.config(mode="determinate") self.enable_gui() def _layout(self): self.config(menu=self.__menu) self.__title_l.pack(fill=X, pady=10, padx=5) self.__curr_config_name_l.pack(fill=X, padx=5) self.__last_backup_l.pack(fill=X, padx=5) self.__set_versions_to_keep.pack(fill=X, padx=5) self.__versions_to_keep_l.pack(fill=X, padx=5) self.__inc_folder_bnt.pack(fill=X, padx=5) self.__included_folders_lb.pack(fill=X, padx=5) self.__excl_folder_bnt.pack(fill=X, padx=5) self.__excluded_folders_lb.pack(fill=X, padx=5) self.__backup_to_bnt.pack(fill=X, padx=5) self.__backup_folder_l.pack(fill=X, padx=5) self.__use_tar_l.pack(fill=X, padx=5) self.__use_tar.pack(fill=X, padx=5) self.__backup_start_bnt.pack(fill=X, padx=5) self.__progress.pack(fill=X) self.__statusbar.pack(side=BOTTOM, fill=X) self.wm_minsize(300, self.winfo_height()) self.wm_resizable(True, False)
class SendFilesWindow(Toplevel): """ A popup window to show the progress of the transfer to the server Parameters ---------- master : instance of tkinter.Widget Parent widget for this Toplevel widget srcs : List of BIDSHandler objects (excluding bidshandler.Scan) List of source objects to copy over. dst : string Destination folder or location on server. set_copied : bool Change the name of the source directory to have `_copied` appended to indicate that the data has been transferred successfully. opt_verify : bool Whether to provide the option to verify data or not. If the option is provided then it will be off by default. """ def __init__(self, master, srcs, dst, set_copied=False, opt_verify=False): self.master = master self.srcs = srcs if not isinstance(self.srcs, list): self.srcs = [self.srcs] self.dst = dst self.set_copied = set_copied self.opt_verify = opt_verify Toplevel.__init__(self, self.master) self.withdraw() if master.winfo_viewable(): self.transient(master) self.title('Transfer files') # define some variables we need self.force_override = BooleanVar(value=False) if opt_verify: self.verify = BooleanVar(value=False) else: self.verify = BooleanVar(value=True) # total number of files to transfer self.file_count_var = StringVar(value="Number of files: {0}") self.total_file_size = StringVar(value="Total file size: {0}") self.file_count = 0 total_file_size = 0 for src in self.srcs: for root, _, files in os.walk(src.path): self.file_count += len(files) for file in files: fpath = op.join(root, file) fsize = os.stat(fpath).st_size total_file_size += fsize fsize = get_fsize(total_file_size) self.file_count_var.set(self.file_count_var.get().format( self.file_count)) self.total_file_size.set(self.total_file_size.get().format(fsize)) # current name of file being transferred self.curr_file = StringVar(value="None") # number of files that have been transferred self.transferred_count = IntVar() # internal progress variable self.curr_file_progress = RangeVar( max_val=0, max_val_callback=self._update_file_progress) self.protocol("WM_DELETE_WINDOW", self._exit) self._create_widgets() self.deiconify() self.focus_set() # wait for window to appear on screen before calling grab_set self.wait_visibility() self.grab_set() self.wait_window(self) def _create_widgets(self): frame = Frame(self) frame.grid(sticky='nsew') # TODO: add line to show destination for data? maybe source too... # number of files being transferred and total size lbl_file_count = Label(frame, textvariable=self.file_count_var) lbl_file_count.grid(column=0, row=0) lbl_total_size = Label(frame, textvariable=self.total_file_size) lbl_total_size.grid(column=1, row=0) # info about current file being transferred label2 = Label(frame, text="Current file being transferred:") label2.grid(column=0, row=1, columnspan=2, sticky='w') lbl_curr_file = Label(frame, textvariable=self.curr_file, width=60) lbl_curr_file.grid(column=0, row=2) self.file_prog = Progressbar(frame, variable=self.curr_file_progress) self.file_prog.grid(column=1, row=2, pady=2) # info about total progress label3 = Label(frame, text="Overall progress:") label3.grid(column=0, row=3, sticky='w') total_prog = Progressbar(frame, variable=self.transferred_count, maximum=self.file_count) total_prog.grid(column=1, row=3) # buttons btn_frame = Frame(frame) force_check = Checkbutton(btn_frame, text="Force", variable=self.force_override) force_check.grid(column=0, row=0, sticky='e') verify_check = Checkbutton(btn_frame, text="Verify", variable=self.verify) if self.opt_verify: verify_check.grid(column=1, row=0, sticky='e') ttm.register(force_check, ("Whether to force the overwriting of current data.\n" "This should only be done if there was an error and the " "data needs to be re-sent.")) btn_start = Button(btn_frame, text="Begin", command=self._transfer) btn_start.grid(column=2, row=0, sticky='e') btn_exit = Button(btn_frame, text="Exit", command=self._exit) btn_exit.grid(column=3, row=0, sticky='w') btn_frame.grid(column=0, row=4, columnspan=2) @threaded def _transfer(self): """Transfer all the files in each of the sources to the destination.""" copy_func = BIDSCopy(overwrite=self.force_override.get(), verify=self.verify.get(), file_name_tracker=self.curr_file, file_num_tracker=self.transferred_count, file_prog_tracker=self.curr_file_progress) self.curr_file.set('Mapping destination BIDS structure...') dst_folder = BIDSTree(self.dst) for src in self.srcs: dst_folder.add(src, copier=copy_func.copy_files) if self.set_copied: self._rename_complete(src) self.transferred_count.set(self.file_count) self.curr_file.set('Complete!') def _rename_complete(self, src): """Rename the folder to have `_copied` appended to the name. Parameters ---------- src : Instance of bidshandler.(BIDSTree, Project, Subject, Setting)""" if not src.path.endswith('_copied'): fname = op.basename(src.path) new_path = "{0}_copied".format(src.path) os.rename(src.path, new_path) # fix the path in the BIDSTree object also if isinstance(src, BIDSTree): src.path = new_path # also rename the branch in the filetree sid = self.master.file_treeview.sid_from_text(fname) self.master.file_treeview.item(sid[0], text="{0}_copied".format(fname)) # the hidden filepath value also needs to be updated new_vals = list(self.master.file_treeview.item(sid[0])['values']) new_vals[1] = new_path self.master.file_treeview.item(sid[0], values=new_vals) def _update_file_progress(self): self.file_prog.config(maximum=self.curr_file_progress.max) def _exit(self): self.withdraw() self.update_idletasks() self.master.focus_set() self.destroy()
class MusicPlayer(): # _________________Image Files_________________ playImg = PhotoImage(file="Images/Play.png") pauseImg = PhotoImage(file="Images/Pause.png") previousImg = PhotoImage(file="Images/Previous.png") nextImg = PhotoImage(file="Images/Next.png") repeatNormImg = PhotoImage(file="Images/Repeat.png") repeatOneImg = PhotoImage(file="Images/Repeat_One.png") repeatAllImg = PhotoImage(file="Images/Repeat_All.png") shuffleOnImg = PhotoImage(file="Images/Shuffle_On.png") shuffleOffImg = PhotoImage(file="Images/Shuffle_Off.png") coverImg = PhotoImage(file="Images/Headphone.png") openFolderImg = PhotoImage(file="Images/Open_Folder.png") libraryImg = PhotoImage(file="Images/Library.png") volumeHighImg = PhotoImage(file="Images/Volume_High.png") volumeMidImg = PhotoImage(file="Images/Volume_Mid.png") volumeLowImg = PhotoImage(file="Images/Volume_Low.png") volumeOffImg = PhotoImage(file="Images/Volume_Off.png") selectVolumeImg = PhotoImage(file="Images/Select_Volume.png") searchImg = PhotoImage(file="Images/Search.png") windowImg = PhotoImage(file="Images/window.png") floatPlayImg = PhotoImage(file="Images/FloatPlay.png") floatPauseImg = PhotoImage(file="Images/FloatPause.png") floatPreviousImg = PhotoImage(file="Images/FloatPrevious.png") floatNextImg = PhotoImage(file="Images/FloatNext.png") floatShuffleOnImg = PhotoImage(file="Images/FloatShuffle_On.png") floatShuffleOffImg = PhotoImage(file="Images/FloatShuffle_Off.png") floatRepeatImg = PhotoImage(file="Images/FloatRepeat.png") floatRepeatOneImg = PhotoImage(file="Images/FloatRepeat_One.png") floatRepeatAllImg = PhotoImage(file="Images/FloatRepeat_All.png") # giffy = PhotoImage(file="Images/spec.gif") # starGif = PhotoImage(file="Images/Stars.gif") # _________________Variables_________________ songsName = [] # songLoader = [] songsLoc = [] # songTitle = [] # songArtist = [] myIndex = 0 shuffleStatus = 0 repeatStatus = 0 prevIndex = 0 backupVolume = 60 initialiseWindow = 1 songsLength = 0 haltMusic = 0 prog = 0 exitStatus = 0 cur_Val = 0 isPaused = 0 juststarted = 1 global timer # insertIndex = 0 # initialiseVolume = 1 # _________________Volume Window_________________ def VolumeWindow(self, root, color, height): self.frameVolume = Frame(root, bg=color, height=height) self.frameVolume.pack(fill=BOTH, expand=TRUE) self.btn_volume = Button(self.frameVolume, image=self.volumeHighImg, relief=FLAT, command=self.volumeOff) self.btn_volume.pack(side=LEFT) self.scl_volume = Scale(self.frameVolume, bg="white", bd=0, relief=FLAT, activebackground="GREEN", orient=HORIZONTAL, fr=0, to=100, command=self.setVolume) self.scl_volume.pack(ipadx=100) mixer.init() mixer.music.set_volume(0.6) self.scl_volume.set(60) # _________________Volume Methods_________________ def setVolume(self, volume_value): volume = int(volume_value) / 100 mixer.music.set_volume(volume) if (volume > 0.8): self.scl_volume.config(activebackground="RED") elif (volume > 0.6): self.scl_volume.config(activebackground="ORANGE") elif (volume > 0): self.scl_volume.config(activebackground="LIGHT GREEN") if (volume > 0.7): self.btn_volume.config(image=self.volumeHighImg, command=self.volumeOff) elif (volume > 0.3): self.btn_volume.config(image=self.volumeMidImg, command=self.volumeOff) elif (volume > 0): self.btn_volume.config(image=self.volumeLowImg, command=self.volumeOff) else: self.btn_volume.config(image=self.volumeOffImg, command=self.volumeOn) def volumeOff(self): self.backupVolume = self.scl_volume.get() # print(self.backupVolume) self.scl_volume.set(0) mixer.init() mixer.music.set_volume(0) self.btn_volume.config(image=self.volumeOffImg, command=self.volumeOn) def volumeOn(self): getVolume = self.backupVolume mixer.init() if (getVolume > 70): self.scl_volume.set(getVolume) mixer.music.set_volume(getVolume / 100) self.btn_volume.config(image=self.volumeHighImg, command=self.volumeOff) elif (getVolume > 30): self.scl_volume.set(getVolume) mixer.music.set_volume(getVolume / 100) self.btn_volume.config(image=self.volumeMidImg, command=self.volumeOff) else: self.scl_volume.set(getVolume) mixer.music.set_volume(getVolume / 100) self.btn_volume.config(image=self.volumeLowImg, command=self.volumeOff) # def Frames(self, root, color, height): # self.frame = Frame(root, bg=color, height=height) # self.frame.pack(fill=BOTH, expand=TRUE) # _________________Cover Window_________________ # def CoverWindow(self, root, color, height): # self.frameCover = Frame(root, bg=color, height=height) # self.frameCover.pack(fill=BOTH, expand=TRUE) # # self.lbl_coverPic = Label(self.frameCover, image=self.coverImg) # self.lbl_coverPic.pack() # _________________Control Window_________________ def ControlWindow(self, root): self.frameCover = Frame(root, bg="GREY", height=350) self.frameCover.pack(fill=BOTH, expand=TRUE) self.lbl_coverPic = Label(self.frameCover, image=self.coverImg) self.lbl_coverPic.pack() self.frameTitleArtist = Frame(root, bg="AQUA", height=30) self.frameTitleArtist.pack(fill=BOTH, expand=TRUE) self.lbl_TitleArtist = Label(self.frameTitleArtist, text="Name\nArtist\nAlbum", bg="WHITE", relief=RIDGE) self.lbl_TitleArtist.pack(fill=BOTH, expand=TRUE) # self.frameAlbum = Frame(root, bg="BLACK", height=20) # self.frameAlbum.pack(fill=BOTH, expand=TRUE) # # self.lbl_Album = Label(self.frameAlbum, text="", relief=FLAT) # self.lbl_Album.pack(fill=BOTH, expand=TRUE) self.frameScrubbar = Frame(root, bg="BLACK", height=30) self.frameScrubbar.pack(fill=BOTH, expand=TRUE) self.prgBar = Progressbar(self.frameScrubbar, length=340, orient=HORIZONTAL, maximum=100, value=0) self.prgBar.grid(row=0, column=0, columnspan=3) # self.prgBar.bind("<Button-1>", self.seek) # self.canvas = Canvas(self.frameScrubbar, width=236, height=18) # self.canvas.grid(row=1, column=1) self.lbl_prgTime = Label(self.frameScrubbar, width=6, text="--:--:--") self.lbl_prgTime.grid(row=1, column=0, sticky=W) self.lbl_totalTime = Label(self.frameScrubbar, width=6, text="--:--:--") self.lbl_totalTime.grid(row=1, column=2, sticky=E) self.frameControl = Frame(root, bg="INDIGO", height=100) self.frameControl.pack(fill=BOTH, expand=TRUE) self.btn_shuffle = Button(self.frameControl, text="SHUF", image=self.shuffleOffImg, relief=FLAT, height=50, width=62, command=self.shuffleOn) self.btn_shuffle.grid(row=0, column=0) self.btn_previous = Button(self.frameControl, text="PREV", image=self.previousImg, relief=FLAT, height=50, width=62, command=self.previousSong) self.btn_previous.grid(row=0, column=1) self.btn_play_pause = Button(self.frameControl, text="PLAY", image=self.playImg, relief=FLAT, height=50, width=62, command=self.playSong) self.btn_play_pause.grid(row=0, column=2) self.btn_next = Button(self.frameControl, text="NEXT", image=self.nextImg, relief=FLAT, height=50, width=62, command=lambda: self.nextSong(1)) self.btn_next.grid(row=0, column=3) # self.btn_next.bind("<Button-1>", lambda x : self.nextSong(1)) self.btn_repeat = Button(self.frameControl, text="REAP", image=self.repeatNormImg, relief=FLAT, height=50, width=62, command=self.repeatOne) self.btn_repeat.grid(row=0, column=4) self.frm_openFolder = Frame(root, bg="WHITE", width=50, height=50) self.frm_openFolder.place(relx=0.07, rely=0.12, anchor=CENTER) self.btn_openFolder = Button(self.frm_openFolder, image=self.openFolderImg, relief=FLAT, command=self.openFolder) self.btn_openFolder.pack() self.frm_library = Frame(root, bg="WHITE", width=50, height=50) self.frm_library.place(relx=0.93, rely=0.12, anchor=CENTER) self.btn_library = Button(self.frm_library, image=self.libraryImg, relief=FLAT, command=self.myLibrary) self.btn_library.pack() self.frm_search = Frame(root, width=200, height=25) self.frm_search.place(relx=0.5, rely=0.105, anchor=CENTER) # self.frm_search.__setattr__('-alpha', 0.9) self.entry_search = Entry(self.frm_search, relief=FLAT, command=None) self.entry_search.pack(side=LEFT, ipadx=10) self.entry_search.bind('<Return>', self.searchAndPlay) self.btn_Search = Button(self.frm_search, image=self.searchImg, relief=FLAT, command=self.searchAndPlay) self.btn_Search.pack() self.frmGif = Frame(root) self.frmGif.place(relx=0.14, rely=0.853) self.myGIf() self.frm_Min = Frame(root) self.frm_Min.place(relx=0.77, rely=0.085) self.btn_min = Button(self.frm_Min, image=self.windowImg, relief=FLAT, command=self.floatingWin) self.btn_min.pack() # _________________Progress Bar Methods_________________ def seek(self, event): # Unused self.exitStatus = 1 myt.sleep(1) temp = (event.x / 830) * 100 cur_pos = int( (temp * round(MP3(self.songsName[self.myIndex]).info.length)) / 100) self.cur_Val = int( (cur_pos * round(MP3(self.songsName[self.myIndex]).info.length)) / 100) + ((2 * cur_pos) / 100) self.prog = self.cur_Val mixer.init() mixer.music.stop() mixer.music.load(self.songsName[self.myIndex]) mixer.music.play(loops=0, start=self.prog) self.prgBar.config( value=(self.prog / round(MP3(self.songsName[self.myIndex]).info.length)) * 100) self.exitStatus = 0 self.progressTimer = threading.Timer(0, self.progressInc) self.progressTimer.start() # self.exitStatus = 1 # self.prgBar.config(value=(self.prog / round(MP3(self.songsName[self.myIndex]).info.length)) * 100) # # self.progressStop() # temp = (event.x / 830)*100 # print(temp) # cur_pos = int((temp * round(MP3(self.songsName[self.myIndex]).info.length))/100) # print(self.cur_Val) # self.cur_Val = int((cur_pos * round(MP3(self.songsName[self.myIndex]).info.length))/100) # self.prog = self.cur_Val # self.progressTimer = threading.Timer(0, self.progressInc) # self.progressTimer.start() # self.songLength = (float(round(MP3(self.songsName[self.myIndex]).info.length)) - self.prog) + 2 # self.timer = threading.Timer(self.songLength, self.nextSong) # self.timer.start() # self.exitStatus = 1 # def myGIf(self): # self.canvas = Canvas(root, width=250, height=18) # self.canvas.place(relx=0.5, rely=0.875, anchor=CENTER)#grid(row=1, column=1) # self.sequence = [ImageTk.PhotoImage(img.resize((236,18), Image.ANTIALIAS)) # for img in ImageSequence.Iterator(Image.open("Images/Specturm.gif"))] # self.image = self.canvas.create_image(118, 9, image=self.sequence[0]) # self.animate(1) # # def animate(self, counter): # self.canvas.itemconfig(self.image, image=self.sequence[counter]) # root.after(30, lambda: self.animate((counter+1) % len(self.sequence))) # # def destroy_myGif(self): # self.canvas.destroy() def progressInc(self): # if(self.isPaused == 0): # self.myGIf() # else: # self.destroy_myGif() try: songLen = round(MP3(self.songsName[self.myIndex]).info.length) # h_time = str(songLen // 3600) # m_time = str((songLen % 3600) // 60) # s_time = str(songLen % 60) t_m_time, t_s_time = divmod(songLen, 60) t_h_time, t_m_time = divmod(t_m_time, 60) total_t_format = '{:02d}:{:02d}:{:02d}'.format( t_h_time, t_m_time, t_s_time) self.lbl_totalTime.config(text=total_t_format) while (self.prog <= songLen): if (self.exitStatus): return else: self.prgBar.config(value=(self.prog / songLen) * 100) c_m_time, c_s_time = divmod(self.prog, 60) c_h_time, c_m_time = divmod(c_m_time, 60) cur_time_format = '{:02d}:{:02d}:{:02d}'.format( c_h_time, c_m_time, c_s_time) self.lbl_prgTime.config(text=cur_time_format) self.prog += 1 myt.sleep(1) self.btn_play_pause.config(image=self.playImg) # if(self.myIndex == len(self.songsName)-1): # self.myIndex = 0 except: pass def progressStop(self): self.exitStatus = 1 self.cur_Val = self.prog self.prgBar.config( value=(self.prog / round(MP3(self.songsName[self.myIndex]).info.length)) * 100) def progressResume(self): self.exitStatus = 0 self.prog = self.cur_Val self.progressTimer = threading.Timer(0, self.progressInc) self.progressTimer.start() # print("Hey") # _________________Shuffle Methods_________________ def shuffleOn(self): self.shuffleStatus = 1 # self.lstbx_library.itemconfig(self.myIndex,bg="WHITE") self.prevIndex = self.myIndex try: self.myIndex = random.randint(0, len(self.songsName) - 1) except: pass # self.playSong() try: self.floatbtn_Shuffle.config(text="S On") except: pass self.btn_shuffle.config(image=self.shuffleOnImg, command=self.shuffleOff) def shuffleOff(self): self.shuffleStatus = 0 try: self.floatbtn_Shuffle.config(text="S Off") except: pass self.btn_shuffle.config(image=self.shuffleOffImg, command=self.shuffleOn) # _________________Previous Methods_________________ def previousSong(self): if (self.prog > 6): self.exitStatus = 1 myt.sleep(1) self.exitStatus = 0 self.prgBar.config(value=0) self.prog = 0 self.playSong() return self.exitStatus = 1 myt.sleep(1) self.exitStatus = 0 self.prgBar.config(value=0) self.prog = 0 if (self.shuffleStatus == 0): self.prevIndex = self.myIndex try: self.lstbx_library.itemconfig(self.myIndex, bg="WHITE") except: pass if (self.myIndex == 0): self.myIndex = len(self.songsName) - 1 else: self.myIndex -= 1 self.playSong() elif (self.shuffleStatus == 1): try: self.lstbx_library.itemconfig(self.myIndex, bg="WHITE") except: pass self.myIndex = self.prevIndex self.prevIndex = random.randint(0, len(self.songsName) - 1) self.playSong() # _________________Play Song Methods_________________ def playSong(self): if (len(self.songsName) == 0): # or len(self.songsLoc) == 0): self.openFolder() else: # self.myIndex = self.songsName.index(self.lstbx_library.get(ACTIVE)) # mySongLoc = "\\".join(self.songsLoc[self.myIndex].split("\\")[:-1]) # os.chdir(mySongLoc) # self.btn_play_pause.config(image=self.pauseImg, command=self.pauseSong) # mixer.init() # mixer.music.load(self.songsLoc[self.myIndex]) # mixer.music.play() # event.config(image=self.pauseImg, command=self.pauseSong) # print(self.myIndex) # self.lstbx_library.curselection() # songN = self.lstbx_library.get(self.lstbx_library.curselection()[0]) # print(songN) # print(self.songsLoc) # print(self.songsName) # mixer.music.load(self.songLoader[self.myIndex]) # if(self.initialiseVolume == 1): # self.initialiseVolume=0 # mixer.music.set_volume(0.6) # if(self.initialiseWindow): # self.initialiseWindow = 0 # self.myLibrary() # self.destroy_Lstbx() try: self.timer.cancel() except: pass # try: # mixer.music.stop() # except: # pass os.chdir(self.songsLoc[self.myIndex]) try: # print(self.prevIndex) self.lstbx_library.itemconfig(self.prevIndex, bg="WHITE") self.lstbx_library.itemconfig(self.myIndex, bg="YELLOW") except: pass mixer.init() mixer.music.load(self.songsName[self.myIndex]) mixer.music.play() # mixer.music.set_endevent() # def invokeNextSong(): # self.nextSong() # self.myGIf() # Error self.songLength = float( round(MP3(self.songsName[self.myIndex]).info.length)) + 2 self.timer = threading.Timer(self.songLength, self.nextSong) self.timer.start() # self.prgBar = Progressbar(self.frameScrubbar, length=320, orient=HORIZONTAL, # maximum=100, # value=0) # self.prgBar.pack() # self.prog = 0 self.progressTimer = threading.Timer(0, self.progressInc) self.progressTimer.start() # self.progressTimer.setDaemon(TRUE) self.currentSongTitleArtist() self.juststarted = 0 self.btn_play_pause.config(image=self.pauseImg, command=self.pauseSong) try: self.floatSongName = EasyID3( self.songsName[self.myIndex])['title'][0] except KeyError: self.floatSongName = self.songsName[self.myIndex] except: self.floatSongName = "Song Name" try: self.floatLbl_SongName.config(text=self.floatSongName) except: # print("Executed") pass # self.resumeSong() # self.progress() # print(mixer.music.get_busy()) # self.btn_play_pause.config(image=self.pauseImg, command=self.pauseSong) def invokePlayNext(self): if (self.myIndex != len(self.songsName) - 1): self.songLength = (float( round(MP3(self.songsName[self.myIndex]).info.length)) - self.prog) + 2 self.timer = threading.Timer(self.songLength, self.nextSong) self.timer.start() def pauseSong(self): mixer.music.pause() self.isPaused = 1 # self.haltMusic = mixer.music.get_pos() / 100 # self.timer.cancel() try: self.floatbtn_PlayPause.config(text="|>") except: pass self.btn_play_pause.config(image=self.playImg, command=self.resumeSong) self.progressStop() # while mixer.music.get_busy(): # continue # self.nextSong() def resumeSong(self): # print(mixer.music.get_pos()) self.isPaused = 0 mixer.music.unpause() self.progressResume() self.invokePlayNext() # print(self.songLength-self.haltMusic) # try: # self.timer = threading.Timer(self.songLength-self.haltMusic, self.nextSong) # self.timer.start() # except: # pass # self.progress() try: self.floatbtn_PlayPause.config(text="||") except: pass self.btn_play_pause.config(image=self.pauseImg, command=self.pauseSong) # _________________Next Methods_________________ def nextSong(self, arg=None): # self.prgBar.destroy() # print(self.isPaused) # print(arg) # Prevent from unnecessary threading invoke if (self.isPaused == 1 and arg != 1): # print("1") self.progressTimer.cancel() return # if(self.shuffleStatus == 1): try: if (self.isPaused == 0 and self.prog < round( MP3(self.songsName[self.myIndex]).info.length) and arg != 1): # print(self.prog < round(MP3(self.songsName[self.myIndex]).info.length)) # print(self.isPaused, self.prog, round(MP3(self.songsName[self.myIndex]).info.length)-2) # print("invoked") # print(self.myIndex) # print("2") return # else: # if(self.isPaused == 0 and self.prog < round(MP3(self.songsName[self.myIndex]).info.length) and arg != 1): # # print(self.isPaused, self.prog, round(MP3(self.songsName[self.myIndex]).info.length)) # # print("invoked") # print("3") # return # print(self.prog) except: pass self.exitStatus = 1 myt.sleep(1) self.exitStatus = 0 self.prgBar.config(value=0) self.prog = 0 # if self.timer == 1: # self.timer.cancel() # print(self.repeatStatus) if (self.repeatStatus == 0 and self.myIndex == len(self.songsName) - 1 and self.shuffleStatus == 0): mixer.music.stop() elif (self.repeatStatus == 1): self.playSong() else: if (self.shuffleStatus == 0): try: self.lstbx_library.itemconfig(self.prevIndex, bg="WHITE") except: pass self.prevIndex = self.myIndex try: self.lstbx_library.itemconfig(self.myIndex, bg="WHITE") except: pass if (self.myIndex == len(self.songsName) - 1): self.myIndex = 0 else: self.myIndex += 1 self.playSong() elif (self.shuffleStatus == 1): try: self.lstbx_library.itemconfig(self.prevIndex, bg="WHITE") self.lstbx_library.itemconfig(self.myIndex, bg="WHITE") except: pass self.shuffleOn() self.playSong() # _________________Repeat Methods_________________ def repeatOne(self): self.repeatStatus = 1 try: self.floatbtn_Repeat.config(text="R One") except: pass self.btn_repeat.config(image=self.repeatOneImg, command=self.repeatAll) def repeatAll(self): self.repeatStatus = 2 try: self.floatbtn_Repeat.config(text="R All") except: pass self.btn_repeat.config(image=self.repeatAllImg, command=self.repeatNorm) def repeatNorm(self): self.repeatStatus = 0 try: self.floatbtn_Repeat.config(text="R Norm") except: pass self.btn_repeat.config(image=self.repeatNormImg, command=self.repeatOne) # _________________Open Folder Methods_________________ def openFolder(self): try: directory = askdirectory() os.chdir(directory) # self.songsName=[] for files in os.listdir(directory): if (files.endswith(".mp3")): # print(files) self.songsName.append(files) # try: # self.songTitle.append(str(ID3(files)['TIT2'].text[0])) # # self.songArtist.append(str(ID3(files)['TPE1'].text[0])) # except: # self.songTitle.append("Unknown") # self.songArtist.append(str("Unknown")) self.songsLoc.append(directory) if (len(self.songsName) == 0): messagebox.showwarning( "EMPTY FOLDER", "Music not found in this folder." "\nPlease select a folder containing mp3 files.") # for root, dirs, files in os.walk("."): # for filename in files: # if(filename.endswith(".mp3")): # self.songsName.append(str(filename)) # # print(os.path.abspath(filename)) # self.songLoader.append(os.path.abspath(filename)) # temp = "/".join(os.path.abspath(filename).split("\\")[:-1]) # self.songsLoc.append(temp) except: messagebox.showinfo("Oops!", "Folder could not select properly") # _________________Library Methods_________________ def myLibrary(self): try: if (len(self.songsName) == 0): self.openFolder() except: pass self.frm_libraryWindow = Frame(root, bg="WHITE") self.frm_libraryWindow.place(relx=0.5, rely=0.44, anchor=CENTER) self.lstbx_library = Listbox(self.frm_libraryWindow, width=50, height=17) self.lstbx_library.grid(row=0, column=0) # pack(side=LEFT, fill=Y) self.lstbx_library.bind('<Double-1>', self.invokeSong) self.vscrl_lstbx_library = Scrollbar(self.frm_libraryWindow, orient=VERTICAL) self.vscrl_lstbx_library.config(command=self.lstbx_library.yview) self.vscrl_lstbx_library.grid( row=0, column=1, ipady=112) # pack(side=RIGHT, fill=Y) self.lstbx_library.config( bd=2, yscrollcommand=self.vscrl_lstbx_library.set) self.hscrl_lstbx_library = Scrollbar(self.frm_libraryWindow, orient=HORIZONTAL) self.hscrl_lstbx_library.config(command=self.lstbx_library.xview) self.hscrl_lstbx_library.grid(row=1, column=0, columnspan=2, ipadx=135) # pack(fill=X) self.lstbx_library.config( bd=2, xscrollcommand=self.hscrl_lstbx_library.set) for i in range(len(self.songsName)): self.lstbx_library.insert( END, str(i + 1) + ". " + self.songsName[i]) self.lstbx_library.itemconfig(i, bg="WHITE") self.btn_library.config(command=self.destroy_Lstbx) try: self.lstbx_library.itemconfig(self.myIndex, bg="YELLOW") except: pass def invokeSong(self, event): self.exitStatus = 1 myt.sleep(1) self.exitStatus = 0 self.prgBar.config(value=0) self.prog = 0 self.lstbx_library.itemconfig(self.prevIndex, bg="WHITE") self.lstbx_library.itemconfig(self.myIndex, bg="WHITE") filterSongName = self.lstbx_library.get(ACTIVE) filterSongName = filterSongName[filterSongName.find(" ") + 1:] self.myIndex = self.songsName.index(filterSongName) self.prevIndex = self.myIndex # print(self.myIndex) self.playSong() def destroy_Lstbx(self): self.frm_libraryWindow.destroy() self.btn_library.config(command=self.myLibrary) # _________________Title Methods_________________ def currentCover(self): try: my_mp3 = stagger.read_tag(self.songsName[self.myIndex]) cover_data = BytesIO(my_mp3[stagger.id3.APIC][0].data) cover_image = Image.open(cover_data) # basewidth = 340 # wpercent = (basewidth / float(cover_image.size[0])) # hsize = int((float(cover_image.size[1]) * float(wpercent))) img = cover_image.resize((340, 340), Image.ANTIALIAS) # img.save('temp.jpg') cur_photo = ImageTk.PhotoImage(img) self.lbl_coverPic.config(image=cur_photo) self.lbl_coverPic.image = cur_photo except: self.lbl_coverPic.config(image=self.coverImg) def currentSongTitleArtist(self): self.currentCover() try: tag = EasyID3(self.songsName[self.myIndex]) # songTitle = str(ID3(self.songsName[self.myIndex])['TIT2'].text[0]) \ # + "\n" + str(ID3(self.songsName[self.myIndex])['TPE1'].text[0]) songTitle = str(self.myIndex + 1) + ". " + str( tag['title'][0]) + "\nArtist: " + str( tag['artist'][0]) + "\nAlbum: " + str(tag['album'][0]) except: songTitle = str(self.myIndex + 1) + ". " + str(self.songsName[ self.myIndex]) + "\nArtist: Unknown\nAlbum: Unknown" # try: # floatSongName = EasyID3(self.songsName[self.myIndex])['title'][0] # self.floatLbl_SongName.config(text=floatSongName) # except KeyError: # floatSongName = self.songsName[self.myIndex] # self.floatLbl_SongName.config(text=floatSongName) # except: # floatSongName = "Song Name" # self.floatLbl_SongName.config(text=floatSongName) self.lbl_TitleArtist.config(text=songTitle) # _________________Search Methods_________________ def searchAndPlay(self, event=None): getIndex = self.entry_search.get().strip() try: if (getIndex == ""): return else: temp = int(getIndex) if (0 < temp <= len(self.songsName)): self.exitStatus = 1 myt.sleep(1) self.exitStatus = 0 self.prgBar.config(value=0) self.prog = 0 self.prevIndex = self.myIndex self.myIndex = temp - 1 self.playSong() else: messagebox.showerror("OUT OF RANGE!", "MUSIC NOT FOUND!") except: messagebox.showwarning("INVALID INDEX!", "Index must be integer.") def keyInvoke(self, event): # print(ord(event.char)) try: if (event.char == " " and self.juststarted == 1): # print("PLAY") self.playSong() elif (event.char == " " and self.isPaused == 1): # self.isPaused = 0 # print("space play") self.resumeSong() elif (event.char == " " and self.isPaused == 0): # print("space paused") # self.isPaused = 1 self.pauseSong() except: pass def myGIf(self): self.canvas = Canvas(self.frmGif, width=240, height=18) self.canvas.grid(row=1, column=1) self.sequence = [ ImageTk.PhotoImage(self.img.resize((240, 18), Image.ANTIALIAS)) for self.img in ImageSequence.Iterator( Image.open("Images/Specturm.gif")) ] self.image = self.canvas.create_image(120, 9, image=self.sequence[0]) self.animate(1) def animate(self, counter): self.canvas.itemconfig(self.image, image=self.sequence[counter]) root.after( 40, lambda: self.animate((counter + 1) % len(self.sequence))) def destroy_Gif(self): self.frmGif.destroy() def floatingWin(self): # root.iconify() root.withdraw() try: self.floatroot.destroy() except: pass self.floatroot = Tk() # self.floatroot.iconbitmap("Images/Music_Player.ico") self.floatroot.geometry("260x50") self.floatroot.attributes("-alpha", 0.80) self.floatroot.resizable(False, False) self.floatroot.call('wm', 'attributes', '.', '-topmost', '1') self.floatroot.title("Quiick Controller") # print("Current File Name : ", os.path.realpath(__file__)) # ImagePath = str(os.path.realpath(__file__))[:-14] + "Images\\" # print(ImagePath) # floatPlayImg = PhotoImage(file=ImagePath+"FloatPlay.png") # floatPauseImg = PhotoImage(file="Images/FloatPause.png") # floatPreviousImg = PhotoImage(file="Images/FloatPrevious.png") # floatNextImg = PhotoImage(file="Images/FloatNext.png") # floatShuffleOnImg = PhotoImage(file="Images/FloatShuffle_On.png") # floatShuffleOffImg = PhotoImage(file="Images/FloatShuffle_Off.png") # floatRepeatImg = PhotoImage(file="Images/FloatRepeat.png") # floatRepeatOneImg = PhotoImage(file="Images/FloatRepeat_One.png") # floatRepeatAllImg = PhotoImage(file="Images/FloatRepeat_All.png") self.floatFrame_SongName = Frame(self.floatroot) self.floatFrame_SongName.pack(fill=BOTH, expand=TRUE) # songName = EasyID3(self.songsName[self.myIndex])['title'][0] try: self.floatSongName = EasyID3( self.songsName[self.myIndex])['title'][0] except KeyError: self.floatSongName = self.songsName[self.myIndex] except: self.floatSongName = "Song Name" self.floatLbl_SongName = Label(self.floatFrame_SongName, width=40, text=self.floatSongName, anchor=W, relief=RIDGE) self.floatLbl_SongName.pack() self.floatLbl_Controllers = Frame(self.floatroot) self.floatLbl_Controllers.pack(fill=BOTH, expand=TRUE) if (self.shuffleStatus): shuffle_icon = "S On" else: shuffle_icon = "S Off" self.floatbtn_Shuffle = Button( self.floatLbl_Controllers, width=6, relief=FLAT, text=shuffle_icon, command=lambda: self.shuffleOn() if (self.shuffleStatus == 0) else self.shuffleOff()) self.floatbtn_Shuffle.grid(row=0, column=0) self.floatbtn_Previous = Button( self.floatLbl_Controllers, width=6, relief=FLAT, text="<", command=lambda: self.previousSong()) self.floatbtn_Previous.grid(row=0, column=1) if (self.isPaused == 0): self.playTxt = "||" else: self.playTxt = "|>" self.floatbtn_PlayPause = Button( self.floatLbl_Controllers, width=6, relief=FLAT, text=self.playTxt, command=lambda: self.playSong() if (self.juststarted == 1) else self.resumeSong() if (self.isPaused == 1) else self.pauseSong()) self.floatbtn_PlayPause.grid(row=0, column=2) self.floatbtn_Next = Button(self.floatLbl_Controllers, width=6, relief=FLAT, text=">", command=lambda: self.nextSong(1)) self.floatbtn_Next.grid(row=0, column=3) if (self.repeatStatus == 0): repeat_icon = "R Norm" elif (self.repeatStatus == 1): repeat_icon = "R One" elif (self.repeatStatus == 2): repeat_icon = "R All" self.floatbtn_Repeat = Button( self.floatLbl_Controllers, width=6, relief=FLAT, text=repeat_icon, command=lambda: self.repeatOne() if (self.repeatStatus == 0) else self.repeatNorm() if (self.repeatStatus == 2) else self.repeatAll()) self.floatbtn_Repeat.grid(row=0, column=4) def float_on_closing(): # root.deiconify() root.update() root.deiconify() self.floatroot.destroy() pass self.floatroot.protocol("WM_DELETE_WINDOW", float_on_closing) self.floatroot.mainloop()
class CentralProgressBarFrame(BaseFrame): """ [ label ] [ progressbar ] """ def __init__(self, master, size_config, info_handler): super().__init__(master, size_config, info_handler) self.label_var = None self.progress_current_var = None self.progress_label = None self.progress_bar_current = None self.add_items() self.place_items() def add_items(self, *args, **kwargs): self.size_conf.divide(( (2, 1), (1, 1), ), spacing=DEFAULT_SPACING, internal=True) self.label_var = tk.StringVar() self.label_var.set("欢迎!") self.progress_current_var = tk.IntVar() self.progress_label = tk.Label(master=self, textvariable=self.label_var, anchor=tk.CENTER) self.progress_bar_current = Progressbar( master=self, orient=tk.HORIZONTAL, mode="determinate", variable=self.progress_current_var) def place_items(self): self.size_conf.place([ [self.progress_label], [self.progress_bar_current], ]) def progress_update(self, **kwargs): mode = kwargs["mode"] if mode == TRACKER_TICK_INIT: process_disc = kwargs["process_disc"] total_tick = kwargs["total_tick"] init_tick = kwargs["init_tick"] self.label_var.set(process_disc) self.progress_bar_current["maximum"] = total_tick self.progress_current_var.set(init_tick) self.label_var.set(process_disc + " ({}/{})".format(init_tick, total_tick)) elif mode == TRACKER_TICK: process_disc = kwargs["process_disc"] total_tick = kwargs["total_tick"] current_tick = kwargs["current_tick"] end = kwargs["end"] disc_fill = kwargs["disc_fill"] time_remain = kwargs["time_remain"] self.progress_current_var.set(current_tick) if end: self.progress_bar_current.stop() self.progress_bar_current.config(mode="determinate") self.label_var.set("结束!") else: message = "{} :{}{} 预计剩余: {}".format( process_disc, " " + (disc_fill if disc_fill is not None else ""), " ({}/{})".format(current_tick, total_tick), time_remain) self.label_var.set(message) elif mode == TRACKER_TICK_DESC_UPDATE: process_disc = kwargs["process_disc"] disc_fill = kwargs["process_disc_fill"] time_remain = kwargs["time_remain"] total_tick = kwargs["total_tick"] current_tick = kwargs["current_tick"] message = "{} :{}{} 预计剩余: {}".format( process_disc, " " + (disc_fill if disc_fill is not None else ""), " ({}/{})".format(current_tick, total_tick), time_remain) self.label_var.set(message) elif mode == TRACKER_SET_INDETERMINATE: indeterminate = kwargs["indeterminate"] process_disc = kwargs["process_disc"] disc_fill = kwargs["process_disc_fill"] if indeterminate: self.progress_bar_current.config(mode="indeterminate") self.progress_bar_current.start() message = "{} :{}".format( process_disc, " " + (disc_fill if disc_fill is not None else ""), ) self.label_var.set(message) else: self.progress_bar_current.stop() self.progress_bar_current.config(mode="determinate")
def initUI(self): self.master.title("Analisa Harga Saham") self.pack(fill=BOTH, expand=True) self.columnconfigure(1, weight=1) self.columnconfigure(3, pad=7) self.rowconfigure(3, weight=1) self.rowconfigure(5, pad=7) self.lbl = Label(self, text="Filename: ") self.lbl.grid(sticky=W, pady=4, padx=5, columnspan=4) self.right_frame = Frame(self, width=800, height=400, borderwidth = 1) self.right_frame.grid(row=2, column=1, columnspan=5, rowspan=4, padx=5, sticky=E+W+S+N) self.right_frame.config(relief=SOLID) self.area = Text(self.right_frame, height = 30, width = 40) self.area.grid(row=0, column=1, padx=5, sticky=W+S+N+E) self.splash = Toplevel(self.right_frame) self.splash.overrideredirect(True) self.splash.geometry('200x23+100+100') self.splash.overrideredirect(1) self.splash.bind("<B1-Motion>", self.move_window) self.splash.attributes('-topmost', 'true') window_height = 23 window_width = 400 screen_width = self.splash.winfo_screenwidth() screen_height = self.splash.winfo_screenheight() x_cordinate = int((screen_width/2) - (window_width/2)) y_cordinate = int((screen_height/2) - (window_height/2)) self.splash.geometry("{}x{}+{}+{}".format(window_width, window_height, x_cordinate, y_cordinate)) self.splash.withdraw() pb = Progressbar(self.splash, orient=HORIZONTAL, length=400) pb.config(mode='indeterminate') pb.start(10) pb.grid(row=1, column=1, sticky=W+E+S+N) # self.splash.withdraw() self.dp = DataProcessor() # upload # lblUpload = Label(self, text="upload") # lblUpload.grid(row=1, column=0, columnspan=2) abtn = Button(self, text="Upload", command=self.openFile) abtn.grid(row=1, column=0, sticky=W, padx=5) self.left_frame = Frame(self, width=200, height=400, borderwidth = 1) self.left_frame.grid(row=2, column=0) self.left_frame.config(relief=SOLID) # self.chkBox = Checkbutton(self.left_frame, text = "All data", variable=self.is_all_data, command=self.cbCallback) # self.chkBox.grid(row=1, column=0, sticky=W, padx=5) Separator(self.left_frame,orient=HORIZONTAL).grid(row=2, columnspan=1, ipadx=75, padx=5, sticky=W) self.rangeFrame = self.rangeFrame() #Frame(self.left_frame, borderwidth = 1) self.rangeFrame.grid(row=3, column=0, columnspan=2) # Button Filter self.btnFilter = Button(self.left_frame, text="Filter", command=self.callFilter) self.btnFilter.grid(row=4, column=0, sticky=W, padx=5) Separator(self.left_frame,orient=HORIZONTAL).grid(row=5, columnspan=1, ipadx=75, padx=5, sticky=W) self.txSaham = Text(self.left_frame) self.cbSaham = Combobox(self.left_frame, textvariable=self.selected_saham) self.cbSaham['values'] = [] #self.kodeSaham self.cbSaham['state'] = 'readonly' # normal self.cbSaham.set('-- Pilih Saham --') self.cbSaham.grid(row=7, column=0,padx=5, pady=5) # Buton Proses self.btnProses = Button(self.left_frame, text="proses", command=self.callProses) self.btnProses.grid(row=8, column=0, sticky=W, padx=5) Separator(self.left_frame,orient=HORIZONTAL).grid(row=9, columnspan=1, ipadx=75, padx=5, sticky=W)
class Tab(ABC): def __init__(self, view, tab_control): self.view = view self.bandas_estandar_repository = RepositoryProvider.provide_bandas_estandar_repository( ) self.tab_frame = tab_control.agregar_tab(self, self.titulo_tab) self.construir_tab() @abstractmethod def obtener_bandas(self): pass def construir_tab(self): self.construir_frame_titulo() self.construir_frame_grafica() self.construir_frame_medicion() def construir_frame_titulo(self): self.frame_titulo_grafica = Frame(self.tab_frame) self.frame_titulo_grafica.config(width=400, borderwidth=2, relief="groove") self.frame_titulo_grafica.grid(row=0, column=0, sticky="nsew", padx=10, pady=(15, 0)) self.label_titulo_grafica = Label(self.frame_titulo_grafica) self.label_titulo_grafica.config( text="Nivel de respuesta impulsional - Curva de decaimiento", bg="#0c005a") self.label_titulo_grafica.pack(fill="both", expand="True") def construir_frame_grafica(self): self.frame_grafica = Frame(self.tab_frame) self.frame_grafica.grid(row=1, column=0, padx=10, pady=10) self.frame_label_grafica = Frame(self.frame_grafica) self.frame_label_grafica.config(width=600, height=400) self.frame_label_grafica.pack_propagate(False) self.frame_label_grafica.grid(row=0, column=0) self.label_grafica = Label(self.frame_label_grafica) self.label_grafica.config(borderwidth=2, relief="groove", bg="#5893d4") self.label_grafica.pack(expand="True", fill="both") self.frame_toolbar = Frame(self.frame_grafica) self.frame_toolbar.config(width=400, height=40, borderwidth=2) self.frame_toolbar.pack_propagate(False) self.frame_toolbar.grid(row=1, column=0, sticky="nsew") self.construir_plot() def construir_plot(self): self.figura = Figure(figsize=(6, 4), dpi=100) self.figura.patch.set_facecolor("#becbff") self.sistema_ejes = self.figura.add_subplot(1, 1, 1) self.sistema_ejes.set_facecolor("#dee1ec") self.limpiar_ejes() self.canvas = FigureCanvasTkAgg(self.figura, master=self.label_grafica) self.canvas.get_tk_widget().pack(side=BOTTOM, fill=BOTH, expand=True) toolbar = NavigationToolbar2Tk(self.canvas, self.frame_toolbar) toolbar.update() def limpiar_ejes(self): self.sistema_ejes.cla() self.sistema_ejes.set_xlabel('Tiempo (s)') self.sistema_ejes.set_ylabel('Nivel (dB)') self.sistema_ejes.set_xlim(left=0, auto=True) self.sistema_ejes.set_ylim(bottom=-120, top=0, auto=True) def construir_frame_medicion(self): self.frame_medicion = Frame(self.tab_frame) self.frame_medicion.grid(row=0, column=1, rowspan=2, sticky="nsew") self.construir_frame_bandas() def construir_frame_bandas(self): self.construir_seleccion_banda() self.construir_frame_rts() def construir_seleccion_banda(self): self.frame_titulo_bandas = Label(self.frame_medicion) self.frame_titulo_bandas.config(borderwidth=2, relief="groove") self.frame_titulo_bandas.grid(row=0, column=0, sticky="nsew", padx=10, pady=(15, 0)) self.label_titulo_bandas_octava = Label(self.frame_titulo_bandas) self.label_titulo_bandas_octava.config(text=self.titulo_bandas_text, bg="#0c005a") self.label_titulo_bandas_octava.pack(ipadx=10, expand="True", fill="both") self.frame_medicion_bandas = Frame(self.frame_medicion) self.frame_medicion_bandas.grid(row=1, column=0, sticky="nsew", padx=10, pady=(20, 0)) bandas_estandar = self.obtener_bandas() self.banda_seleccionada = StringVar() self.banda_seleccionada.set(bandas_estandar[0]) self.combobox_banda = OptionMenu(self.frame_medicion_bandas, self.banda_seleccionada, *bandas_estandar) self.combobox_banda.config(relief="groove", borderwidth=0, bg="#5893d4", activebackground="#0060ca", width=20) self.combobox_banda['menu'].config(bg="#5893d4", activebackground="#0060ca") self.combobox_banda.grid(row=0, column=0, padx=10) self.ponderacion_A_checked = BooleanVar(False) self.checkbutton_ponderacion_A = Checkbutton( self.frame_medicion_bandas) self.checkbutton_ponderacion_A.config( text="Ponderación A", variable=self.ponderacion_A_checked, selectcolor="#5e0606") self.checkbutton_ponderacion_A.grid(row=0, column=1, padx=20) self.boton_calcular = Button(self.frame_medicion_bandas) self.boton_calcular.config(text="Calcular", command=self.view.on_calcular, bg="#5e0606", width=20) self.boton_calcular.grid(row=0, column=2, padx=10) def construir_frame_rts(self): self.frame_rts = Frame(self.frame_medicion) self.frame_rts.config(borderwidth=2, relief='ridge') self.frame_rts.grid(row=4, column=0, padx=10, pady=(15, 0)) self.frame_titulo_rts = Label(self.frame_rts) self.frame_titulo_rts.config(borderwidth=2, relief="groove") self.frame_titulo_rts.grid(row=0, column=0, sticky="nsew", padx=10, pady=10, columnspan=2) self.label_titulo_rts = Label(self.frame_titulo_rts) self.label_titulo_rts.config(text="Tiempos de reverberación", bg="#0c005a") self.label_titulo_rts.pack(ipadx=10, expand="True", fill="both") self.frame_titulo_linealidad = Label(self.frame_rts) self.frame_titulo_linealidad.config(borderwidth=2, relief="groove") self.frame_titulo_linealidad.grid(row=0, column=2, sticky="nsew", padx=10, pady=10, columnspan=4) self.label_titulo_linealidad = Label(self.frame_titulo_linealidad) self.label_titulo_linealidad.config(text="Parámetros de linealidad", bg="#0c005a") self.label_titulo_linealidad.pack(ipadx=10, expand="True", fill="both") self.construir_frame_edt() self.construir_frame_t20() self.construir_frame_t30() self.construir_frame_curvatura() self.construir_frame_progressbar() def construir_frame_edt(self): self.frame_edt = Frame(self.frame_rts) self.frame_edt.grid(row=1, column=0, pady=(0, 10), columnspan=2) self.label_edt = Label(self.frame_edt) self.label_edt.config(text="EDT", bg="#5893d4", borderwidth=2, relief="groove", width=4) self.label_edt.grid(row=0, column=0, padx=(0, 10), pady=10) self.edt_var = StringVar() self.label_res_edt = Label(self.frame_edt) self.label_res_edt.config(relief="sunken", bg="#becbff", borderwidth=2, width=10, textvariable=self.edt_var, fg="black") self.label_res_edt.grid(row=0, column=1, padx=(10, 0), pady=10) self.frame_linealidad_edt = Frame(self.frame_rts) self.frame_linealidad_edt.grid(row=1, column=2, pady=(0, 10), columnspan=4) self.label_r_edt = Label(self.frame_linealidad_edt) self.label_r_edt.config(text="r", bg="#5893d4", borderwidth=2, relief="groove", width=4) self.label_r_edt.grid(row=0, column=0, padx=10, pady=10) self.r_edt_var = StringVar() self.label_res_r_edt = Label(self.frame_linealidad_edt) self.label_res_r_edt.config(relief="sunken", bg="#becbff", borderwidth=2, width=10, textvariable=self.r_edt_var, fg="black") self.label_res_r_edt.grid(row=0, column=1, padx=10, pady=10) self.label_xi_edt = Label(self.frame_linealidad_edt) self.label_xi_edt.config(text="ξ", bg="#5893d4", borderwidth=2, relief="groove", width=4) self.label_xi_edt.grid(row=0, column=2, padx=10, pady=10) self.xi_edt_var = StringVar() self.label_res_xi_edt = Label(self.frame_linealidad_edt) self.label_res_xi_edt.config(relief="sunken", bg="#becbff", borderwidth=2, width=10, fg="black", textvariable=self.xi_edt_var) self.label_res_xi_edt.grid(row=0, column=3, padx=10, pady=10) def construir_frame_t20(self): self.frame_t20 = Frame(self.frame_rts) self.frame_t20.grid(row=2, column=0, pady=(0, 10), columnspan=2) self.label_t20 = Label(self.frame_t20) self.label_t20.config(text="T20", bg="#5893d4", borderwidth=2, relief="groove", width=4) self.label_t20.grid(row=0, column=0, padx=(0, 10), pady=10, sticky='w') self.t20_var = StringVar() self.label_res_t20 = Label(self.frame_t20) self.label_res_t20.config(relief="sunken", borderwidth=2, bg="#becbff", width=10, textvariable=self.t20_var, fg='black') self.label_res_t20.grid(row=0, column=1, padx=(10, 0), pady=10, sticky='e') self.frame_linealidad_t20 = Frame(self.frame_rts) self.frame_linealidad_t20.grid(row=2, column=2, pady=(0, 10), columnspan=4) self.label_r_t20 = Label(self.frame_linealidad_t20) self.label_r_t20.config(text="r", bg="#5893d4", borderwidth=2, relief="groove", width=4) self.label_r_t20.grid(row=0, column=2, padx=10, pady=10) self.r_t20_var = StringVar() self.label_res_r_t20 = Label(self.frame_linealidad_t20) self.label_res_r_t20.config(relief="sunken", bg="#becbff", borderwidth=2, width=10, textvariable=self.r_t20_var, fg='black') self.label_res_r_t20.grid(row=0, column=3, padx=10, pady=10) self.label_xi_t20 = Label(self.frame_linealidad_t20) self.label_xi_t20.config(text="ξ", bg="#5893d4", borderwidth=2, relief="groove", width=4) self.label_xi_t20.grid(row=0, column=4, padx=10, pady=10) self.xi_t20_var = StringVar() self.label_res_xi_t20 = Label(self.frame_linealidad_t20) self.label_res_xi_t20.config(relief="sunken", bg="#becbff", borderwidth=2, width=10, fg='black', textvariable=self.xi_t20_var) self.label_res_xi_t20.grid(row=0, column=5, padx=10, pady=10) def construir_frame_t30(self): self.frame_t30 = Frame(self.frame_rts) self.frame_t30.grid(row=3, column=0, pady=(0, 10), columnspan=2) self.label_t30 = Label(self.frame_t30) self.label_t30.config(text="T30", bg="#5893d4", borderwidth=2, relief="groove", width=4) self.label_t30.grid(row=0, column=0, padx=(0, 10), pady=10, sticky='w') self.t30_var = StringVar() self.label_res_t30 = Label(self.frame_t30) self.label_res_t30.config(relief="sunken", borderwidth=2, bg="#becbff", width=10, textvariable=self.t30_var, fg='black') self.label_res_t30.grid(row=0, column=1, padx=(10, 0), pady=10, sticky='e') self.frame_linealidad_t30 = Frame(self.frame_rts) self.frame_linealidad_t30.grid(row=3, column=2, pady=(0, 10), columnspan=4) self.label_r_t30 = Label(self.frame_linealidad_t30) self.label_r_t30.config(text="r", bg="#5893d4", borderwidth=2, relief="groove", width=4) self.label_r_t30.grid(row=0, column=2, padx=10, pady=10) self.r_t30_var = StringVar() self.label_res_r_t30 = Label(self.frame_linealidad_t30) self.label_res_r_t30.config(relief="sunken", bg="#becbff", borderwidth=2, width=10, textvariable=self.r_t30_var, fg='black') self.label_res_r_t30.grid(row=0, column=3, padx=10, pady=10) self.label_xi_t30 = Label(self.frame_linealidad_t30) self.label_xi_t30.config(text="ξ", bg="#5893d4", borderwidth=2, relief="groove", width=4) self.label_xi_t30.grid(row=0, column=4, padx=10, pady=10) self.xi_t30_var = StringVar() self.label_res_xi_t30 = Label(self.frame_linealidad_t30) self.label_res_xi_t30.config(relief="sunken", bg="#becbff", borderwidth=2, width=10, fg='black', textvariable=self.xi_t30_var) self.label_res_xi_t30.grid(row=0, column=5, padx=10, pady=10) def construir_frame_curvatura(self): self.frame_curvatura = Frame(self.frame_rts) self.frame_curvatura.grid(row=4, column=2, pady=(0, 10), columnspan=4, sticky='e') self.label_curvatura = Label(self.frame_curvatura) self.label_curvatura.config(text="C", bg="#5893d4", borderwidth=2, relief="groove", width=4) self.label_curvatura.grid(row=0, column=0, padx=(0, 10), pady=10, sticky='w') self.curvatura_var = StringVar() self.label_res_curvatura = Label(self.frame_curvatura) self.label_res_curvatura.config(relief="sunken", borderwidth=2, bg="#becbff", width=10, textvariable=self.curvatura_var, fg='black') self.label_res_curvatura.grid(row=0, column=1, padx=10, pady=10) def get_frecuencia_central_banda_seleccionada(self): return float(self.banda_seleccionada.get()) def get_tipo(self): return self.tipo def verificar_ponderacion_A(self): return self.ponderacion_A_checked.get() def desactivar(self): self.combobox_banda.config(state=DISABLED) self.checkbutton_ponderacion_A.config(state=DISABLED) self.boton_calcular.config(state=DISABLED) def activar(self): self.combobox_banda.config(state=NORMAL) self.checkbutton_ponderacion_A.config(state=NORMAL) self.boton_calcular.config(state=NORMAL) def graficar(self, nivel_respuesta_impulsional, curva_decaimiento): dominio_temporal_ri = nivel_respuesta_impulsional.get_dominio_temporal( ) valores_ri = nivel_respuesta_impulsional.get_valores() dominio_temporal_cd = curva_decaimiento.get_dominio_temporal() valores_cd = curva_decaimiento.get_valores() self.limpiar_ejes() self.sistema_ejes.plot(dominio_temporal_ri, valores_ri, color='#0000ff', linewidth=0.5, label='Nivel respuesta impulsional') self.sistema_ejes.plot(dominio_temporal_cd, valores_cd, color="#ff0000", linewidth=1, label='Curva de decaimiento') self.sistema_ejes.legend() self.canvas.draw() def mostrar_tiempos_de_reverberacion(self, edt, t20, t30): self.edt_var.set(str(round(edt, 4)) + "seg") self.t20_var.set(str(round(t20, 4)) + "seg") self.t30_var.set(str(round(t30, 4)) + "seg") def mostrar_parametros_de_linealidad(self, edt, t20, t30, curvatura): self.r_edt_var.set(round(edt.get_coef_correlacion(), 4)) self.xi_edt_var.set(str(round(edt.get_xi(), 4)) + "‰") self.r_t20_var.set(round(t20.get_coef_correlacion(), 4)) self.xi_t20_var.set(str(round(t20.get_xi(), 4)) + "‰") self.r_t30_var.set(round(t30.get_coef_correlacion(), 4)) self.xi_t30_var.set(str(round(t30.get_xi(), 4)) + "‰") self.curvatura_var.set(str(round(curvatura, 4)) + "%") def construir_frame_progressbar(self): self.pb_frame = Frame(self.frame_medicion) self.pb_frame.config(padx=20, pady=20) self.frame_calculando = Frame(self.pb_frame) self.frame_calculando.grid(row=0, column=0, pady=10) self.label_calculando = Label(self.frame_calculando) self.label_calculando.config(text="Calculando") self.label_calculando.pack(expand="True", fill="both") self.progressbar = Progressbar(self.pb_frame) self.progressbar.config(mode="indeterminate", length=250) self.progressbar.grid(row=1, column=0, pady=10) def activar_progressbar(self): self.pb_frame.grid(row=5, column=0) self.progressbar.start(10) def desactivar_progressbar(self): self.progressbar.stop() self.pb_frame.grid_remove() def redibujar_canvas(self): self.canvas.draw() self.canvas.get_tk_widget().pack() def ocultar_grafica(self): self.canvas.get_tk_widget().pack_forget()
class App: def __init__(self, _async_loop): self.async_loop = _async_loop self.imgs = {} self.imgs_length = 0 self.img_selected = None # Build TK self.window = Tk() self.window.title = 'Aplicación Gráfica!' self.window.geometry('850x100') self.window.resizable(False, False) self.window.configure(bg=bg_color) # Build Title self.title_app = Label(text="URL a procesar", bg=bg_color, width=20, fg=font_color) self.title_app.grid(column=0, row=1, padx=10) # Build search self.search = Entry(width=40, bg=bg_color, fg=font_color) self.search.grid(column=1, row=1, pady=10, padx=5) # Build button search self.button_search = Button(text='Buscar', command=self.observe_search_button, highlightbackground=bg_color, width=10) \ .grid(column=2, row=1, columnspan=2, sticky="w") # Build listbox self.listbox = Listbox(background=bg_color, fg=font_color, selectbackground=black_color) self.listbox.grid_forget() self.listbox.bind("<<ListboxSelect>>", self.observe_select_item) # Build canvas self.canvas = Canvas(self.window, width=300, height=300, bg=bg_color, borderwidth=0) self.canvas.grid_forget() # Build label status download images self.status_download_files = Label(text="", bg=bg_color, fg=font_color) self.status_download_files.grid_forget() # Build progress bar to show progress while downloading images self.progress_bar = Progressbar(self.window, orient=HORIZONTAL, length=100, mode='determinate') self.progress_bar.grid_forget() self.window.mainloop() ''' Method to initialize flow when user click on button search ''' def initialize_flow_download(self): self.imgs = {} self.imgs_length = 0 self.listbox.delete(0, END) self.listbox.grid(column=0, row=3, columnspan=2, padx=10, sticky="nsew") self.status_download_files.grid(column=0, row=4, columnspan=4, sticky="se", pady=5) self.progress_bar.grid(column=2, row=5, columnspan=4, sticky="ew") self.canvas.grid(row=3, column=2, columnspan=2) self.img_selected = None self.title_app.config(text="Procesando url") self.window.geometry('850x450') # START SECTION OBSERVABLE DOWNLOAD URL IMAGES ''' Method to initialize async loop until complete download images ''' def _asyncio_thread(self, _imgs, observer): self.async_loop.run_until_complete( self.download_images(_imgs, observer)) async def download_images(self, _imgs, observer): downloads = [self.download_image(img) for img in _imgs] await asyncio.wait(downloads) observer.on_completed() def observable_search_button(self, url): def search_page(o, s): try: content = requests.get(url) soup = BeautifulSoup(content.text, 'html.parser') _imgs = soup.find_all('img') self.imgs_length = len(_imgs) self.status_download_files.config( text=f'Se han descargado 0 de {self.imgs_length} imagenes') self.title_app.config(text="Descargando imagenes") threading.Thread(target=self._asyncio_thread, args=( _imgs, o, )).start() except Exception as e: print(e) self.listbox.grid_forget() self.status_download_files.grid_forget() self.progress_bar.grid_forget() self.canvas.grid_forget() self.window.geometry('650x100') self.title_app.config(text="Error url") return create(search_page) async def download_image(self, img): try: async with aiohttp.ClientSession() as session: async with session.get(img['src']) as resp: img_downloaded = await resp.read() alt_img = f'{img["alt"] or "Imagen"}' alt_img_key = f'{alt_img}_{self.listbox.size()}' self.imgs[alt_img_key] = img_downloaded self.listbox.insert(self.listbox.size(), alt_img) self.status_download_files.config( text= f'Se han descargado {self.listbox.size()} de {self.imgs_length} imagenes', bg=bg_color) self.progress_bar.config(value=self.listbox.size() * 100 / self.imgs_length) except Exception as e: print(e) print(img['src'] + " No ha podido ser descargada correctamente") def download_completed(self): self.status_download_files.configure( text=f'Descarga finalizada de las {self.imgs_length} imagenes') self.title_app.config(text="Introduce nueva URL") self.progress_bar.grid_forget() def observe_search_button(self): self.initialize_flow_download() self.observable_search_button( self.search.get()).subscribe(on_completed=self.download_completed) # END SECTION OBSERVABLE DOWNLOAD URL IMAGES # START SECTION OBSERVABLE LISTBOX def observable_select_item(self, widget, index): def search_item(o, s): try: img_key = f'{widget.get(index)}_{index}' aux_image = resize_image(self.imgs[img_key], "bytes") self.img_selected = ImageTk.PhotoImage(aux_image) self.canvas.create_image(20, 20, anchor=NW, image=self.img_selected) except Exception as e: print(e) aux_image = resize_image("./assets/imgs/default.jpg", "file") self.img_selected = ImageTk.PhotoImage(aux_image) self.canvas.create_image(20, 20, anchor=NW, image=self.img_selected) o.on_completed() return create(search_item) def item_load_completed(self): print("Imagen cargada correctamente") def observe_select_item(self, event): self.observable_select_item(event.widget, event.widget.curselection()[0]) \ .subscribe(on_completed=self.item_load_completed)
class AutoEmail_GUI: def __init__(self): self.window = tk.Tk() self.window.geometry("720x550") self.widgets = {} # Language dropdown # Options bar self.opt_bar = tk.Frame(self.window, height=40) languages = list(lang_ctl._ALL.keys()) self.current_lang = StringVar(self.window) self.current_lang.set(languages[0]) self.lang_menu = tk.OptionMenu(self.opt_bar, self.current_lang, *languages) self.lang_menu.pack(side="right", fill="both", expand=True) # Get lang self.text_dict = lang_ctl.get_lang(self.current_lang.get()) self.window.title(self.text_dict["window"]["title"]) select_lang_label = tk.Label( self.opt_bar, text=self.text_dict["window"]["select_lang"]) self.widgets["window/select_lang"] = select_lang_label select_lang_label.pack(side="top", fill="both", expand=True) self.opt_bar.pack(side="top") # Top Frame self.menu_top = tk.Frame(self.window, height=100) # Main text welcome_text = tk.Label(self.menu_top, text=self.text_dict["window"]["body"], anchor="w", justify="left") self.widgets["window/body"] = welcome_text welcome_text.pack() self.menu_top.pack(side="top", fill="both", expand=True) # It's duplicated, we need a list of widgets here self.widgets["window/select_file"] = [] self.widgets["button/open"] = [] self.widgets["window/sample_path"] = [] # Mid Frame self.menu_credentials = tk.Frame(self.window, height=1, width=200) self.menu_credentials_left = tk.Frame(self.menu_credentials) creds = tk.Label(self.menu_credentials, text=self.text_dict["window"]["credentials"], font=("", 16)) self.widgets["window/credentials"] = creds creds.pack(side=tk.TOP, pady=5) # Delete credentials button del_button = tk.Button( self.menu_credentials, text=self.text_dict["button"]["delete"], command=self.reset_credentials, height=2, width=30, ) self.widgets["button/delete"] = del_button del_button.pack(side=tk.TOP, pady=10) tk.Label(self.menu_credentials_left, text="Email", font=("", 10)).pack(side=tk.TOP) self.menu_credentials_left.pack(side=tk.LEFT, padx=(0, 10)) self.menu_credentials_right = tk.Frame(self.menu_credentials) # User Entry self.username = StringVar(self.window) self.username.set("*****@*****.**") self.user_box = tk.Entry(self.menu_credentials_right, textvariable=self.username, width=40) self.user_box.pack(side=tk.TOP) self.menu_credentials_right.pack(side=tk.RIGHT) self.menu_credentials.pack(pady=10) self.menu_mid = tk.Frame(self.window, height=150) self.menu_mid.pack(side="top", fill="both", expand=True) self.menu_mid_left = tk.Frame(self.menu_mid, height=200, width=200, bd=2, relief="groove", padx=5) self.input_file_box(self.menu_mid_left, False, True) self.menu_mid_left.pack(side="left", fill="both", expand=True, padx=10, pady=10) self.menu_mid_right = tk.Frame(self.menu_mid, height=200, width=200, bd=2, relief="groove", padx=5) self.input_file_box(self.menu_mid_right, True, False) self.menu_mid_right.pack(side="right", fill="both", expand=True, padx=10, pady=10) # Bottom Frame self.menu_bot = tk.Frame(self.window, height=50) # Checkbox Menu self.options_menu = tk.Frame(self.window, height=20, relief="groove", bd=2) # Checkbox Debug self.checkbox_debug = tk.BooleanVar(self.window) self.checkbox_debug.set(True) debug_checkbox = tk.Checkbutton( self.options_menu, text=self.text_dict["settings"]["debug"], variable=self.checkbox_debug, command=self.debug_checkbox_clicked, ) self.widgets["settings/debug"] = debug_checkbox debug_checkbox.pack(side="right") # Checkbox SendIfFiles self.checkbox_only_att = tk.BooleanVar(self.window) self.checkbox_only_att.set(True) sendiffiles_checkbox = tk.Checkbutton( self.options_menu, text=self.text_dict["settings"]["only_att"], variable=self.checkbox_only_att, command=self.onlyatt_checkbox_clicked) self.widgets["settings/only_att"] = sendiffiles_checkbox sendiffiles_checkbox.pack(side="left", padx=(5, 0)) self.num_att = tk.Spinbox(self.options_menu, from_=0, to=99) self.num_att.pack(side="left", padx=(0, 0)) # Checkbox OnlyPDF self.checkbox_onlypdf = tk.BooleanVar(self.window) self.checkbox_onlypdf.set(True) onlypdf_checkbox = tk.Checkbutton( self.options_menu, text=self.text_dict["settings"]["only_pdf"], variable=self.checkbox_onlypdf, command=self.onlypdf_checkbox_clicked, ) self.widgets["settings/only_pdf"] = onlypdf_checkbox onlypdf_checkbox.pack(side="left", padx=(20, 20)) self.options_menu.pack(side="top", pady=(0, 10)) # Execute bttton run_button = tk.Button(self.menu_bot, text=self.text_dict["button"]["run"], font=("", 14), command=self.bar_init, height=2, width=30) self.widgets["button/run"] = run_button run_button.pack() self.progressbar = Progressbar(self.menu_bot, mode="indeterminate") self.progressbar.pack(side="bottom", fill="both", expand=True, padx=5, pady=5) self.progressbar.config(value=0, maximum=0) self.menu_bot.pack(fill="both", expand=True) # link function to change dropdown self.current_lang.trace("w", self.change_lang) self.domainCtl = Domain_Ctl() self.window.mainloop() def debug_checkbox_clicked(self): self.domainCtl.set_debug_mode(self.checkbox_debug.get()) def onlyatt_checkbox_clicked(self): self.domainCtl.set_only_with_att(self.checkbox_only_att.get()) def onlypdf_checkbox_clicked(self): self.domainCtl.set_only_pdf(self.checkbox_onlypdf.get()) def select_file(self, isleft: bool, isdir: bool): tk.Tk().withdraw( ) # we don't want a full GUI, so keep the root window from appearing///// if isdir: filename = askdirectory( ) # show an "Open" dialog box and return the path to the selected file else: filename = askopenfilename( ) # show an "Open" dialog box and return the path to the selected file if isleft: self.left_file.delete(0, tk.END) self.left_file.insert(0, filename) logging.info("Data file selected: " + str(filename)) else: self.right_file.delete(0, tk.END) self.right_file.insert(0, filename) logging.info("Attachment dir selected: " + str(filename)) def input_file_box(self, parent, dir: bool, left: bool): input1_text = tk.Label(parent, text=self.text_dict["window"]["select_file"], font=("", 12)) self.widgets["window/select_file"].append(input1_text) input1_text.pack() if left: self.left_file = tk.Entry(parent) self.widgets["window/sample_path"].append(self.left_file) self.left_file.insert(0, self.text_dict["window"]["sample_path"]) self.left_file.pack(side="left", fill="x", expand=True, ipady=4) bt = tk.Button(parent, text=self.text_dict["button"]["open"], command=lambda: self.select_file(left, dir)) self.widgets["button/open"].append(bt) bt.pack(side="right") else: self.right_file = tk.Entry(parent) self.widgets["window/sample_path"].append(self.right_file) self.right_file.insert(0, self.text_dict["window"]["sample_path"]) self.right_file.pack(side="left", fill="x", expand=True, ipady=4) bt = tk.Button(parent, text=self.text_dict["button"]["open"], command=lambda: self.select_file(left, dir)) self.widgets["button/open"].append(bt) bt.pack(side="right") def reset_credentials(self): try: os.remove(common.BASE_DIR / pathlib.Path("resources\\.credentials\\token.pickle")) showinfo(lang_ctl._FULL_VERSION, self.text_dict["popup"]["cred_del"]) except: showinfo(lang_ctl._FULL_VERSION, self.text_dict["popup"]["cred_del_err"]) def run(self): excel = self.left_file.get() att_dir = self.right_file.get() if os.path.exists(excel) and os.path.exists(att_dir): logging.info("Send_emails_from_excel Started") self.domainCtl.set_credentials(self.username.get()) self.domainCtl.set_min_att(int(self.num_att.get())) logging.info("Min att is %d" % int(self.num_att.get())) try: self.domainCtl.send_emails_from_excel(excel, att_dir) except PermissionError as e1: showerror(self.text_dict["popup"]["cred_err"], str(e1)) except Exception: # General exception showerror(self.text_dict["popup"]["err"]) if len(self.domainCtl.mail_error_list) != 0: showinfo( lang_ctl._FULL_VERSION, self.text_dict["popup"]["finished_w_err"] + "\n".join(self.domainCtl.mail_error_list)) self.domainCtl.clear_error_list() else: showinfo(lang_ctl._FULL_VERSION, self.text_dict["popup"]["finished"]) else: showerror("IOError", self.text_dict["popup"]["ioerror"]) def bar_init(self): # first layer of isolation, note var being passed along to the self.start_bar function # target is the function being started on a new thread, so the "bar handler" thread self.start_bar_thread = threading.Thread(target=self.start_bar) # start the bar handling thread self.start_bar_thread.start() def start_bar(self): # the progressbar needs to be configured for indeterminate amount of bouncing self.progressbar.config(mode="indeterminate", maximum=100, value=0) # 8 here is for speed of bounce self.progressbar.start(8) # start the work-intensive thread, again a var can be passed in here too if desired self.work_thread = threading.Thread(target=self.run) self.work_thread.start() # close the work thread self.work_thread.join() # stop the indeterminate bouncing self.progressbar.stop() # reconfigure the bar so it appears reset self.progressbar.config(value=0, maximum=0) self.change_lang() def change_lang(self, *args): self.text_dict = lang_ctl.get_lang(self.current_lang.get()) self.set_text() def set_text(self): for key in self.widgets: group, index = tuple(key.split("/")) if isinstance(self.widgets[key], list): for wg in self.widgets[key]: if isinstance(wg, tk.Entry): wg.delete(0, tk.END) wg.insert(0, self.text_dict[group][index]) else: wg.configure(text=self.text_dict[group][index]) else: self.widgets[key].configure(text=self.text_dict[group][index])
class Application(Frame): """Main class, handles GUI and starts logic""" def __init__(self, master=None, arguments=()): super().__init__(master) self._file_path = "" self._output_dir = "" self._same_dir = IntVar(value=1) # By default output path is the same as file path self._show_password = False self._db_type = IntVar(value=self.DB_TYPE_MARIADB()) self._master = master self.grid() try: self._create_widgets() except Exception as ex: messagebox.showerror("Error", ex.args[0]) self._same_dir_as_file() # Disable output button and it sets output dir at start self._convert_progressbar.grid_remove() # Hide loading bar at start if self._is_file_path_in_arguments(arguments): self._set_file_path(arguments[1]) def _is_file_path_in_arguments(self, arguments): """Method to check if arguments[1] (because arguments[0] is application path) is a file path """ if arguments.__len__() > 1: file_path = arguments[1] if path.isfile(file_path): extension = path.splitext(file_path)[1] if extension == ".mdb" or extension == ".accdb": return True return False def _create_widgets(self): """GUI building""" # File widgets self._filename_label = Label(self._master, width="22", anchor="e", text="Access File (*.mdb, *.accdb):") self._filename_label.grid(row=0, column=0) self._filename_path_label = Label(self._master, width="50", anchor="w", textvariable=self._file_path, bg="#cccccc") self._filename_path_label.grid(row=0, column=1) self._browse_file_button = Button(self._master, text="...", width="3", command=self._browse_file) self._browse_file_button.grid(row=0, column=2) # Password widget self._password_label = Label(self._master, width="22", anchor="e", text="Password (else leave empty):") self._password_label.grid(row=1, column=0) self._password_entry = Entry(self._master, width="58", show="*") self._password_entry.grid(row=1, column=1) self._password_show_image = PhotoImage(file=path.join(module_dir, "images\\watch_pwd.png")).subsample(8, 8) self._password_show_button = Button(self._master, width="3", command=self._show_hide_password, image=self._password_show_image) self._password_show_button.grid(row=1, column=2) # Checkbox widget self._same_dir_as_file_checkbox = Checkbutton(self._master, width="50", text="Same directory as source file", var=self._same_dir, command=self._same_dir_as_file) self._same_dir_as_file_checkbox.grid(row=2, column=1, pady=8) # Output widgets self._output_label = Label(self._master, width="22", anchor="e", text="Output directory:") self._output_label.grid(row=3, column=0) self._output_dir_label = Label(self._master, width="50", anchor="w", textvariable=self._file_path, bg="#cccccc") self._output_dir_label.grid(row=3, column=1) self._browse_dir_button = Button(self._master, text="...", width="3", command=self._browse_dir) self._browse_dir_button.grid(row=3, column=2) # Radio buttons for PostgreSQL or MySQL/MariaDB self._db_type_label = Label(self._master, width="22", anchor="e", text="Database type:") self._db_type_label.grid(row=4, column=0) self._db_type_frame = Frame(self._master) self._db_type_frame.grid(row=4, column=1, columnspan=2, pady=5) self._radio_button_postgres = Radiobutton(self._db_type_frame, text="PostgreSQL", var=self._db_type, value=self.DB_TYPE_POSTGRESQL(), width="13") self._radio_button_postgres.grid(row=0, column=0) self._radio_button_mariadb = Radiobutton(self._db_type_frame, text="MariaDB", var=self._db_type, value=self.DB_TYPE_MARIADB(), width="13") self._radio_button_mariadb.grid(row=0, column=1) self._radio_button_mysql = Radiobutton(self._db_type_frame, text="MySQL", var=self._db_type, value=self.DB_TYPE_MYSQL(), width="13") self._radio_button_mysql.grid(row=0, column=2) # Convert widget & progressbar self._convert_frame = Frame(self._master) self._convert_frame.grid(row=5, column=0, columnspan=2, pady=5) self._convert_button = Button(self._convert_frame, width="84", text="CREATE SQL FILE", command=self.convertSQL, state="disabled") self._convert_button.grid(row=0, column=0) self._convert_progressbar = Progressbar(self._convert_frame, length="512") self._convert_progressbar.grid(row=1, column=0) def convertSQL(self): """SQL file generator""" self._convert_progressbar.grid(row=1, column=0) # Show progressbar self._convert_progressbar["value"] = 0 self._master.config(cursor="wait") accessconnector = Accessconnector() try: driver = accessconnector.driver(self._file_path) con = accessconnector.con(driver, self._file_path, self._get_password()) self._convert_progressbar["value"] = 33 except (AccessConnectionError, ODBCDriverNotFoundError) as ex: self._master.config(cursor="") self._convert_progressbar["value"] = 100 messagebox.showerror("Error", ex) else: cur = con.cursor() database_name = StringDialog.ask_string(title_="Database name", prompt="Name for database:") if database_name is not None: if database_name == "": messagebox.showinfo("Error", "Database name field cannot be blank") else: self._convert_progressbar["value"] = 66 accesshandler = Accesshandler(cur) accesshandler.make_file(self._output_dir, database_name, self._db_type.get()) messagebox.showinfo("Completed", "SQL file generated successfully") cur.close() con.close() self._master.config(cursor="") self._convert_progressbar["value"] = 100 def _set_file_path(self, file_path): """Setter for file path, updates file path label and output dir based on _same_dir""" self._file_path = file_path self._filename_path_label.config(text=self._file_path) if self._is_same_dir() == 1: self._set_output_dir(path.dirname(self._file_path)) if self._file_path != "" and self._output_dir != "": # Enable convert button if it´s good to go self._convert_button.config(state="normal") self._update_gui_size() def _set_output_dir(self, output_dir): """Setter for output dir""" self._output_dir = output_dir self._output_dir_label.config(text=self._output_dir) if self._file_path != "" and self._output_dir != "": # Enable convert button if it´s good to go self._convert_button.config(state="normal") self._update_gui_size() def _update_gui_size(self): """Method for expanding or shrinking GUI based on the length of the paths""" min_size = 50 # Standard min-size on creating GUI for _filename_path_label ... size = max(self._file_path.__len__(), self._output_dir.__len__()) if size > min_size: self._filename_path_label.config(width=size) self._output_dir_label.config(width=size) self._same_dir_as_file_checkbox.config(width=size) self._password_entry.config(width=int((size * 58) / min_size)) self._convert_button.config(width=int((size * 84) / min_size)) self._convert_progressbar.config(length=int((size * 512) / min_size)) elif size <= min_size: self._filename_path_label.config(width=50) self._output_dir_label.config(width=50) self._same_dir_as_file_checkbox.config(width=50) self._password_entry.config(width=58) self._convert_button.config(width=84) self._convert_progressbar.config(length=512) def _same_dir_as_file(self): """Functionality for disabling or enabling browse output dir button and setting _output_dir based on _file_path """ if self._is_same_dir() == 1: self._set_output_dir(path.dirname(self._file_path)) self._browse_dir_button.config(state="disabled") else: self._browse_dir_button.config(state="normal") def _show_hide_password(self): """Show/Hide password by current _show_password value and updates it""" if self._show_password: self._password_entry.config(show="*") try: self._password_show_image = PhotoImage(file=path.join(module_dir, "images\\watch_pwd.png")).subsample(8, 8) except Exception as ex: messagebox.showerror("Error", ex) else: self._password_entry.config(show="") try: self._password_show_image = PhotoImage(file=path.join(module_dir, "images\\hide_pwd.png")).subsample(8, 8) except Exception as ex: messagebox.showerror("Error", ex) self._password_show_button.config(image=self._password_show_image) self._show_password = not self._show_password def _browse_file(self): """Browse file functionality""" file_path = askopenfilename(filetypes=[("Microsoft Access", ".mdb .accdb")]) if file_path != "": # If browse window is closed then don´t update self._set_file_path(file_path) def _browse_dir(self): """Browse dir functionality""" output_dir = askdirectory() if output_dir != "": # If browse window is closed then don´t update self._set_output_dir(output_dir) def _get_password(self): """Getter for password""" return self._password_entry.get() def _is_same_dir(self): """Getter for _same_dir""" return self._same_dir.get() @staticmethod def DB_TYPE_POSTGRESQL(): """POSTGRESQL constant""" return 1 @staticmethod def DB_TYPE_MARIADB(): """MARIADB constant""" return 2 @staticmethod def DB_TYPE_MYSQL(): """MYSQL constant""" return 3
var=type_value, onvalue="BW", offvalue="") type_list = [ type_1, type_2, type_3, type_placeholder, type_4, type_5, type_6, type_7 ] # for loop to pack & configure checkbuttons for l in type_list: l.config(font=('Courier', 10)) l.pack(fill="both") # Progress bar widget progress = Progressbar(middle_frame_3, orient='horizontal') progress.pack(fill='both') # Progress bar config progress.config(mode='determinate', value=0, maximum=100) # print messages from the bulk_download function display_message_1 = tk.StringVar() display_message_2 = tk.StringVar() error_message = tk.StringVar() display_message_1.set("Messages here provide download progress feedback.") message_area_1 = tk.Label(middle_frame_4, textvariable=display_message_1, font=('Courier', 10)) message_area_2 = tk.Label(middle_frame_4, textvariable=display_message_2, font=('Courier', 10), fg='green') message_area_3 = tk.Label(middle_frame_4, textvariable=error_message,
class App(Tk): def __init__(self, master=None): super().__init__(master) self.style = ThemedStyle(self) self.style.set_theme('elegance') self.iconbitmap(r'data\app.ico') self.minsize(450, 300) self.title('WoT Battle Counter') self.menu_bar = Menu(self) self.content = Frame(self) self.entry = Entry(self.content) self.player_list = Listbox(self.content) self.count_button = Button(self) self.scrollbar = Scrollbar(self.content) self.buttons_frame = Frame(self) self.sort_button = Checkbutton(self.buttons_frame) self.progressbar = Progressbar(self.buttons_frame) self.sort_variable = IntVar(self) self.PlayerObjects = [] self.replays = [] self.player_names = [] self.offset = 0 self.skirmish_value = 1 self.advance_value = 1 self.clan_war_value = 3 def create_app(self): # Config menu entries and attach them self.menu_bar.add_command(label='Config', command=self.open_config_window) self.menu_bar.add_command(label='Open replay files', command=self.open_skirmish_files) self.menu_bar.add_command(label='Open list', command=self.load_list) self.menu_bar.add_command(label='Save list', command=self.save_list) self.menu_bar.add_command(label='Export to file', command=self.export_to_file) self.menu_bar.add_command(label='About', command=about) self.config(menu=self.menu_bar) # Config main content window self.content.pack(fill='both', expand=1) # Config Text Entry + bind enter key self.entry.config(exportselection=0) self.entry.pack(fill='x') self.entry.bind('<Return>', self.add_player) # Config Listbox + bind delete key self.player_list.config(yscrollcommand=self.scrollbar.set) self.scrollbar.config(command=self.player_list.yview, orient='vertical') self.scrollbar.pack(side='right', fill='y') self.player_list.pack(side='left', fill='both', expand=1) self.player_list.bind('<Delete>', self.remove_player) # Count button at the bottom self.count_button.config( text='Count!', command=Thread(target=self.decode_replays).start) self.count_button.pack(side='right', padx=10, pady=10) self.count_button.state(['disabled']) # Config button frame + button + progressbar self.buttons_frame.pack(side='left', fill='both', pady=5, padx=5, expand=1) self.sort_button.config(text="Sort the list", variable=self.sort_variable) self.sort_button.pack(anchor='nw', pady=3, padx=3) self.progressbar.config(length=360, mode='indeterminate', orient=HORIZONTAL, maximum=10) self.progressbar.pack(anchor='e', pady=3, padx=3) # Config the style Style().configure('TEntry', background='white') Style().configure('TButton', font=('Roboto', 12)) Style().configure('OK.TButton', font=('Roboto', 12, 'bold')) # Loading configuration self.load_config() # Start the app self.mainloop() def add_player(self, event): name = self.entry.get() self.entry.delete(0, 'end') player_obj = Player(name) self.PlayerObjects.append(player_obj) if self.sort_variable.get() == 1: self.PlayerObjects.sort(key=lambda player: player.name.lower()) self.player_list.delete(0, 'end') for player in self.PlayerObjects: self.player_list.insert('end', (self.PlayerObjects.index(player) + self.offset + 1, player.name)) else: self.player_list.delete(0, 'end') for player in self.PlayerObjects: self.player_list.insert('end', (self.PlayerObjects.index(player) + self.offset + 1, player.name)) def remove_player(self, event): select = self.player_list.curselection() name = self.player_list.get(select) self.player_list.delete(select) for player in self.PlayerObjects: if name.split()[1] == player.name: self.PlayerObjects.remove(player) self.player_list.delete(0, 'end') for player in self.PlayerObjects: self.player_list.insert('end', (self.PlayerObjects.index(player) + self.offset + 1, player.name)) def open_skirmish_files(self): directory_path = filedialog.askdirectory() if not path.exists(directory_path): return self.replays = self.list_dir(directory_path) self.count_button.state(['!disabled']) def save_list(self): file_path = filedialog.asksaveasfilename(defaultextension='.json') if not path.exists(file_path): return players = list() for player in self.PlayerObjects: players.append(player.name) if path.isfile(file_path): f = open(file_path, 'w') else: f = open(file_path, 'x') f.seek(0) f.write(dumps(players)) def load_list(self): file_path = filedialog.askopenfilename( filetypes=[('json-file', '*.json'), ('all files', '*.*')]) if path.isfile(file_path): self.player_list.delete(0, 'end') f = open(file_path, 'r') players = loads(f.read()) for name in players: player_obj = Player(name) self.PlayerObjects.append(player_obj) for player in self.PlayerObjects: self.player_list.insert('end', (self.PlayerObjects.index(player) + self.offset + 1, player.name)) def export_to_file(self): file_path = filedialog.asksaveasfilename(defaultextension='.txt') if path.isfile(file_path): f = open(file_path, 'w') elif path.exists(file_path): f = open(file_path, 'x') else: return data = str() for player in self.PlayerObjects: if player.battles >= 100: data += f'{player.battles} {player.name} \n' elif player.battles >= 10: data += f'{player.battles} {player.name} \n' elif player.battles > 0: data += f'{player.battles} {player.name} \n' f.seek(0) f.write(data) def list_dir(self, path): entries = listdir(path) re_replay = compile('\.wotreplay') re_file = compile('\.') replays = [] # recursive function for searching in subdirectories for .wotreplay files and putting them into a list for entry in entries: if not search(re_file, entry): new_path = path + "/" + entry new_replays = self.list_dir(new_path) for replay in new_replays: replays.append(replay) elif search(re_replay, entry): replays.append((path + '/' + entry)) elif not search(re_replay, entry) and search(re_file, entry): continue return replays def decode_replays(self): self.progressbar.start() thread_queue = Queue() replay_list_1 = [ self.replays[x] for x in range(0, round(len(self.replays) / 4)) ] replay_list_2 = [ self.replays[x] for x in range(round(len(self.replays) / 4), round(len(self.replays) / 4) * 2) ] replay_list_3 = [ self.replays[x] for x in range( round(len(self.replays) / 4) * 2, round(len(self.replays) / 4) * 3) ] replay_list_4 = [ self.replays[x] for x in range( round(len(self.replays) / 4) * 3, len(self.replays)) ] thread_1 = Thread(target=self.convert_binary_data, args=(replay_list_1, thread_queue)) thread_2 = Thread(target=self.convert_binary_data, args=(replay_list_2, thread_queue)) thread_3 = Thread(target=self.convert_binary_data, args=(replay_list_3, thread_queue)) thread_4 = Thread(target=self.convert_binary_data, args=(replay_list_4, thread_queue)) threads = (thread_1, thread_2, thread_3, thread_4) for thread in threads: thread.start() sleep(1) if self.listen_for_result(threads): self.player_names = thread_queue.get() for name in thread_queue.get(): self.player_names.append(name) for name in thread_queue.get(): self.player_names.append(name) for name in thread_queue.get(): self.player_names.append(name) # COUNTING TIME! for name in self.player_names: for player in self.PlayerObjects: if name[0] == player.name: player.battles += name[1] # Insert names together with battle count back into the list self.player_list.delete(0, 'end') for player in self.PlayerObjects: if player.battles > 0: self.player_list.insert( 'end', (self.PlayerObjects.index(player) + self.offset + 1, player.name, player.battles)) else: continue self.progressbar.stop() def listen_for_result(self, threads): # Check if all replay results have come in alive_threads = 0 for thread in threads: thread.join(0.1) for thread in threads: if thread.is_alive(): print("thread not ded") alive_threads += 1 if alive_threads > 0: if self.listen_for_result(threads): return True return True def convert_binary_data(self, replays, queue): player_names = list() for replay in range(len(replays)): filename_source = replays[replay] f = open(filename_source, 'rb') f.seek(8) size = f.read(4) data_block_size = unpack('I', size)[0] f.seek(12) my_block = f.read(int(data_block_size)) # Convert binary data into a json and then into an iterable tuple json_replay = loads(my_block) players_dict = [(v, k) for (k, v) in dict.items(json_replay['vehicles'])] # Extract names and append to a list for player_id in players_dict: player_name = player_id[0]['name'] if json_replay['battleType'] == 20: player_names.append((player_name, self.skirmish_value)) elif json_replay['battleType'] == 13: player_names.append((player_name, self.clan_war_value)) else: player_names.append((player_name, 1)) queue.put(player_names) def open_config_window(self): config_window = Toplevel(self) config_window.iconbitmap(r'data\app.ico') config_window.minsize(500, 350) config_frame = Labelframe(config_window) config_frame.config(text="App Configuration", relief='groove', borderwidth=5) config_frame.pack(expand=1, fill='both', padx=5, pady=5) offset_title = Label(config_frame) offset_title.config(text='Numbering offset (Default 0)') offset_title.pack(anchor='nw', padx=5, pady=5) offset_entry = Entry(config_frame) offset_entry.config( width=10, exportselection=0, validate='key', validatecommand=(offset_entry.register(validate_config_entry), '%P')) offset_entry.pack(anchor='nw', padx=5, pady=5) battle_value_frame = Labelframe(config_frame) battle_value_frame.config(text='Battle weighting', relief='groove', borderwidth=5) battle_value_frame.pack(anchor='nw', fill='both', expand=1, padx=5, pady=5) descriptor_frame = Frame(battle_value_frame) descriptor_frame.pack(side='left', fill='both', expand=1) entry_frame = Frame(battle_value_frame) entry_frame.pack(side='left', fill='both', expand=1) skirmish_title = Label(descriptor_frame) skirmish_title.config(text='Skirmish weighting (Default = 1):') skirmish_title.pack(anchor='nw', padx=5, pady=7) skirmish_entry = Entry(entry_frame) skirmish_entry.config( width=10, exportselection=0, validate='key', validatecommand=(skirmish_entry.register(validate_config_entry), '%P')) skirmish_entry.pack(anchor='nw', padx=5, pady=5) advance_title = Label(descriptor_frame) advance_title.config(text='Advance weighting (Default = 1):') advance_title.pack(anchor='nw', padx=5, pady=10) advance_entry = Entry(entry_frame) advance_entry.config( width=10, exportselection=0, validate='key', validatecommand=(advance_entry.register(validate_config_entry), '%P')) advance_entry.pack(anchor='nw', padx=5, pady=5) clan_war_title = Label(descriptor_frame) clan_war_title.config(text='Clan War weighting (Default = 3):') clan_war_title.pack(anchor='nw', padx=5, pady=6) clan_war_entry = Entry(entry_frame) clan_war_entry.config( width=10, exportselection=0, validate='key', validatecommand=(clan_war_entry.register(validate_config_entry), '%P')) clan_war_entry.pack(anchor='nw', padx=5, pady=5) buttons_frame = Frame(config_frame) buttons_frame.pack(anchor='sw', fill='both', expand=0) apply_button = Button(buttons_frame) apply_button.config(text='Apply', command=partial(self.config_apply, offset_entry, skirmish_entry, advance_entry, clan_war_entry)) apply_button.pack(side='right', padx=5, pady=5) cancel_button = Button(buttons_frame) cancel_button.config(text='Cancel', command=lambda: config_window.destroy()) cancel_button.pack(side='right', padx=5, pady=5) ok_button = Button(buttons_frame) ok_button.config(text='OK', style='OK.TButton', command=partial(self.config_ok, offset_entry, skirmish_entry, advance_entry, clan_war_entry, config_window)) ok_button.pack(side='right', padx=5, pady=5) offset_entry.insert('end', self.offset) skirmish_entry.insert('end', self.skirmish_value) advance_entry.insert('end', self.advance_value) clan_war_entry.insert('end', self.clan_war_value) def config_ok(self, offset, skirmish, advance, clan_war, window): self.offset = int(offset.get()) self.skirmish_value = int(skirmish.get()) self.advance_value = int(advance.get()) self.clan_war_value = int(clan_war.get()) data = { 'offset': offset.get(), 'skirmish_value': skirmish.get(), 'advance_value': advance.get(), 'clan_war_value': clan_war.get() } if path.isfile(r'config.json'): f = open(r'config.json', 'w') else: f = open(r'config.json', 'x') f.seek(0) f.write(dumps(data)) window.destroy() def config_apply(self, offset, skirmish, advance, clan_war): self.offset = int(offset.get()) self.skirmish_value = int(skirmish.get()) self.advance_value = int(advance.get()) self.clan_war_value = int(clan_war.get()) data = { 'offset': offset.get(), 'skirmish_value': skirmish.get(), 'advance_value': advance.get(), 'clan_war_value': clan_war.get() } if path.isfile(r'config.json'): f = open(r'config.json', 'w') else: f = open(r'config.json', 'x') f.seek(0) f.write(dumps(data)) def load_config(self): if path.isfile(r'config.json'): f = open(r'config.json', 'r') data = loads(f.read()) print(data) self.offset = int(data['offset']) self.skirmish_value = int(data['skirmish_value']) self.advance_value = int(data['advance_value']) self.clan_war_value = int(data['clan_war_value']) else: pass
class FrameDownload(Frame): def __init__(self, master=None, option=()): super().__init__(master=master) self.master = master self.master.title('Download information') self.option = option self.setupUI() def setupUI(self): # build UI base on URLS if self.option[2] == SEARCH: # title window label_title = Label(self, text='Search Photos') label_title.config(anchor='center', foreground='white', background='#8e44ad') label_title.grid(row=0, column=0, columnspan=6, sticky='we') # progress self.progress = Progressbar(self) self.progress.config(orient='horizontal', length=100, mode='determinate') self.progress.grid(row=2, column=0, columnspan=5, sticky='we') self.var_progress = StringVar() self.var_progress.set('0%') self.label_show_progress = Label(self) self.label_show_progress.config(textvariable=self.var_progress, anchor='center') self.label_show_progress.var = self.var_progress self.label_show_progress.grid(row=2, column=5, sticky='w') # query self.label_query = Label(self, text='Query') self.label_query.grid(row=1, column=0, sticky='e') self.var_entry_query = StringVar() self.entry_query = Entry(self) self.entry_query.config(textvariable=self.var_entry_query, state='readonly') self.entry_query.grid(row=1, column=1, sticky='w') # total self.var_total = StringVar() self.var_total.set('Total') self.label_total = Label(self, textvariable=self.var_total) self.label_total.grid(row=1, column=2, sticky='e') self.var_entry_total = IntVar() self.entry_total = Entry(self) self.entry_total.config(textvariable=self.var_entry_total, state='readonly') self.entry_total.grid(row=1, column=3, sticky='w') # total pages self.label_total_page = Label(self, text='Total pages:') self.label_total_page.grid(row=1, column=4, sticky='e') self.var_entry_total_pages = IntVar() self.entry_total_page = Entry(self) self.entry_total_page.config(textvariable=self.var_entry_total_pages, state='readonly') self.entry_total_page.grid(row=1, column=5, sticky='w') # show image is downloaded self.label_image_downloaded = Label(self, anchor='center') self.label_image_downloaded.grid(row=3, column=0, columnspan=6, sticky='wesn') # self.change_ui() elif self.option[2] == LIST: # title window label_title = Label(self, text='List of Photos') label_title.config( anchor='center', foreground='white', background='#2c3e50') label_title.grid(row=0, column=0, columnspan=4, sticky='we') # progress self.progress = Progressbar(self) self.progress.config(orient='horizontal', length=100, mode='determinate') self.progress.grid(row=2, column=0, columnspan=3, sticky='we') self.var_progress = StringVar() self.var_progress.set('0%') self.label_show_progress = Label(self) self.label_show_progress.config( textvariable=self.var_progress, anchor='center') self.label_show_progress.var = self.var_progress self.label_show_progress.grid(row=2, column=3, sticky='w') # query self.label_query = Label(self, text='Query:') self.label_query.grid(row=1, column=0, sticky='e') self.entry_query = Entry(self) self.entry_query.insert(0,'LIST') self.entry_query.config(state='readonly') self.entry_query.grid(row=1, column=1, sticky='w') # amount self.label_total = Label(self, text='Amount:') self.label_total.grid(row=1, column=2, sticky='e') self.entry_total = Entry(self) self.entry_total.insert(0,self.option[3]['per_page']) self.entry_total.config(state='readonly') self.entry_total.grid(row=1, column=3, sticky='w') # show image is downloaded self.label_image_downloaded = Label(self, anchor='center') self.label_image_downloaded.grid( row=3, column=0, columnspan=4, sticky='wesn') # self.change_ui() elif self.option[2] == RANDOM: # title window label_title = Label(self, text='Random Photos') label_title.config( anchor='center', foreground='white', background='#16a085') label_title.grid(row=0, column=0, columnspan=4, sticky='we') # progress self.progress = Progressbar(self) self.progress.config(orient='horizontal', length=100, mode='determinate') self.progress.grid(row=2, column=0, columnspan=3, sticky='we') self.var_progress = StringVar() self.var_progress.set('0%') self.label_show_progress = Label(self) self.label_show_progress.config( textvariable=self.var_progress, anchor='center') self.label_show_progress.var = self.var_progress self.label_show_progress.grid(row=2, column=3, sticky='w') # query self.label_query = Label(self, text='Query') self.label_query.grid(row=1, column=0, sticky='e') self.entry_query = Entry(self) self.entry_query.insert(0,'RANDOM') self.entry_query.config(state='readonly') self.entry_query.grid(row=1, column=1, sticky='w') # amount self.label_total = Label(self, text='Amount') self.label_total.grid(row=1, column=2, sticky='e') self.var_entry_total = IntVar() if self.option[3]['count'] > 30: self.var_entry_total.set(30) else: self.var_entry_total.set(self.option[3]['count']) self.entry_total = Entry(self) self.entry_total.config(textvariable=self.var_entry_total, state='readonly') self.entry_total.grid(row=1, column=3, sticky='w') # show image is downloaded self.label_image_downloaded = Label(self, anchor='center') self.label_image_downloaded.grid( row=3, column=0, columnspan=4, sticky='wesn') def change_ui(self): if self.option[2] == SEARCH: r = requests.get(self.option[2], params=self.option[3]) if r.status_code == 200: # get urls based on quality j = json.loads(r.text) total = j['total'] total_pages = j['total_pages'] results = j['results'] self.var_entry_query.set(self.option[3]['query']) self.var_entry_total.set(total) self.var_entry_total_pages.set(total_pages) self.entry_query.update_idletasks() self.entry_total.update_idletasks() self.entry_total_page.update_idletasks() # random photos elif self.option[2] == RANDOM: r = requests.get(self.option[2], params=self.option[3]) if r.status_code == 200: # get result j = json.loads(r.text) results = j elif self.option[2] == LIST: r = requests.get(self.option[2], params=self.option[3]) if r.status_code == 200: # get result j = json.loads(r.text) results = j self.download(results) def download(self, results): for i in results: name = i['id'] url = i['urls'][self.option[1]] time.sleep(1) # delay time to send request try: request.urlretrieve(url, self.option[0]+'/'+name+'.jpg') except Exception as x: # re download if have a problem print('have problem', x) time.sleep(1) self.progress['value'] += 100/len(results) self.var_progress.set('{}%'.format(self.progress['value'])) # show image downloaded image = Image.open(self.option[0]+'/'+name+'.jpg') width = int(self.winfo_width()) height = int(width*image.height/image.width) self.photo = ImageTk.PhotoImage( image.resize((width, height), Image.ANTIALIAS)) self.label_image_downloaded.config(image=self.photo) self.label_image_downloaded.image = self.photo self.progress.update_idletasks() self.message_done = messagebox.showinfo('Info', 'Done') self.master.destroy()
class OptimizeGroup(Group): def __init__(self, *args, **kwargs): self._app = kwargs.pop('wavesyn_root') self.__topwin = kwargs.pop('topwin') super().__init__(*args, **kwargs) parameter_frame = Frame(self) parameter_frame.pack(side='left', expand='yes', fill='y') self.__num = LabeledEntry(parameter_frame) set_attributes(self.__num, label_text='num', entry_text='1', label_width=5, entry_width=8, checker_function=self._app.gui.value_checker.check_int) self.__num.entry.bind('<Return>', lambda event: self._on_solve_click()) self.__num.pack(side='top') self.__pci = LabeledEntry(parameter_frame) set_attributes(self.__pci, label_text='PCI', entry_text='100', label_width=5, entry_width=8, checker_function=self._app.gui.value_checker.check_int) self.__pci.pack(side='top') self.__parallel_checker_variable = IntVar() self.__parallel_checker = Checkbutton( parameter_frame, text="Parallel", variable=self.__parallel_checker_variable, command=self._on_parallel_checker_click) self.__parallel_checker.pack() progfrm = Frame(self) progfrm.pack(side='left', expand='yes', fill='y') self.__genbtn = Button(progfrm, text='Generate', command=self._on_solve_click) self.__genbtn.pack(side='top') Button(progfrm, text='Stop', command=self._on_stop_button_click).pack(side='top') self.__progressbar_variable = IntVar() self.__finishedwav = IntVar() self.__progressbar = Progressbar(progfrm, orient='horizontal', variable=self.__progressbar_variable, maximum=100) self.__progressbar.pack(side='left') self.__progressbar.config(length=55) self.__finishedwavbar = Progressbar(progfrm, orient='horizontal', variable=self.__finishedwav) self.__finishedwavbar.pack(side='left') self.__finishedwavbar.config(length=30) self.name = 'Generate' self.getparams = None self.__stopflag = False def _on_solve_click(self): params = self.__topwin.parameter_group.get_parameters() repeat_times = self.__num.get_int() if self.__parallel_checker_variable.get(): run = self.__topwin.current_algorithm.process_run else: run = self.__topwin.current_algorithm.thread_run with code_printer(): run(on_finished=['store', 'draw'], progress_indicator='progress_dialog', repeat_times=repeat_times, **params) def _on_stop_button_click(self): self.__stopflag = True def _on_parallel_checker_click(self): topwin = self.__topwin if topwin.current_algorithm.need_cuda: self.__parallel_checker_variable.set(0) topwin.root_node.gui.dialogs.report(f'''{topwin.node_path}: Current algorithm "{topwin.current_algorithm.meta.name}" need CUDA worker, which does not support multi-cpu parallel. ''') def _cancel_parallel(self): self.__parallel_checker_variable.set(0)
class InpaintApp(Frame): def __init__(self): super().__init__() self.initInpaintUI() def initInpaintUI(self): self.master.title("Fill Your Face") self.pack(fill=BOTH, expand=True) self.columnconfigure(1, weight=1) self.columnconfigure(4, pad=2) self.rowconfigure(4, weight=1) self.rowconfigure(5, pad=2) lbl = Label(self, text="Please select a mask type & face to fill.") lbl.grid(sticky=W, pady=4, padx=5) wbtn = Button(self, text="Choose Folder", command=self.saveLoc) wbtn.place(x=10, y=30) # variables self.save_loc = None self.chosen_img = None self.completed_img = None self.msk = None self.lr = config.learning_rate self.moment = config.momentum self.nitrs = config.niters self.l2loss = False self.saveEaItr = False # saves images after ea iteration to visualize manifold self.weighted_mask = config.weighted_mask self.show_mskedim = False self.saveMask = IntVar() # checkboxes whether to save as image self.saveMaskedIm = IntVar() # buttons right abtn = Button(self, text="Select Image", command=self.openImg) abtn.grid(row=2, column=4, padx=5, pady=5) abtn = Button(self, text="Random Image", command=self.getRandImg) abtn.grid(row=1, column=4, padx=5, pady=5) # choose mask choices = {'Center', 'Random', 'Half'} self.mask_type = StringVar(root) self.mask_type.set("Select Mask Type") popupMenu = OptionMenu(self, self.mask_type, *choices, command=self.display_mask) popupMenu.grid(row=1, column=3, padx=5) dmbtn = Button(self, text="Display Masked Image", command=self.display_masked_img) dmbtn.grid(row=2, column=3, padx=5) # buttons lower hbtn = Button(self, text="Help", command=self.clickHelp) hbtn.grid(row=5, column=0, padx=5, pady=5) wbtn = Button(self, text="Settings", command=self.setParams) wbtn.grid(row=5, column=1) Button(self, text="Save Image(s)", command=self.saveImg).grid(row=5, column=2, padx=5, pady=5) obtn = Button(self, text="Start Inpaint", command=self.start_inpaint) obtn.grid(row=5, column=3, padx=5, pady=5) cbtn = Button(self, text="Quit", command=self.ExitApplication) cbtn.grid(row=5, column=4, padx=5, pady=5) # progress bar Label(self, text="Inpainting Progress:").place(x=40, y=260) self.progressbar = Progressbar(self, length=500) # self.progressbar.config(mode = 'determinate', maximum=self.nitrs) self.progressbar.place(x=40, y=280) def ExitApplication(self): MsgBox = messagebox.askquestion( 'Exit Application', 'Are you sure you want to exit the application', icon='warning') if MsgBox == 'yes': root.destroy() def openImg(self): filename = filedialog.askopenfilename( ) # show an "Open" dialog box and return the path to the selected file if filename[-4:] == '.png' or filename[-4:] == 'jpeg' or filename[ -4:] == '.jpg': img = Image.open(filename) self.blend_tar = np.asarray(img) # for poisson blending later self.blend_tar.flags.writeable = True if img.size != (64, 64): messagebox.showwarning( "Error", "Please choose a 64x64 rgb face image.\ \n You can use openface to crop your image. Click Help for more info." ) return self.chosen_img = np.asarray(img, dtype="float32") img = img.resize((100, 100), Image.ANTIALIAS) imgtk = ImageTk.PhotoImage(img) txt_lbl = Label(self, text="Your Image") txt_lbl.place(x=50, y=110) dis_img = Label(self, image=imgtk) dis_img.image = imgtk dis_img.place(x=50, y=127) else: messagebox.showwarning("Error", "Please select a png or jpeg image") def getRandImg(self): dataset = tf.data.TFRecordDataset(filenames="data.tfrecord") dataset = dataset.map(func.extract_fn) # dataset = tf.data.TFRecordDataset.from_tensor_slices(dataset) dataset = dataset.shuffle(buffer_size=300) dataset = dataset.batch(1) iterator = tf.data.Iterator.from_structure(dataset.output_types, dataset.output_shapes) init_op = iterator.make_initializer(dataset) # batched data to feed in image_data = iterator.get_next() # visualize original data with tf.Session() as sess: sess.run(init_op) real_img = np.array(sess.run(image_data)) rand_img = real_img[0, :, :, :] self.chosen_img = np.asarray(rand_img, dtype="float32") img = toimage(rand_img) self.blend_tar = np.asarray(img) # for poisson blending later self.blend_tar.flags.writeable = True img = img.resize((100, 100), Image.ANTIALIAS) imgtk = ImageTk.PhotoImage(img) txt_lbl = Label(self, text="Your Image") txt_lbl.place(x=50, y=110) dis_img = Label(self, image=imgtk) dis_img.image = imgtk dis_img.place(x=50, y=127) def saveLoc(self): self.save_loc = filedialog.askdirectory() self.dis_save = Label(self, text='Save Location: ') self.dis_save.place(x=10, y=60) slength = len(self.save_loc) if slength > 40: self.dis_save['text'] += "..." self.dis_save['text'] += self.save_loc[-40:] else: self.dis_save['text'] += self.save_loc def saveImg(self): if self.completed_img is not None: im = toimage(self.completed_img) im = im.resize((250, 250), Image.ANTIALIAS) if self.save_loc is not None: # file = filedialog.asksaveasfile(mode='w', defaultextension=".jpg") uniq_filename = 'CompletedImg_' + str( datetime.datetime.now().time()).replace(':', '.') filename = self.save_loc + '/' + uniq_filename + '.jpg' imageio.imwrite(filename, im) if self.saveMask.get(): uniq_filename = 'Mask_' + str( datetime.datetime.now().time()).replace(':', '.') filename = self.save_loc + '/' + uniq_filename + '.jpg' mskimg = toimage(self.msk) mskimg = mskimg.resize((250, 250), Image.ANTIALIAS) imageio.imwrite(filename, mskimg) if self.saveMaskedIm.get(): uniq_filename = 'MaskedImg_' + str( datetime.datetime.now().time()).replace(':', '.') filename = self.save_loc + '/' + uniq_filename + '.jpg' masked_img = preinpaint.get_masked_image( self.msk, self.chosen_img) masked_img = toimage(masked_img) masked_img = masked_img.resize((250, 250), Image.ANTIALIAS) imageio.imwrite(filename, masked_img) messagebox.showinfo("Success!", "Your image has been saved") else: messagebox.showwarning("Error", "Please choose folder to save image.") else: messagebox.showwarning("Error", "Please inpaint first to get image.") def display_mask(self, mask_type): if mask_type != "Select Mask Type": self.msk = preinpaint.make_mask(mask_type, weighted_mask=self.weighted_mask) # mskimg = Image.fromarray(msk, 'RGB') # dispmsk = preinpaint.make_mask(mask_type, weighted_mask=False) mskimg = toimage(self.msk) mskimg = mskimg.resize((100, 100), Image.ANTIALIAS) imgtk = ImageTk.PhotoImage(mskimg) txt_lbl = Label(self, text="Your Mask: ") txt_lbl.place(x=200, y=110) dis_img = Label(self, image=imgtk) dis_img.image = imgtk dis_img.place(x=200, y=127) else: messagebox.showwarning("Error", "Please select a mask first!") def display_masked_img(self): if self.chosen_img is not None and self.msk is not None: masked_img = preinpaint.get_masked_image(self.msk, self.chosen_img) masked_img = toimage(masked_img) masked_img = masked_img.resize((100, 100), Image.ANTIALIAS) imgtk = ImageTk.PhotoImage(masked_img) txt_lbl = Label(self, text="Masked Image: ") txt_lbl.place(x=350, y=110) dis_img = Label(self, image=imgtk) dis_img.image = imgtk dis_img.place(x=350, y=127) self.show_mskedim = True else: messagebox.showwarning("Error", "Please load image and mask") def start_inpaint(self): l2 = self.l2loss savegenerated = self.saveEaItr if self.chosen_img is not None and self.msk is not None: self.progressbar['value'] = 0 self.progressbar.update_idletasks() img = preinpaint.preprocess(self.chosen_img) # print(img.dtype, np.amax(img), np.amin(img)) # debugging images = preinpaint.single_to_batch(img) masks = preinpaint.single_to_batch(self.msk) # gen_images, loss = inpaint.get_best_z_img(masks, images, iters=self.nitrs) # backprop to z z = np.random.randn(config.BATCH_SIZE, config.z_dim) vel = 0 iters = self.nitrs r = self.lr momentum = self.moment self.progressbar.config(mode='determinate', maximum=self.nitrs) # load frozen graph graph, graph_def = func.loadpb("dcgan-100.pb") g_in = graph.get_tensor_by_name('dcgan/z:0') g_out = graph.get_tensor_by_name('dcgan/Tanh:0') g_loss = graph.get_tensor_by_name('dcgan/Mean_2:0') d_in = graph.get_tensor_by_name('dcgan/real_images:0') d_out = graph.get_tensor_by_name('dcgan/Sigmoid:0') with tf.Session(graph=graph) as sess: # create batches of masks & images to feed in mask_placeholder = tf.placeholder( tf.float32, shape=(config.BATCH_SIZE, config.image_size, config.image_size, config.channels)) # real image batches, use if own image input images_placeholder = tf.placeholder( tf.float32, shape=(config.BATCH_SIZE, config.image_size, config.image_size, config.channels)) inpaint_loss, gradient = inpaint.get_losses( mask_placeholder, images_placeholder, g_in, g_out, g_loss, l2) bests = [] for i in range(iters): # yield Label(self, text="Inpainting Progress:" + str(i)).place(x=40, y=280) feed_dict = { mask_placeholder: masks, images_placeholder: images, g_in: z } loss, grad, gen_images = sess.run( (inpaint_loss, gradient, g_out), feed_dict=feed_dict) grad = grad[0] v_prev = vel vel = v_prev * momentum - r * grad # z += vel z += vel * ( 1 + momentum) - v_prev * momentum # dampening momentum z = np.clip(z, -1, 1) # debugging -- save best gen img of ea. iteration if savegenerated: best = inpaint.get_best_generated(gen_images, loss) bests.append(best) for b in bests: im = toimage(b) im.save("generated/z_" + str(i) + ".jpg") self.progressbar['value'] = i + 1 self.progressbar.update_idletasks() best_image = inpaint.get_best_generated(gen_images, loss) # poisson blending blend_src = np.asarray(toimage(best_image)) mask = preinpaint.bin_inv_mask(self.msk) mask = np.asarray(toimage(mask)) self.completed_img = postinpaint.blend(self.blend_tar, blend_src, mask) # print(self.blend_tar.shape, blend_src.shape, mask.shape) # self.completed_img = inpaint.inpaint(img, best_image, self.msk) disp_img = toimage(self.completed_img) disp_img = disp_img.resize((128, 128), Image.ANTIALIAS) imgtk = ImageTk.PhotoImage(disp_img) txt_lbl = Label(self, text="Completed Image: ") txt_lbl.place(x=250, y=330) dis_img = Label(self, image=imgtk) dis_img.image = imgtk dis_img.place(x=250, y=347) def clickHelp(self): toplevel = Toplevel(root) toplevel.title("Help") with open("files/about.txt", "r") as f: Label(toplevel, text=f.read(), height=20, width=100).pack() def closetl(): toplevel.destroy() Button(toplevel, text="Close", command=closetl).pack() def setParams(self): tl = Toplevel(root) tl.title("Set Parameters") Label(tl, text="Iterations: ").grid(row=0, column=0, sticky=W, padx=5, pady=3) self.iters = Entry(tl, width=10) self.iters.grid(row=0, column=1, padx=5, pady=3) Label(tl, text="Use weighted mask?: ").grid(row=1, column=0, padx=5, pady=3) self.maskedbool = BooleanVar() Radiobutton(tl, text="Yes", variable=self.maskedbool, value=True).grid(row=1, column=1) Radiobutton(tl, text="No", variable=self.maskedbool, value=False).grid(row=1, column=2) # Checkbutton(tl, text="Use weighted mask?", variable=self.maskedbool).grid(row=1, column=3) ch1 = Checkbutton(tl, text="Save mask?", variable=self.saveMask) ch1.grid(row=2, column=0, padx=5, pady=7) ch2 = Checkbutton(tl, text="Save masked image?", variable=self.saveMaskedIm) ch2.grid(row=2, column=1, padx=5, pady=7) def closetl(): tl.destroy() def changeParams(): try: if int(self.iters.get()) > 0: self.nitrs = int(self.iters.get()) else: messagebox.showwarning("Error", "You need at least 1 iteration.") self.weighted_mask = self.maskedbool.get() if self.mask_type.get() != "Select Mask Type": self.display_mask(self.mask_type.get()) if self.show_mskedim: self.display_masked_img() tl.destroy() except ValueError: self.weighted_mask = self.maskedbool.get() if self.mask_type.get() != "Select Mask Type": self.display_mask(self.mask_type.get()) tl.destroy() Button(tl, text="Ok", command=changeParams).grid(row=3, column=2, padx=5, pady=3) Button(tl, text="Cancel", command=closetl).grid(row=3, column=3, padx=5, pady=3)
def addDownloadItem(url): if url != None: req = requests.get(url, stream=True) if "Content-Length" in req.headers: total_size = req.headers['Content-Length'] else: total_size = None if "Content-Disposition" in req.headers.keys(): fname = re.findall("filename=(.+)", req.headers["Content-Disposition"])[0] else: fname = url.split("/")[-1] fname.replace(" ", "") frame2 = Frame(frame, bg="#E67E22") img = Image.open("file_icon.png") render = ImageTk.PhotoImage(img) label = Label(frame2, image=render, bg="#E67E22") label.image = render label.grid(row=0, column=0, rowspan=2) title = Label(frame2, text=fname, padx=5, bg="#E67E22", fg="white", anchor="w") title.config(font=("Arial", "15")) title.grid(row=0, column=1, sticky="nsew") progress = Progressbar(frame2) progress['value'] = 0 progress.grid(row=1, column=1, sticky="nsew") labelPercentage = Label(frame2, text="0 %", padx="5", anchor="w", bg="#E67E22", fg="white") labelPercentage.grid(row=0, column=2) labelsize = Label(frame2, text="0 KB", padx="5", anchor="w", bg="#E67E22", fg="white") labelsize.grid(row=1, column=2) frame2.pack(fill="x") frame2.columnconfigure(1, weight=1) with open(fname, "wb") as fileobj: for chunk in req.iter_content(chunk_size=1024): if chunk: fileobj.write(chunk) current_size = os.path.getsize(fname) labelsize.config(text=str(getStandardSize(current_size))) if total_size != None: percentg = round( (int(current_size) / int(total_size)) * 100) labelPercentage.config(text=str(percentg) + " %") progress['value'] = percentg else: percentg = "Infinte" progress.config(mode="indeterminate") progress.start() labelPercentage.config(text=str(percentg) + " %") if total_size != None: current_size = os.path.getsize(fname) labelsize.config(text=str(getStandardSize(current_size))) labelPercentage.config(text=str(percentg) + " %") percentg = round((int(current_size) / int(total_size)) * 100) progress['value'] = percentg else: current_size = os.path.getsize(fname) labelsize.config(text=str(getStandardSize(current_size))) labelPercentage.config(text="100 %") progress['value'] = 100