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
