class UndoButton(Observer):
'''Represent the 'undo' button in the Senku GUI.'''
def __init__(self, game, parent):
'''Constructor of UndoButton. Receive the game and the
parent widget (frame, in this case).'''
Observer.__init__(self)
self._game = game
self._game.add_observer(self, 'UNDO_STACK')
self._button = Button(parent, text='Deshacer', command=self.undo)
self._button.grid(row=1, column=1)
def update(self, aspect, value):
'''The aspect is always UNDO_STACK. If there's no undo
actions, the button will be disabled.'''
if value.is_empty():
self._button.config(state=DISABLED)
else:
self._button.config(state=NORMAL)
def undo(self):
'''Tell the model to perform the undo action, if it's possible.'''
self._game.undo()
class ConfigWindow(Toplevel):
'''Represent the configuration window.'''
def __init__(self, parent=None):
'''Constructor of ConfigWindow.'''
Toplevel.__init__(self, parent)
self.title('Configuracion')
self._states = [IntVar(value=CONFIG['GAME_TRACKING']),
IntVar(value=CONFIG['CONFIRM_EXIT'])]
self._cbox_gtrack = Checkbutton(self, text='Seguimiento del juego')
self._cbox_gtrack.config(variable=self._states[0])
self._cbox_confexit = Checkbutton(self, text='Confirmacion al salir')
self._cbox_confexit.config(variable=self._states[1])
self._cbox_gtrack.grid(row=0, column=0, sticky=W)
self._cbox_confexit.grid(row=1, column=0, sticky=W)
self._button_cancel = Button(self, text='Cancelar', command=self.destroy)
self._button_cancel.grid(row=3, column=1, sticky=E)
self._button_accept = Button(self, text='Guardar y Salir')
self._button_accept.config(command=self.save_config)
self._button_accept.grid(row=3, column=0, sticky=E)
def save_config(self):
pass
def get_state_game_tracking(self):
return self._states[0].get()
def get_state_confirm_exit(self):
return self._states[1].get()
class GuiBasicSettings(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.pack()
#Unit
self.sizeUnits = {"Byte": 1, "KiB":1024, "MiB":1024**2, "GiB":1024**3}
self._initFile()
self._initSize()
def _initFile(self):
self._fileLbl = Label(self, text="File: ")
self._fileTxt = Entry(self)
self._fileTxt.insert(0, "/tmp/out.txt")
self._fileBtn = Button(self, text="Create", command=self._callbackFun)
self._fileLbl.grid(row=0, column=0)
self._fileTxt.grid(row=0, column=1)
self._fileBtn.grid(row=0, column=2)
def _initSize(self):
self._sizeLbl = Label(self, text="FileSize: ")
self._sizeTxt = Entry(self)
self._sizeTxt.insert(0, "1024")
self._sizeVar = StringVar()
self._sizeVar.set("Byte") #FIXME: replace "Byte" with variable
sizeOptParam = (self, self._sizeVar) + tuple(self.sizeUnits.keys())
self._sizeOptMen = OptionMenu(*sizeOptParam)
self._sizeLbl.grid(row=1, column=0)
self._sizeTxt.grid(row=1, column=1)
self._sizeOptMen.grid(row=1, column=2)
def _callbackFun(self):
print("_callbackBtn")
self.outerCallback()
def enableButton(self, enabled=True):
if enabled:
self._fileBtn.config(state="normal")
else:
self._fileBtn.config(state="disabled")
def getFileName(self):
return self._fileTxt.get()
def getFileSize(self):
mult = int(self.sizeUnits[self._sizeVar.get()])
val = int(self._sizeTxt.get())
return val * mult
def setCallback(self, aCallback):
self.outerCallback = aCallback
class Dashboard:
#顯示儀表板
def showup(self):
self.psr = Processor()
self.root = Tk()
self.root.title("MOPS資訊觀測站")
frame = Frame(self.root)
frame.grid(row=0, column=0, sticky="news")
self.stateV = StringVar()
self.stateV.set("日期格式：yyyymmdd")
self.statebarL = Label(frame, textvariable=self.stateV)
sdateL = Label(frame, text="開始日期")
edateL = Label(frame, text="迄止日期")
self.sdateE = Entry(frame)
self.edateE = Entry(frame)
self.goBtn = Button(frame, text="確定", command=self.runProcess)
self.statebarL.grid(row=0, column=0, rowspan=1, columnspan=3, sticky="news")
sdateL.grid(row=1, column=0, rowspan=1, columnspan=1, sticky="news")
edateL.grid(row=2, column=0, rowspan=1, columnspan=1, sticky="news")
self.sdateE.grid(row=1, column=1, rowspan=1, columnspan=1, sticky="news")
self.edateE.grid(row=2, column=1, rowspan=1, columnspan=1, sticky="news")
self.goBtn.grid(row=1, column=2, rowspan=2, columnspan=1, sticky="news")
Grid.grid_rowconfigure(self.root, 0, weight=1)
Grid.grid_columnconfigure(self.root, 0, weight=1)
self.root.mainloop()
#確定開始執行抓取資料
def runProcess(self):
self.goBtn.config(state="disabled")
try:
sdate = self.sdateE.get()
edate = self.edateE.get()
datetime.strptime(sdate, "%Y%m%d")
datetime.strptime(edate, "%Y%m%d")
except ValueError:
self.stateV.set("日期格式錯誤，正確為：yyyymmdd")
return None
print("from " + sdate + " to " + edate)
self.psr.setDateRange(sdate, edate)
self.psr.registerProgressObserver(self) #observer 需實作 updateProgress
t = Timer(0, self.psr.runProcess) #啟動另一個 thread 執行，畫面才不會「沒有回應」
t.start()
#進度更新
def updateProgress(self, progress):
self.stateV.set("進度：" + str(progress) + "%")
if progress == 100:
self.goBtn.config(state="normal")
self.stateV.set("已完成。重新輸入日期：yyyymmdd")
def list_entries(self, Medikom, results, entry_type):
if entry_type == 0: # tasks (left column)
x = self.SPACE_TWO
else: # information (right column)
x = self.WIN_WIDTH / 2 + (.25 * self.SPACE_ONE)
for i, (id, ts, title) in enumerate(results):
ts = self.format_ts(ts)
task_button = Button(
self, text=ts + title, font='Courier 10', anchor='w',
command=Callable(self.view_details, Medikom, id))
task_button.place(
x=x, y=(i + 1) * (self.ROW_HIGHT + self.ROW_SPACE),
width=(self.WIN_WIDTH / 2) - (1.25 * self.SPACE_ONE),
height=self.ROW_HIGHT)
rm_task_button = Button(
self, text='√',
command=Callable(self.rm_entry, Medikom, id, title))
rm_task_button.place(
x=x + (self.WIN_WIDTH / 2) - (1.25 * self.SPACE_ONE),
y=(i + 1) * (self.ROW_HIGHT + self.ROW_SPACE),
width=self.SPACE_TWO, height=self.ROW_HIGHT)
# highlight selected entries and those with priority
if self.selected_id and (id == self.selected_id):
task_button.config(bg='lightblue')
rm_task_button.config(bg='lightblue')
if title.startswith('!'):
task_button.config(bg='IndianRed2')
rm_task_button.config(bg='IndianRed2')
def main():
root = Tk()
a = Alarm(root)
a.pack(side="bottom")
textbox = Entry(root)
textbox.pack(side="left")
start = Button(root, text="Start",command= lambda: a.startTimer(int(textbox.get()), start, stop, textbox))
start.pack(side="left")
stop = Button(root, text="Stop",command= lambda: a.stop(start,stop))
stop.config(state="disabled")
stop.pack(side="left")
reset = Button(root, text="Reset", command= lambda: a.reset(start,stop,textbox))
reset.pack(side="left")
root.mainloop()
def __init__(self, game):
'''Constructor of UISenku. Build the main window and the
main frame.'''
Observer.__init__(self)
self._game = game
self._root = Tk()
self._root.title('PySenku')
main_frame = Frame(self._root, width=280, height=330, bd=1)
BoardArea(self._game, main_frame)
start_button = Button(main_frame)
start_button.config(text='Nuevo', command=self.start)
start_button.grid(row=1, column=0)
help_button = Button(main_frame)
help_button.config(text='Mas info...', command=self.open_help)
help_button.grid(row=1, column=2)
UndoButton(self._game, main_frame)
main_frame.pack()
self._game.add_observer(self, 'GAME_OVER')
self._root.protocol("WM_DELETE_WINDOW", self.quit)
def initButtons(self, ios, commands):
for command in ios:
cmdInstance = command()
cmdButton = Button(self.topToolbar, image=self.res.get(command.get_id()), relief=GROOVE)
cmdHandler = partial(self.onIOCommandClick, cmdButton, cmdInstance)
cmdButton.config(command=cmdHandler)
cmdButton.pack(side=LEFT, padx=2, pady=2)
self.ioButtons.append(cmdButton)
print("Added draw command: {} ({})".format(cmdInstance.get_name(), cmdInstance.get_description()))
self.commandButtons = []
for command in commands:
cmdButton = Button(self.topToolbar, image=self.res.get(command.get_id()), relief=FLAT)
cmdHandler = partial(self.onDrawCommandButtonClick, cmdButton, command)
cmdButton.config(command=cmdHandler)
cmdButton.pack(side=LEFT, padx=2, pady=2)
self.commandButtons.append(cmdButton)
print("Added IO command: {} ({})".format(command.get_name(), command.get_description()))
cmdColorPicker = Button(self.topToolbar, relief=RIDGE)
cmdHandler = partial(self.onChangeColor, cmdColorPicker)
cmdColorPicker.config(command=cmdHandler, background=self.colorPicker.getColor(), relief=GROOVE, width=2,
highlightbackground='white')
cmdColorPicker.pack(side=LEFT, padx=15, pady=2)
self.colorPickerButton = cmdColorPicker
class Amel(LabelFrame):
def __init__(self, boss, nom, amelioration, maximum, prix, up, logo):
"""
amelioration (str) : Nom de l'amélioration du bouton
maximum (int) : Maximum de fois que l'on peut augmenter l'amélioration
prix (int) : Prix de l'amélioration par niveau
up (int) : Montant de point apporté par l'amélioration
"""
global imagesMag
self.amel = amelioration
self.max = maximum
self.prix = prix
self.up = up
LabelFrame.__init__(self, boss)
Label(self, image=imagesMag[logo]).pack(side=LEFT)
Label(self, text=nom, width=18).pack(side=LEFT)
self.button = Button(self, command=self.acheter, width = 6)
self.level = Label(self, width=5)
self.total = Label(self, width=11)
self.total.pack(side=RIGHT)
self.level.pack(side=RIGHT)
self.button.pack(side=RIGHT)
self.maj()
def maj(self):
global amel, stat
self.button.config(text=(str((amel[self.amel]+1)*self.prix) + ' PO'))
self.level.config(text=str(amel[self.amel]) + '/' + str(self.max))
self.total.config(text='Total : ' + str(stat[self.amel]))
def acheter(self):
global stat, OR, amel
if ((OR >= (amel[self.amel]+1)*self.prix) and (amel[self.amel] < self.max)):
OR -= (amel[self.amel]+1)*self.prix #A changer
stat[self.amel] += self.up
amel[self.amel] += 1
self.maj()
__main__.menu.majPerso()
__main__.menu.majOR()
class QCAT_Auto(Frame):
def __init__(self, master=None):
self.cur_dir = os.getcwd()
Frame.__init__(self, master)
self.master = master
window_width = 460
window_heigh = 510
x_pos = (screen_width / 2) - (window_width / 2)
y_pos = (screen_heigh / 2) - (window_heigh / 2)
# self.master.geometry("420x200")
self.master.geometry('%dx%d+%d+%d' %
(window_width, window_heigh, x_pos, y_pos))
self.master.title("QCAT Automation")
######################################################################################################
self.config_file_PATH_label = Label(self.master,
text="4G Config file path")
self.config_file_PATH_label.grid(row=0, column=0, sticky=W, pady=2)
self.config_file_PATH_txt = Text(self.master, heigh=1, width=35)
self.config_file_PATH_txt.grid(row=0, column=1, pady=2)
self.config_file_PATH_label_5g = Label(self.master,
text="5G Config file path")
self.config_file_PATH_label_5g.grid(row=1, column=0, sticky=W, pady=2)
self.config_file_5g_PATH_txt = Text(self.master, heigh=1, width=35)
self.config_file_5g_PATH_txt.grid(row=1, column=1, pady=2)
self.raw_log_file_PATH_label = Label(self.master,
text="Raw Log file path")
self.raw_log_file_PATH_label.grid(row=3, column=0, sticky=W, pady=2)
self.raw_log_file_PATH_txt = Text(self.master, heigh=1, width=35)
self.raw_log_file_PATH_txt.grid(row=3, column=1, pady=2)
# self.qcat_input_label = Label(self.master, text = '')
self.log_type_label = Label(self.master, text="Information")
self.log_type_label.grid(row=3, column=0, sticky=W)
self.log_type_txt = ScrolledText(self.master, undo=True, width=55)
self.log_type_txt.grid(row=4,
rowspan=4,
column=0,
columnspan=3,
sticky=W)
self.QCAT_txt_dir_label = Label(self.master,
text="QCAT Output\nDirectory")
self.QCAT_txt_dir_label.grid(row=9, column=0, sticky=W)
self.QCAT_txt_dir_txt = Text(self.master, heigh=1, width=35)
self.QCAT_txt_dir_txt.grid(row=9,
rowspan=2,
column=0,
columnspan=3,
padx=80,
sticky=W)
######################################################################################################
self.Import_txt_button = Button(self.master,
text='Import to txt',
command=self.call_import_txt)
self.Import_txt_button.grid(row=9,
column=1,
columnspan=3,
sticky=E,
pady=2,
padx=3)
self.Import_txt_button.config(width=10, heigh=2)
self.extract_config_button = Button(self.master,
text="Extract",
state=DISABLED,
command=self.call_extract)
self.extract_config_button.grid(row=0, column=2, sticky=E, padx=4)
# self.view_log_button = Button(self.master, text = "View")
# self.view_log_button.grid(row=1, column=2, sticky=E, padx=4)
###############################################################################
# creating a menu instance
self.menu = Menu(self.master)
self.master.config(menu=self.menu)
# create the file object)
self.file = Menu(self.menu)
# adds a command to the menu option, calling it exit, and the
# command it runs on event is client_exit
# self.file.add_command(label="QCAT Automation", command = self.openQCAT)
self.file.add_command(label="Open 4G Config", command=self.open_config)
self.file.add_command(label="Open 5G Config",
command=self.open_config_5g)
self.file.add_command(label="Open Raw Log", command=self.open_raw_log)
self.file.add_command(label="Set Output Directory",
command=self.set_output_directory)
self.file.add_command(label="Exit", command=self.client_exit)
self.menu.add_cascade(label="File", menu=self.file)
# menu.add_cascade(label="Open config", menu=file)
self.edit = Menu(self.menu)
self.menu.add_cascade(label="Edit", menu=self.edit)
self.help = Menu(self.menu)
self.help.add_command(label="About", command=self.show_about)
self.help.add_command(label="Instruction",
command=self.show_instruction)
self.menu.add_cascade(label="Help", menu=self.help)
####################################################################################
def client_exit(self):
exit()
def is_uniconfig(self):
if self.config_file_PATH_txt.get(
'1.0', END) != '\n' and self.config_file_5g_PATH_txt.get(
'1.0', END) != '\n':
self.config_file_5g_PATH_txt.delete("1.0", "end")
return False
else:
return True
def open_config(self):
###Test
# global config_file_PATH
# config_file_PATH = r'G:\PycharmProjects\Log_Extractor\parser.cfg'
filename = askopenfilename(initialdir=self.cur_dir,
title="Select file",
filetypes=(("config file", "*.cfg"),
("all files", "*.*")))
if filename:
global QCAT_config_file_PATH
QCAT_config_file_PATH = filename
print(QCAT_config_file_PATH)
# self.update_text()
self.config_file_PATH_txt.delete("1.0", "end")
self.config_file_5g_PATH_txt.delete("1.0", "end")
self.config_file_PATH_txt.insert(END, QCAT_config_file_PATH)
self.extract_config_button.config(state=NORMAL)
else:
showerror("Error", "No file selected")
if self.is_uniconfig() == False:
showerror("Error", "Cannot choose more than one config file!!!")
def open_config_5g(self):
###Test
# global config_file_PATH
# config_file_PATH = r'G:\PycharmProjects\Log_Extractor\parser.cfg'
if self.cur_dir == None:
self.cur_dir = os.getcwd()
filename = askopenfilename(initialdir=self.cur_dir,
title="Select file",
filetypes=(("config file", "*.cfg"),
("all files", "*.*")))
if filename:
global config_file_PATH
config_file_PATH = filename
print(config_file_PATH)
# self.update_text()
self.config_file_PATH_txt.delete("1.0", "end")
self.config_file_5g_PATH_txt.delete("1.0", "end")
self.config_file_5g_PATH_txt.insert(END, config_file_PATH)
self.extract_config_button.config(state=NORMAL)
else:
showerror("Error", "No file selected")
if self.is_uniconfig() == False:
showerror("Error", "Cannot choose more than two config files!!!")
def open_raw_log(self):
# Test
# global log_file_PATH
# log_file_PATH = r'G:\PycharmProjects\Log_Extractor\Test\log_test.txt'
log_path = askopenfilenames(initialdir=self.cur_dir,
title="Select file",
filetypes=(("raw log file",
"*.qmdl *.dlf *.isf"),
("dlf file", "*.dlf"),
("all files", "*.*")))
if log_path:
global QCAT_raw_log_file_PATH
# QCAT_raw_log_file_PATH = log_path
for path in log_path:
QCAT_raw_log_file_PATH.append(path)
# print(log_path)
self.raw_log_file_PATH_txt.delete("1.0", "end")
self.raw_log_file_PATH_txt.insert(END, QCAT_raw_log_file_PATH)
else:
showerror("Error", "No file selected")
def set_output_directory(self):
csv_dir = askdirectory()
if csv_dir:
global QCAT_output_directory
QCAT_output_directory = csv_dir
self.QCAT_txt_dir_txt.delete("1.0", "end")
self.QCAT_txt_dir_txt.insert(END, csv_dir)
else:
showerror("Error", "No directory selected")
##Test'
# global csv_folder_PATH
# csv_folder_PATH = r'C:\Users\Admin\Desktop\test'
def change_file_name(self, log_path, exported_path):
"""Change exported file name from 'analyzer'.txt to 'log_analyser.txt'"""
from tool_summary import is_file_exist
if not is_file_exist(exported_path):
return False
if log_path.find('/'):
split_log_path = log_path.split('/')
log_name = split_log_path[-1].split('.')[
0] # remove file extension, Ex. '.txt'
exported_path = exported_path.replace('\\', '/')
if exported_path.find('/'):
cur_dir = os.getcwd()
short_dir = exported_path.split(
cur_dir) # Get short path from current directory
split_exported_path = short_dir[1].split('/')
exported_name = split_exported_path[-1] # Get file name
if log_name and exported_name:
new_path = os.path.join(*split_exported_path[:-1],
log_name + '_' + exported_name)
if not is_file_exist(new_path):
os.rename(exported_path, new_path)
return True
return False
def call_extract(self):
global QCAT_config_file_PATH
global QCAT_log_list_brief, QCAT_log_list_full, grids
try:
self.log_type_txt.delete("1.0", "end")
self.log_type_txt.insert(END, "Extracting...\n")
lines = read_file(QCAT_config_file_PATH)
QCAT_log_list_brief, QCAT_log_list_full, grids = read_config_log_types(
lines)
if len(QCAT_log_list_brief) != 0:
# self.log_type_txt.delete("1.0", "end")
self.log_type_txt.insert(END, '\n#Packets\n')
for log in QCAT_log_list_brief:
self.log_type_txt.insert(END, log + '\n')
if len(grids) != 0:
self.log_type_txt.insert(END, '\n#Grids\n')
for grid in grids.keys():
self.log_type_txt.insert(END, grid + '\n')
self.log_type_txt.insert(END, "\nExtract successfully!!!\n")
# showinfo("Respond", "Extract successfully")
else:
showwarning("Config Empty",
"No log type found in config file. Try again!")
except:
# self.log_type_txt.delete("1.0", "end")
self.log_type_txt.insert(END, "Error extracting\n")
def call_import_txt(self):
global QCAT_raw_log_file_PATH, QCAT_output_directory, QCAT_log_list_brief, grids
self.log_type_txt.insert(END, "Importing! Please wait...\n")
if QCAT_raw_log_file_PATH == '' or QCAT_output_directory == '' or len(
QCAT_log_list_brief) == 0:
self.log_type_txt.insert(
END,
"Error, Please check raw log path, output directory and config file\n"
)
try:
QCAT_Execute(QCAT_raw_log_file_PATH, QCAT_log_list_brief,
QCAT_output_directory)
# Export all grids according to analyzers in configuration file
#TODO : Put import on the top
from QCAT_Lib.QCAT_Basic import qcat_export_grids
from tool_summary import path_to_outfile
qcat_export_grids(QCAT_raw_log_file_PATH, grids.values(),
QCAT_output_directory)
# Change exported file name
for grid in grids.keys():
outfile_path = path_to_outfile(grid)
self.change_file_name(QCAT_raw_log_file_PATH, outfile_path)
self.log_type_txt.insert(END, "Import successful")
except:
self.log_type_txt.insert(END, "Error importing\n")
# def openQCAT(self):
# self.newWindow = Toplevel(self.master)
# self.app = QCAT_Auto(self.newWindow)
def show_instruction(self):
pass
def show_about(self):
pass
class GameScreen:
def __init__(self, master, params, model=None):
self.master = master
self.controller = GameScreenController(params, model=model)
self.width = self.controller.model.width
self.height = self.controller.model.height
self.graphic_init()
self.is_run = True
self.run()
def draw(self):
# Сделать 4 солнца
model = self.controller.model
x, y = model.sun_x, model.sun_y
suns = [(x, y), (x - self.width, y), (x, y - self.height), (x - self.width, y - self.height)]
for x, y in suns:
self.canvas.create_rectangle(
max(0, x),
max(0, y),
min(x + model.sun_size, self.width + 1),
min(y + model.sun_size, self.height + 1),
fill="yellow",
)
for coord, creature in model.creatures.items():
color = "#00{:0>2}00".format(hex(int(creature.life * 255))[2:])
if not creature.alive:
color = "red"
func = self.canvas.create_oval
func(coord[0], coord[1], coord[0] + 6, coord[1] + 6, fill=color)
def graphic_init(self):
self.frame = Frame(self.master, bd=2)
self.button_frame = Frame(self.frame, bd=2)
self.button_frame.grid_bbox(row=1, column=4)
self.start_stop_button = Button(self.button_frame, text="Пауза", command=self.start_stop_pressed)
self.start_stop_button.grid(row=1, column=2)
self.save_button = Button(self.button_frame, text="Сохранить", command=self.save_pressed)
self.save_button.grid(row=1, column=1)
self.info_button = Button(self.button_frame, text="Инфо", command=self.info_pressed, state=DISABLED)
self.info_button.grid(row=1, column=4)
self.add_button = Button(self.button_frame, text="Добавить существо", command=self.add_pressed)
self.add_button.grid(row=1, column=3)
self.canvas = Canvas(self.frame, width=self.width, height=self.height)
self.canvas.pack(side=TOP)
self.button_frame.pack()
self.frame.pack()
def start_stop_pressed(self):
self.is_run = not self.is_run
self.start_stop_button.config(text="Пауза" if self.is_run else "Старт")
self.info_button.config(state=DISABLED if self.is_run else ACTIVE)
self.run()
def save_pressed(self):
filename = asksaveasfilename(title="Сохранить мир")
if filename:
try:
self.controller.save_pressed(filename)
except Exception as e:
messagebox.showerror("Не удалось сохранить файл", str(e))
def info_pressed(self):
InfoWindow(self.controller.model)
def add_pressed(self):
self.controller.add_pressed()
def run(self):
if self.is_run:
self.canvas.delete("all")
self.controller.run()
self.draw()
self.master.after(1, self.run)
class Main():
def __init__(self, parent, CPU_object):
# Set up the basic variables and the frame
self.cpu = CPU_object
self.parent = parent
self.parent.title("Main")
self.frame = Frame(parent)
self.frame.config(pady = 10)
self.running = True
self.reg_list = RegisterListener(self.update_regs)
# Set up the label at the top
self.label = Label(self.frame, text = "Registers: ")
self.label.grid(row = 0, columnspan = 2)
# Set up the labels and text-boxes for the registers
self.register_text = []
self.register_label = []
# A loop for setting the registers text boxes and labels
for x in range(11):
# Use tricky-tricks to not have to write in the values for the labels
label_text = REV_VALUES[x] + ": "
if x > 7:
label_text = REV_VALUES[x + 19] + ": "
self.register_label.append(Label(self.frame, text = label_text))
self.register_text.append(Entry(self.frame, width = 25))
self.register_label[x].grid(row = x + 1, column = 0)
self.register_text[x].grid(row = x + 1, column = 1)
#Set up the buttons into the frame
self.monitor_button = Button(self.frame, text = "Open monitor", width = 25, command = self.open_monitor)
self.watcher_button = Button(self.frame, text = "Open watcher", width = 25, command = self.open_watcher)
self.run_button = Button(self.frame, text = "Run program", width = 25, command = self.run_program)
self.step_button = Button(self.frame, text = "Step program", width = 25, command = self.step_program)
self.stop_button = Button(self.frame, text = "Stop program", width = 25, command = self.stop_program)
# Pack the buttons
self.monitor_button.grid(row = 12, columnspan = 2)
self.watcher_button.grid(row = 13, columnspan = 2)
self.run_button.grid(row = 14, columnspan = 2)
self.step_button.grid(row = 15, columnspan = 2)
self.stop_button.grid(row = 16, columnspan = 2)
# Pack the frame
self.frame.pack()
# Handle the closing event (unregister the event listener)
self.parent.protocol("WM_DELETE_WINDOW", self.handle_close)
def step_program(self):
# Step through the program and update the registers
self.cpu.step()
time.sleep(0.1)
# Disable the buttons for step/run
if len(self.cpu.text) == self.cpu.PC:
self.step_button.config(state = DISABLED)
self.run_button.config(state = DISABLED)
def run(self):
while(len(self.cpu.text) != self.cpu.PC and self.running):
self.step_program()
def stop_program(self):
self.running = False
def run_program(self):
self.running = True
t = threading.Thread(target=self.run)
t.start()
# self.run()
def update_text(self, obj, text):
# Update the text in an Entry object
obj.delete(0, END)
obj.insert(0, text)
def update_regs(self, data):
# Update the general registers
for i, reg in enumerate(self.cpu.regs):
self.update_text(self.register_text[i], hex(reg))
# Update SP, PC, and O
self.update_text(self.register_text[8], hex(self.cpu.SP))
self.update_text(self.register_text[9], hex(self.cpu.PC))
self.update_text(self.register_text[10], hex(self.cpu.O))
def handle_close(self):
self.reg_list.unregister()
self.parent.quit()
def open_watcher(self):
self.watcher_window = Toplevel(self.parent)
self.app = MemoryWatcher(self.watcher_window)
def open_monitor(self):
# Open the monitor
self.monitor_window = Toplevel(self.parent)
self.app = Monitor(self.monitor_window)
class myFirstGUI:
def __init__(self, master):
self.master = master
self.my_blue_button = "#006a9b"
self.background = "#4E4E50"
master.title = ("Aquisição de dados")
self.my_blue = "#13E7EB"
#flag for HRV bar movement
self.active = False
self.increase = True
self.background_label = Label(master, background=self.background)
self.background_label.place(x=0, y=0, relwidth=1, relheight=1)
self.title_string = StringVar()
self.title_string.set("Bem-vindo!")
self.title_w = Label(self.background_label,
textvariable=self.title_string,
font=("Helvetica", 30),
foreground="#ffffff",
background=self.background)
self.title_w.place(relx=0.5, rely=0.3, anchor="center")
self.instruction_string = StringVar()
self.instruction_string.set(
"O teste irá começar em breve. Por favor aguarde")
self.instruction_label = Label(self.background_label,
textvariable=self.instruction_string,
font=("Helvetica", 18),
foreground="#ffffff",
background=self.background)
self.instruction_label.place(relx=0.5, rely=0.4, anchor="center")
self.button_string = StringVar()
self.button_string.set("Clique para começar!")
self.next_button = Button(self.background_label,
textvariable=self.button_string,
font=("Helvetica", 14),
foreground="#ffffff",
background=self.my_blue_button)
self.next_button.config(width=len("Clique para começar!") + 2)
self.next_button['command'] = lambda: self.start_callback()
self.next_button.place(relx=0.5, rely=0.5, anchor="center")
def start_callback(self):
#create timestamps objects, to store all the relevant times
self.experimentTimestamps = experimentTimeObject(
time.perf_counter(), datetime.now(), time.time())
#change layout for heart rate variability instructions
self.title_w.place_forget()
self.title_string.set("Variabilidade da Frequência Cardíaca\n")
self.title_w.place(relx=0.5, rely=0.2, anchor="center")
self.instruction_string.set(
"No ecrã seguinte será apresentada uma animação. Tente que o seu padrão respiratório siga a animação. \n\n Tente manter-se relaxado.\n"
)
self.button_string.set("Entendi")
self.next_button['command'] = lambda: self.start_hrv_test()
self.next_button.place(relx=0.5, rely=0.6)
def start_hrv_test(self):
self.experimentTimestamps.add_entry("t2", time.perf_counter())
#call function that skips one minute, to measure stuff at baseline
self.my_yellow = "#F5F50F"
#update HRV bar movement flag
self.active = True
self.baseline = True
self.breathing_instruction = StringVar()
self.breathing_instruction.set("INSPIRE")
#Add key to skip HRV part of the test. If the user presses the "s" key, it will go to the next part of the test
self.master.bind("<s>", self.start_pvt)
#variables that define the interval between consecutive breathings and experiment duration
self.total_duration = 4 * 60 #total time of 5 minutes, expressed in seconds
self.breathing_interval = 5 #means that patient should inspire for 5 seconds, and expire for 5 seconds. 10 seconds total breathing intervals
#hide previous layout
self.instruction_label.place_forget()
self.next_button.place_forget()
self.title_w.place_forget()
self.background_label.place_forget()
self.background_label.place(x=0, y=0, relwidth=1, relheight=1)
#add title again
self.title_w.place(relx=0.5, rely=0.2, anchor="center")
#draw background rectangle
self.static_width = 800
self.rectangle = Canvas(self.background_label,
bg=self.background,
width=self.static_width,
height=150)
self.rectangle.place(relx=0.5, rely=0.4, anchor="center")
#draw first moving rectangle
self.variable_width = 0
self.rectangle_variable = Canvas(self.rectangle,
bg=self.my_yellow,
width=self.variable_width,
height=150)
self.rectangle_variable.place(relx=0, rely=0)
#draw first breathing instruction
self.instruction_widget = Label(
self.background_label,
textvariable=self.breathing_instruction,
font=("Helvetica", 65),
background=self.background,
foreground=self.my_yellow)
self.instruction_widget.place(relx=0.5, rely=0.65, anchor="center")
#measure initial time
self.initial_time = time.time()
#call meque no botãthod that will start iterative updates
self.master.bind("<d>", self.delete_this) #delete this!!
self.move_rectangle()
def hrv_clear_rectangles(self):
#this function was developed later, that's why it's not used everywhere
self.rectangle.place_forget()
self.rectangle_variable.place_forget()
self.instruction_widget.place_forget()
self.title_w.place_forget()
def hrv_place_rectangles(self):
self.background_label.place(x=0, y=0, relwidth=1, relheight=1)
self.rectangle.place(relx=0.5, rely=0.4, anchor="center")
self.instruction_widget.place(relx=0.5, rely=0.65, anchor="center")
self.title_w.place(relx=0.5, rely=0.2, anchor="center")
self.rectangle_variable.place(relx=0, rely=0)
def rectangle_update(self):
actual_time = time.time()
#Decision if rectangle should grow or get smaller depends on 3 factors: time is an independent one and should be verified here.
#The others factors are width below 0 or above 800. Any of these events will shift the direction of growth.
if actual_time - self.iteration_start_time > 5:
self.iteration_start_time = time.time()
if self.increase:
self.increase = False
#update instruction widget
self.breathing_instruction.set("EXPIRE")
self.instruction_widget.place_forget()
self.instruction_widget.config(foreground=self.my_blue)
self.instruction_widget.place(relx=0.5,
rely=0.65,
anchor="center")
self.title_w.place_forget()
self.title_w.place(relx=0.5, rely=0.2, anchor="center")
self.rectangle_variable.config(bg=self.my_blue)
else:
self.increase = True
#update instruction widget
self.breathing_instruction.set("INSPIRE")
self.instruction_widget.place_forget()
self.instruction_widget.config(foreground=self.my_yellow)
self.instruction_widget.place(relx=0.5,
rely=0.65,
anchor="center")
self.title_w.place_forget()
self.title_w.place(relx=0.5, rely=0.2, anchor="center")
self.rectangle_variable.config(bg=self.my_yellow)
#Either way, increase or decrease is proportional to time left for 5 seconds
if (self.increase):
self.rectangle_variable.place_forget()
#width increase
self.variable_width = (self.static_width /
self.breathing_interval) * (
actual_time - self.iteration_start_time)
#Shift growth direction
if self.variable_width > 800:
self.variable_width = 800
self.increase = False
self.iteration_start_time = time.time()
#update instruction widget
self.breathing_instruction.set("INSPIRE")
self.instruction_widget.place_forget()
self.instruction_widget.config(foreground=self.my_yellow)
self.instruction_widget.place(relx=0.5,
rely=0.65,
anchor="center")
self.title_w.place_forget()
self.title_w.place(relx=0.5, rely=0.2, anchor="center")
self.rectangle_variable.config(bg=self.my_yellow)
else:
#width decrease
self.variable_width = self.static_width - (
(self.static_width / self.breathing_interval) *
(actual_time - self.iteration_start_time))
#shift growth direction
if self.variable_width < 0:
self.variable_width = 0
self.increase = True
self.iteration_start_time = time.time()
#update instruction widget
self.breathing_instruction.set("EXPIRE")
self.instruction_widget.place_forget()
self.instruction_widget.config(foreground=self.my_blue)
self.instruction_widget.place(relx=0.5,
rely=0.65,
anchor="center")
self.title_w.place_forget()
self.title_w.place(relx=0.5, rely=0.2, anchor="center")
self.rectangle_variable.config(bg=self.my_blue)
#call functions to draw the new rectangle
self.rectangle_variable.place_forget()
self.rectangle_variable.config(width=self.variable_width)
self.rectangle_variable.place(relx=0, rely=0)
#after the update, check if the total experiment time was acchieved
if actual_time - self.initial_time > self.total_duration:
#move on to next test. Call method that starts PVT
self.active = False
self.start_pvt()
def layout_baseline(self):
#clear layout
self.hrv_clear_rectangles()
#set new layout
self.title_w.place(relx=0.5, rely=0.20, anchor="center")
#self.title_w.config
self.relaxation_widget = Label(self.background_label,
text="TENTE PERMANECER RELAXADO.",
font=("Helvetica", 30),
background=self.background,
foreground=self.my_yellow)
self.relaxation_widget2 = Label(
self.background_label,
text="IREMOS COMEÇAR DENTRO DE APROXIMADAMENTE UM MINUTO.",
font=("Helvetica", 22),
background=self.background,
foreground=self.my_yellow)
self.relaxation_widget.place(relx=0.5, rely=0.40, anchor="center")
self.relaxation_widget2.place(relx=0.5, rely=0.65, anchor="center")
def delete_this(self, event=None):
self.initial_time = time.time() - 50
def move_rectangle(self):
now = time.time()
if self.active:
if (now - self.initial_time) < 60:
#the first minute is just to measure baseline and relax
if self.baseline == True:
self.layout_baseline()
self.baseline = False
else:
if self.baseline == False:
self.relaxation_widget.place_forget()
self.relaxation_widget2.place_forget()
self.hrv_clear_rectangles()
self.hrv_place_rectangles()
self.baseline = True #this is just to not verify this condition anymore. this will only run one time, and it's to set the first layout...
self.iteration_start_time = time.time()
self.rectangle_update()
self.call_identifier = self.master.after(20, self.move_rectangle)
def start_pvt(self, event=None):
self.experimentTimestamps.add_entry("t3", time.perf_counter())
#make sure that hrv part has finished
self.active = False
#associate <s> key to skip this part of the test
#self.master.bind("<s>", *nextmethod*)
#clear screen
self.rectangle.place_forget()
self.rectangle_variable.place_forget()
self.instruction_widget.place_forget()
self.title_w.place_forget()
self.relaxation_widget.place_forget()
self.relaxation_widget2.place_forget()
#set new title and instruction
self.title_string.set("Tempo de Reação")
self.instruction_string.set(
"No ecrã seguinte, será apresentado um rectângulo de cor verde. \n Sempre que a cor mudar para vermelho, clique no botão esquerdo do rato.\n\n Caso tenha alguma questão, não hesite em perguntar."
)
self.title_w.place(relx=0.5, rely=0.2, anchor="center")
self.instruction_label.place(relx=0.5, rely=0.4, anchor="center")
self.next_button['command'] = lambda: self.pvt_test()
self.next_button.place(relx=0.5, rely=0.60, anchor="center")
def pvt_test(self):
self.experimentTimestamps.add_entry("t4", time.perf_counter())
self.pvt_tries = 5
self.pvt_counter = 0
self.pvt_active = False
self.pvt_green = "#20E820"
self.pvt_red = "#ED1F1F"
self.switch_time = {'0': 5, '1': 7, '2': 3, '3': 10, '4': 5}
#associate <s> key to skip pvt test
self.master.bind("<s>", self.signature_instruction_layout)
#bind mouse1 to click
self.master.bind("<Button-1>", self.pvt_click_detected)
#configure screen layout
self.next_button.place_forget()
self.instruction_label.place_forget()
self.title_w.place_forget()
self.pvt_box = Canvas(self.background_label,
bg=self.pvt_green,
width=800,
height=300)
self.pvt_box.place(relx=0.5, rely=0.4, anchor="center")
self.breathing_instruction.set("PREPARE-SE")
self.instruction_widget.config(foreground=self.my_yellow,
font=("Helvetica", 50))
self.instruction_widget.place(relx=0.5, rely=0.70, anchor="center")
self.title_w.place(relx=0.5, rely=0.10, anchor="center")
self.pvt_iteration_start_time = time.perf_counter()
#get things rolling
self.pvt_iteration()
def pvt_iteration(self):
if self.pvt_counter < 5:
self.pvt_update()
else:
self.signature_instruction_layout()
def pvt_update(self):
time_dif = time.perf_counter() - self.pvt_iteration_start_time
if time_dif >= self.switch_time[str(self.pvt_counter)]:
self.title_w.place_forget()
self.title_w.place(relx=0.5, rely=0.1, anchor="center")
self.instruction_widget.place_forget()
self.instruction_widget.place(relx=0.5, rely=0.70, anchor="center")
self.pvt_active = True
self.pvt_box.place_forget()
self.pvt_box.config(bg=self.pvt_red)
self.pvt_box.place(relx=0.5, rely=0.4, anchor="center")
self.reaction_ini_time = time.perf_counter()
else:
if self.pvt_counter < 5:
self.call_identifier = self.master.after(10, self.pvt_update)
def pvt_click_detected(self, event=None):
self.reaction_end_time = time.perf_counter()
if self.pvt_active == False:
#user clicked on mouse1 before the correct time
#maybe display saying something like: chillout or a buzzing noise
self.pvt_iteration_start_time = time.perf_counter()
self.reaction_end_time = None
self.experimentTimestamps.add_entry("PVT_MISTAKE", "MISTAKE")
else:
self.reaction_time = self.reaction_end_time - self.reaction_ini_time
print('Reaction time number ', self.pvt_counter)
self.experimentTimestamps.add_entry(
"reaction_" + str(self.pvt_counter), str(self.reaction_time))
self.experimentTimestamps.add_entry(
"t4" + str(2 * self.pvt_counter), self.reaction_ini_time)
self.experimentTimestamps.add_entry(
"t4" + str(2 * self.pvt_counter + 1), self.reaction_end_time)
#restore control variables and layout
self.title_w.place_forget()
self.title_w.place(relx=0.5, rely=0.1, anchor="center")
self.pvt_box.place_forget()
self.pvt_box.config(bg=self.pvt_green)
self.pvt_box.place(relx=0.5, rely=0.4, anchor="center")
self.instruction_widget.place_forget()
self.instruction_widget.place(relx=0.5, rely=0.70, anchor="center")
self.pvt_active = False
self.pvt_counter = self.pvt_counter + 1
self.pvt_iteration_start_time = time.perf_counter()
self.pvt_iteration()
def signature_instruction_layout(self, event=None):
self.experimentTimestamps.add_entry("t5", time.perf_counter())
#control variables for this test
self.number_signatures = 5
self.signature_counter = 0
#disable old flags
self.pvt_active = False
self.pvt_counter = 10 #just to be higher than 5, it's not necessary probably
#unbind
self.master.unbind("<Button-1>")
self.master.unbind("<s>")
#clear window
self.title_w.place_forget()
self.pvt_box.place_forget()
self.instruction_widget.place_forget()
self.next_button.place_forget()
#set new layout
self.title_string.set("Assinatura")
self.instruction_string.set(
"Nesta parte receberá uma folha em branco, que deverá assinar " +
repr(self.number_signatures) +
" vezes.\n\n De cada vez que terminar uma assinatura, deverá parar e clicar num botão de contagem que estará na página seguinte. \n\n Caso tenha alguma questão não hesite em perguntar."
)
self.title_w.place(relx=0.5, rely=0.2, anchor="center")
self.instruction_label.place(relx=0.5, rely=0.4, anchor="center")
self.next_button['command'] = lambda: self.signature_test()
self.next_button.place(relx=0.5, rely=0.6, anchor="center")
def signature_test(self):
self.experimentTimestamps.add_entry("t6", time.perf_counter())
#change layout
self.instruction_label.place_forget()
self.title_w.place_forget()
self.instruction_string.set(
"Deve incrementar o contador abaixo sempre que terminar uma assinatura."
)
self.breathing_instruction.set("NÚMERO DE ASSINATURAS OBTIDAS: " +
repr(self.signature_counter))
self.button_string.set("Incrementar")
self.instruction_widget.config(fg=self.pvt_green,
font=("Helvetica", 40))
self.next_button['command'] = lambda: self.signature_increment()
self.title_w.place(relx=0.5, rely=0.2, anchor="center")
self.instruction_label.place(relx=0.5, rely=0.3, anchor="center")
self.instruction_widget.place(relx=0.5, rely=0.5, anchor="center")
self.next_button.place(relx=0.5, rely=0.7, anchor="center")
def signature_increment(self):
self.experimentTimestamps.add_entry("t6" + str(self.signature_counter),
time.perf_counter())
self.signature_counter = self.signature_counter + 1
self.clear_screen()
self.breathing_instruction.set("NÚMERO DE ASSINATURAS OBTIDAS: " +
repr(self.signature_counter))
self.title_w.place(relx=0.5, rely=0.2, anchor="center")
self.instruction_label.place(relx=0.5, rely=0.3, anchor="center")
self.instruction_widget.place(relx=0.5, rely=0.5, anchor="center")
self.next_button.place(relx=0.5, rely=0.7, anchor="center")
if self.signature_counter == self.number_signatures:
#call next method
self.cognitive_tests_layout()
def cognitive_tests_layout(self):
self.experimentTimestamps.add_entry("t7", time.perf_counter())
#clear screen
self.clear_screen()
self.title_string.set("Trail Making Test - Parte A")
self.instruction_string.set(
"Nesta parte irá receber uma folha que contém diversas bolas numeradas. \n\n O objetivo é unir as diversas bolas de forma sequencial, o mais rapidamente possível e sem cometer erros. \n\n Caso tenha alguma dúvida não hesite em perguntar."
)
self.button_string.set("Começar")
self.next_button['command'] = lambda: self.start_trail_making_a()
self.title_w.place(relx=0.5, rely=0.2, anchor="center")
self.instruction_label.place(relx=0.5, rely=0.4, anchor="center")
self.next_button.place(relx=0.5, rely=0.6, anchor="center")
def start_trail_making_a(self):
self.experimentTimestamps.add_entry("t8", time.perf_counter())
self.clear_screen()
self.instruction_string.set(
"Quando terminar o teste, clique no botão abaixo.")
self.button_string.set("Terminado")
self.next_button['command'] = lambda: self.prepare_trail_making_b()
self.add_common_widgets()
self.ini_time_tma = datetime.now()
def prepare_trail_making_b(self):
self.experimentTimestamps.add_entry("t9", time.perf_counter())
self.end_time_tma = datetime.now()
dif = self.end_time_tma - self.ini_time_tma
print("TRAIL MAKING A: Demorou " + repr(dif.seconds) +
" a completar a primeira parte do teste.")
self.clear_screen()
self.title_string.set("Trail Making Test - Parte B")
self.instruction_string.set(
"Nesta parte irá receber uma folha que contém diversas bolas, com números ou letras. \n\n O objetivo é unir as diversas bolas de forma sequencial, o mais rapidamente possível e sem cometer erros. \n \n Tenha em consideração que por exemplo a letra B é equivalente ao número 2. \n\n Caso tenha alguma dúvida não hesite em perguntar."
)
self.button_string.set("Começar")
self.next_button['command'] = lambda: self.start_trail_making_b()
self.add_common_widgets()
def start_trail_making_b(self):
self.experimentTimestamps.add_entry("t10", time.perf_counter())
self.clear_screen()
self.instruction_string.set(
"Quando terminar o teste, clique no botão abaixo.")
self.button_string.set("Terminado")
self.next_button['command'] = lambda: self.store_end_time_tmb()
self.add_common_widgets()
self.ini_time_tmb = datetime.now()
def store_end_time_tmb(self):
self.experimentTimestamps.add_entry("t11", time.perf_counter())
self.end_time_tmb = datetime.now()
dif = self.end_time_tmb - self.ini_time_tmb
print("TRAIL MAKING B: Demorou " + repr(dif.seconds) +
" a completar a primeira parte do teste.")
self.physical_tests_layout()
def physical_tests_layout(self):
self.clear_screen()
self.title_string.set("Testes físico")
self.instruction_string.set(
"Para esta parte deverá colocar a pulseira no seu braço não dominante. \n\n De seguida será explicado os exercícios que deverá efectuar."
)
self.button_string.set("Iniciar")
self.next_button['command'] = lambda: self.start_physical_tests()
self.add_common_widgets()
def start_physical_tests(self):
self.experimentTimestamps.add_entry("t12", time.perf_counter())
self.ini_time_physical = datetime.now()
self.physical_tests_counter = 0
self.number_physical_tests = 5
self.clear_screen()
self.breathing_instruction.set("NÚMERO DE VOLTAS TERMINADAS: " +
repr(self.physical_tests_counter))
self.instruction_string.set(
"Clique no botão abaixo sempre que uma volta for completada")
self.title_w.place(relx=0.5, rely=0.2, anchor="center")
self.instruction_label.place(relx=0.5, rely=0.3, anchor="center")
self.instruction_widget.place(relx=0.5, rely=0.5, anchor="center")
self.next_button.place(relx=0.5, rely=0.7, anchor="center")
self.button_string.set("Incrementar")
self.next_button['command'] = lambda: self.physical_increment()
#self.add_common_widgets()
def physical_increment(self, event=None):
self.experimentTimestamps.add_entry(
"t12" + str(self.physical_tests_counter), time.perf_counter())
self.physical_tests_counter = self.physical_tests_counter + 1
self.clear_screen()
self.breathing_instruction.set("NÚMERO DE VOLTAS TERMINADAS: " +
repr(self.physical_tests_counter))
self.title_w.place(relx=0.5, rely=0.2, anchor="center")
self.instruction_label.place(relx=0.5, rely=0.3, anchor="center")
self.instruction_widget.place(relx=0.5, rely=0.5, anchor="center")
self.next_button.place(relx=0.5, rely=0.7, anchor="center")
if self.physical_tests_counter == self.number_physical_tests:
#call next method
self.store_end_time_physical()
def store_end_time_physical(self):
self.experimentTimestamps.add_entry("t13", time.perf_counter())
self.end_time_physical = datetime.now()
dif1 = self.end_time_physical - self.ini_time_physical
self.thank_you_layout()
def thank_you_layout(self):
self.clear_screen()
self.title_string.set("Muito obrigado pelo seu contributo!")
self.button_string.set("Exportar dados")
self.next_button['command'] = lambda: self.export_time_intervals()
self.title_w.place(relx=0.5, rely=0.5, anchor="center")
self.next_button.place(relx=0.5, rely=0.7, anchor="center")
#ADD LOGOS OF ISR and HBA
def export_time_intervals(self):
#prompt for patient name in
self.patient_name = input("Escreva o nome do paciente: ")
filename = self.patient_name + "_" + str(
self.experimentTimestamps.epoch)
filename = filename.replace(" ", "_")
filename = filename.replace(":", "-")
filename = filename.replace(".", "-")
print("Name of file %s", filename)
with open(filename + '.json', "w") as fp:
json.dump(self.experimentTimestamps.stamp_dict, fp)
def add_common_widgets(self):
self.title_w.place(relx=0.5, rely=0.2, anchor="center")
self.instruction_label.place(relx=0.5, rely=0.4, anchor="center")
self.next_button.place(relx=0.5, rely=0.6, anchor="center")
def clear_screen(self):
self.title_w.place_forget()
self.instruction_label.place_forget()
self.next_button.place_forget()
self.instruction_widget.place_forget()
def refreshWidget(self) :
#print "refresh"
self.card_win.pack_forget()
import unicodedata
#Card window
self.card_win = PanedWindow(self.card_win.master, orient=VERTICAL)
self.card_win.pack(side=TOP, expand=True, fill=BOTH, pady=2, padx=2)
#Create the name zone
name_zone=PanedWindow(self.card_win, orient=HORIZONTAL)
name = StringVar()
name.set(self.name)
def modifName(*args) :
try :
assert('"' not in name.get())
name.get().encode('ascii')
except Exception as e:
print ("error on name")
name.set(self.name)
return
old = self.name in Card.blocked_creature
self.name=name.get()
if old or self.name in Card.blocked_creature :
self.refreshWidget()
name.trace("w", modifName)
name_wid=Entry(name_zone, width=30,textvariable=name)
name_wid.pack()
name_zone.add(name_wid)
#Create the cost ad star stringvar
#print int(floor(self.getCost()))
self.cost=StringVar()
self.stars=StringVar()
cost_wid=Label(None, textvariable=self.cost, background='red',width=5, anchor=W)
star_wid=Label(None, textvariable=self.stars, background='blue', anchor=E)
self.cost.set(str(int(floor(self.getCost()))))
self.stars.set("*"*self.getStars())
#Add them in name zone
name_zone.add(cost_wid)
name_zone.add(star_wid)
#Create an Image Zone
image_zone=Button(self.card_win, command=self.choosePhoto)
if hasattr(self,"photofile") and self.photofile :
print ("Image: ",self.photofile)
try :
pilImage=Image.open(self.photofile)
img=PhotoImage(pilImage,master=image_zone)
except :
decomp=self.photofile.split('/')
for i in range(1,6) :
try :
fname="/".join(decomp[-i:])
print ("try to open",fname)
pilImage = Image.open(fname)
img=PhotoImage(pilImage,master=image_zone)
self.photofile=fname
break
except :
self.photofile=None
if self.photofile :
w, h = img.width(), img.height()
print('wh',w,h)
if h>400 :
print("reduction")
img=PhotoImage(pilImage.resize((w//2,h//2), Image.ANTIALIAS),master=image_zone)
image_zone=Button(self.card_win,image=img, command=self.choosePhoto)
image_zone.image=img
#image_zone.configure(image=image_zone.image,width=50,height=50,compound=RIGHT)
#image_zone.pack()
#print "IMAGE CHANGED"
else :
from os import path
fname=self.name.replace(" ","_")
if path.isfile("Cards/"+fname+".png") :
image_zone.config(text='image can be taken from\n'+"Cards/"+fname+".png",background='white',anchor=CENTER)
else :
image_zone.config(text='clic to choose image',background='white',anchor=CENTER)
#image_zone.pack()
# POWER ZONE
power_zone=PanedWindow(self.card_win, orient=VERTICAL)
#fenetre=self.card_win.master
def removePowerCreator(px) :
def removePower(*args) :
#print 'avant',list_pow
self.bonus.remove(px)
#print 'apres',list_pow
#self.card_win.pack_forget()
self.refreshWidget()
return removePower
for p in self.bonus :
powline = PanedWindow(self.card_win, orient=HORIZONTAL)
pow_wid=p.initWidget(powline)
powline.add(pow_wid)
removepow=Button(powline, text="X", command=removePowerCreator(p), anchor=E)
removepow.pack()
powline.add(removepow)
power_zone.add(powline)
def addPower(*args) :
if addBonus.get()!= "add bonus":
name=addBonus.get()
else:
name=add_cost_alteration.get()
print ("added :",name)
import CardPowers
self.bonus+=[eval('CardPowers.'+name+'()')]
self.bonus[-1].parent=self.bonus
self.bonus[-1].card=self
#self.card_win.pack_forget()
self.refreshWidget()
#Add bonus Option menu
addBonus = StringVar(power_zone)
addBonus.set("add bonus") # default value
if not self.pv:
addBonus_wid = Spell.getSpellMenu(power_zone, addBonus)
else: addBonus_wid = getBonusMenu(power_zone, addBonus)
addBonus.trace('w', addPower)
if self.pv>0 or len(self.bonus)==0 or all([b.is_cost_alterator for b in self.bonus]):
addBonus_wid.pack()
#Add this to power zone
power_zone.add(addBonus_wid)
#Create save zone
save_zone = PanedWindow(self.card_win, orient=HORIZONTAL)
if self.monster_type != "all" and not(self.name in Card.blocked_creature) :
save_wid = Button(save_zone, text="Save", command=self.postAndSave)
elif self.monster_type != "all" :
save_wid = Button(save_zone, text="creature in campaign", command=None)
else:
save_wid = Button(save_zone, text="nead type", command=None)
save_wid.pack()
#Create the open button
save_zone.pack()
if Card.monster_list.keys():
self.opening = StringVar(save_zone)
self.opening.set("Open")
choice = [na for na in Card.monster_list.keys() if na not in Card.blocked_creature]
choice.sort()
#print all_monsters.keys()
open_wid = OptionMenu(save_zone, self.opening,*choice)
self.opening.trace('w', self.Open)
open_wid.pack()
save_zone.add(open_wid)
if Card.monster_list.keys():
self.delete = StringVar(save_zone)
self.delete.set("Delete")
choice = [na for na in Card.monster_list.keys() if na not in Card.blocked_creature]
choice.sort()
delete_wid = OptionMenu(save_zone, self.delete,*choice)
self.delete.trace('w', self.clicDelete)
delete_wid.pack()
save_zone.add(delete_wid)
#Create the type button
self.category = StringVar(save_zone)
self.category.set(self.monster_type)
choice = [file2name(t,"_monsters.sav") for t in glob.glob("CardFiles/*_monsters.sav")]
if "recup" in choice:
choice.remove("recup")
#print all_monsters.keys()
category_wid = OptionMenu(save_zone, self.category,*choice)
self.category.trace('w', self.setFile)
category_wid.pack()
#Add it to save zone
save_zone.add(save_wid)
save_zone.add(category_wid)
#Create a new Strength zone for att and pv
strength_zone=PanedWindow(self.card_win, orient=HORIZONTAL)
att=StringVar()
att.set(str(self.att))
pv=StringVar() ; pv.set(str(self.pv))
def modifiedAttPv(*args) :
print ("modifiedAttPv")
self.pv=int(pv.get())
if self.pv<1 and self.is_spell==False :
if len(self.bonus)==0 :
self.is_spell=True
self.refreshWidget()
else :
self.pv=1
self.refreshWidget()
if self.pv>0 and self.is_spell==True :
if len(self.bonus)==0 :
self.is_spell=False
self.refreshWidget()
else :
self.pv=0
self.refreshWidget()
self.att=int(att.get())
self.getCost()
att_wid = Spinbox(strength_zone, from_=0, to=1000,textvariable=att,command=modifiedAttPv)
att_wid.pack()
strength_zone.add(att_wid)
strength_zone.add(Label(strength_zone, text=' ', background='white',
anchor=CENTER))
pv_wid = Spinbox(strength_zone, from_=0, to=1000,textvariable=pv,command=modifiedAttPv)
pv_wid.pack()
strength_zone.add(pv_wid)
#Put it all in window
self.card_win.add(name_zone)
self.card_win.add(image_zone)
self.card_win.add(power_zone)
self.card_win.add(strength_zone)
self.card_win.add(save_zone)
self.card_win.pack()
addClassButton = Button(bottomFrame, text="Add class", fg="green", command=lambda: getCRN())
addClassButton.grid(row=1, column=2)
userInfo = Label(bottomFrame, text="Your Villanova email is: " + usernameEntry.get())
userInfo.grid(columnspan=2)
crnInfo = Label(bottomFrame, text="Your desired CRN is: " + crnEntry.get())
crnInfo.grid(columnspan=2)
registerMe = Button(bottomFrame, text="Register me", fg="green",
command=lambda: retrieve.registration(crnEntry.get(), usernameEntry.get()))
registerMe.grid(row=5, column=5)
if crnInfo['text'] == "Your desired CRN is: " and userInfo['text'] == "Your Villanova email is: ":
registerMe.config(state="disabled")
def check():
if crnInfo['text'] == "Your desired CRN is: " or userInfo['text'] == "Your Villanova email is: ":
registerMe.config(state="disabled")
else:
registerMe.config(state="active")
registerMe["command"] = lambda: retrieve.registration(crnEntry.get(), usernameEntry.get())
e = ttk.Progressbar(bottomFrame, orient=HORIZONTAL, length=200)
e.grid(row=5, column=1)
master.mainloop()
class MainWindow:
def __init__(self):
global root
self.http_session = requests.Session()
self.http_session.headers.update(HEADERS)
self.menu_bar = Menu(root)
self.menu_bar.add_command(label="Back", command=self.back_in_history)
self.menu_bar.add_command(label="Toggle image",
command=self.toggle_image)
hist_menu = Menu(self.menu_bar, tearoff=0)
hist_menu.add_command(label="All time",
command=lambda: self.show_full_history(ALL_TIME))
hist_menu.add_command(label="Last day",
command=lambda: self.show_full_history(DAY))
hist_menu.add_command(label="Two days",
command=lambda: self.show_full_history(TWO_DAYS))
hist_menu.add_command(label="Week",
command=lambda: self.show_full_history(WEEK))
hist_menu.add_command(label="Month",
command=lambda: self.show_full_history(MONTH))
hist_menu.add_command(
label="Three months",
command=lambda: self.show_full_history(THREE_MONTHS))
self.menu_bar.add_cascade(label="History", menu=hist_menu)
root.config(menu=self.menu_bar)
self.session = None
self.show_image = False
self.hist_window = None
self.proxies = None
self.model_name = None
self.update_title()
self.level = 0
self.image_label = Label(root)
self.level += 1
self.cb_model = ttk.Combobox(root, width=60)
self.cb_model.bind("<FocusIn>", self.focus_callback)
self.cb_model.bind("<Button-1>", self.drop_down_callback)
self.cb_model.bind('<Return>', self.enter_callback)
self.cb_model.focus_set()
self.cb_model.grid(row=self.level,
column=0,
columnspan=4,
sticky=W + E,
padx=PAD,
pady=PAD)
self.btn_remove = Button(root,
text="-",
command=self.remove_from_favorites)
self.btn_remove.grid(row=self.level,
column=4,
sticky=W + E,
padx=PAD,
pady=PAD)
self.level += 1
self.btn_update = Button(root,
text="Update info",
command=lambda: self.update_model_info(True))
self.btn_update.grid(row=self.level,
column=0,
sticky=W + E,
padx=PAD,
pady=PAD)
self.cb_resolutions = ttk.Combobox(root, state="readonly", values=[])
self.cb_resolutions.grid(row=self.level,
column=1,
columnspan=4,
sticky=W + E,
padx=PAD,
pady=PAD)
self.cb_resolutions['values'] = ['1080', '720', '480', '240']
self.level += 1
self.btn_show_recording = Button(root,
text="Show recording model",
command=self.show_recording_model,
state=DISABLED)
self.btn_show_recording.grid(row=self.level,
column=0,
sticky=W + E,
padx=PAD,
pady=PAD)
self.use_proxy = BooleanVar()
self.use_proxy.set(False)
self.use_proxy.trace('w', self.on_use_proxy_change)
self.chk_use_proxy = Checkbutton(root,
text='Use proxy',
variable=self.use_proxy)
self.chk_use_proxy.grid(row=self.level,
column=1,
sticky=W,
padx=PAD,
pady=PAD)
self.cb_proxy = ttk.Combobox(root, width=30, state=DISABLED)
self.cb_proxy.grid(row=self.level,
column=2,
columnspan=3,
sticky=W + E,
padx=PAD,
pady=PAD)
self.level += 1
self.btn_start = Button(root, text="Start", command=self.on_btn_start)
self.btn_start.grid(row=self.level,
column=0,
sticky=W + E,
padx=PAD,
pady=PAD)
self.btn_stop = Button(root,
text="Stop",
command=self.on_btn_stop,
state=DISABLED)
self.btn_stop.grid(row=self.level,
column=1,
sticky=W + E,
padx=PAD,
pady=PAD)
self.copy_button = Button(root,
text="Copy",
command=self.copy_model_name)
self.copy_button.grid(row=self.level,
column=2,
sticky=W + E,
padx=PAD,
pady=PAD)
self.paste_button = Button(root,
text="Paste",
command=self.paste_model_name)
self.paste_button.grid(row=self.level,
column=3,
columnspan=2,
sticky=W + E,
padx=PAD,
pady=PAD)
self.level += 1
self.progress = ttk.Progressbar(root,
orient=HORIZONTAL,
length=120,
mode='indeterminate')
root.bind("<FocusIn>", self.focus_callback)
root.protocol("WM_DELETE_WINDOW", self.on_close)
self.play_list_url = None
self.base_url = None
self.model_image = None
self.img_url = None
self.hist_logger = logging.getLogger('history')
self.hist_logger.setLevel(logging.INFO)
self.fh_hist = logging.FileHandler(
os.path.join(LOGS, f'hist_{int(time.time())}.log'))
self.fh_hist.setLevel(logging.INFO)
self.hist_logger.addHandler(self.fh_hist)
self.proxy_logger = logging.getLogger('proxy')
self.proxy_logger.setLevel(logging.INFO)
self.fh_proxy = logging.FileHandler(
os.path.join(LOGS, f'proxy_{int(time.time())}.log'))
self.fh_proxy.setLevel(logging.INFO)
self.proxy_logger.addHandler(self.fh_proxy)
self.proxy_dict = {}
self.load_proxy_dict()
self.hist_stack = []
self.load_image()
def on_btn_start(self):
self.btn_start.config(state=DISABLED)
self.stop()
idx = self.cb_resolutions.current()
success = self.update_model_info(True)
if not success:
self.set_default_state()
return
items_count = len(self.cb_resolutions['value'])
if items_count == 0:
return
if items_count <= idx or idx < 0:
idx = 0
self.cb_resolutions.current(idx)
self.session = RecordSession(self, self.base_url, self.model_name,
"chunks.m3u8")
self.session.start()
self.btn_stop.config(state=NORMAL)
self.btn_show_recording.config(state=NORMAL)
self.progress.grid(row=self.level,
column=0,
columnspan=5,
sticky=W + E,
padx=PAD,
pady=PAD)
self.progress.start()
self.update_title()
root.configure(background='green')
def on_btn_stop(self):
self.stop()
self.set_default_state()
def stop(self):
if self.session is None:
return
self.session.stop()
self.session = None
def copy_model_name(self):
clipboard.copy(self.cb_model.get())
def paste_model_name(self):
self.cb_model.set(clipboard.paste())
self.cb_model.selection_range(0, END)
def update_model_info(self, remember):
if remember and (self.model_name is not None):
if len(self.hist_stack) == 0 or (self.model_name !=
self.hist_stack[-1]):
self.hist_stack.append(self.model_name)
self.set_undefined_state()
input_url = self.cb_model.get().strip()
if len(input_url) == 0:
self.set_undefined_state()
return False
proxy = self.cb_proxy.get().strip()
if self.use_proxy.get() and len(proxy.strip()) != 0:
self.proxies = {
"http": "http://" + proxy,
"https": "https://" + proxy
}
else:
self.proxies = None
## https://live-edge66.bcvcdn.com/hls/stream_-icebabyice-/public/stream_-icebabyice-/chunks.m3u8
## https://live-edge3.bcvcdn.com/hls/stream_TemariShi/public-aac/stream_TemariShi/chunks.m3u8
self.base_url = None
if input_url.startswith('https://ded'):
public_pos = input_url.rfind('public')
self.base_url = input_url[:public_pos + 7]
stream_pos = self.base_url.find('stream_')
slash_pos = self.base_url.find('/', stream_pos)
self.model_name = self.base_url[stream_pos + 7:slash_pos]
elif input_url.startswith('https://live-edge'):
slash_pos = input_url[:-1].rfind('/')
self.base_url = input_url[:slash_pos + 1]
stream_pos = self.base_url.find('stream_')
slash_pos = self.base_url.find('/', stream_pos)
self.model_name = self.base_url[stream_pos + 7:slash_pos]
elif input_url.startswith('http'):
slash_pos = input_url[:-1].rfind('/')
self.model_name = input_url[slash_pos +
1:-1] if input_url.endswith(
'/') else input_url[slash_pos + 1:]
else:
self.model_name = input_url
if self.base_url is None:
info = self.get_model_info()
print(info)
if 'localData' not in info:
self.set_undefined_state()
return False
server_url = info['localData']['videoServerUrl']
self.model_name = info['performerData']['username']
self.cb_resolutions.set(info['performerData']['videoQuality'])
self.base_url = f"https:{server_url}/hls/stream_{self.model_name}/public-aac/stream_{self.model_name}/"
if self.use_proxy.get() and len(proxy) != 0:
self.add_to_proxies(proxy)
self.get_image_url()
self.add_to_history(self.model_name)
self.update_title()
return True
def add_to_history(self, name):
if name not in self.cb_model['values']:
self.cb_model['values'] = (name, *self.cb_model['values'])
self.hist_logger.info(name)
def remove_from_favorites(self):
name = self.cb_model.get().strip()
values = list(self.cb_model['values'])
if name not in values:
return
values.remove(name)
self.cb_model['values'] = tuple(values)
if len(values) == 0:
self.cb_model.set('')
else:
self.cb_model.set(values[0])
def add_to_proxies(self, proxy):
if len(self.cb_proxy['values']) == 0:
self.cb_proxy['values'] = proxy
elif proxy not in self.cb_proxy['values']:
self.cb_proxy['values'] = (proxy, *self.cb_proxy['values'])
self.proxy_logger.info(proxy)
count = self.proxy_dict.get(proxy, 0)
self.proxy_dict[proxy] = count + 1
def focus_callback(self, event):
self.cb_model.selection_range(0, END)
if self.hist_window is not None:
self.hist_window.lift()
def drop_down_callback(self, event):
self.cb_model.focus_set()
self.cb_model.selection_range(0, END)
self.cb_model.event_generate('<Down>')
def enter_callback(self, event):
self.update_model_info(True)
def get_image_url(self):
edge_pos = self.base_url.find('-edge')
point_pos = self.base_url.find('.', edge_pos)
# hyphen_pos = self.base_url.find('-', edge_pos + 1)
# if point_pos > hyphen_pos:
# point_pos = hyphen_pos
vsid = self.base_url[edge_pos + 5:point_pos]
self.img_url = f"https://mobile-edge{vsid}.bcvcdn.com/stream_{self.model_name}.jpg"
def get_model_info(self):
post_fields = {
'method': 'getRoomData',
'args[]': [self.model_name, "", ""]
}
headers = {
'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
'X-Requested-With': 'XMLHttpRequest'
}
try:
response = self.http_session.post(
"https://rt.chat-s-devushkami.com/tools/amf.php?x-country=a1",
data=post_fields,
headers=headers,
proxies=self.proxies,
timeout=TIMEOUT)
except RequestException as error:
print("GetRoomData exception model: " + self.model_name)
print(error)
traceback.print_exc()
return {}
return response.json()
def load_image(self):
global executor
global root
if (self.img_url is not None) or self.show_image:
executor.submit(self.fetch_image)
root.update_idletasks()
root.after(DELAY, self.load_image)
def fetch_image(self):
global root
try:
response = self.http_session.get(self.img_url, timeout=TIMEOUT)
img = Image.open(io.BytesIO(response.content))
w, h = img.size
k = 200 / w
img_resized = img.resize((200, int(h * k)))
root.after_idle(self.update_image, img_resized)
except BaseException as error:
root.after_idle(self.set_undefined_state)
print("Exception URL: " + self.img_url)
print(error)
traceback.print_exc()
def update_image(self, img):
self.model_image = ImageTk.PhotoImage(img)
self.image_label.config(image=self.model_image)
def on_close(self):
global root
self.stop()
root.update_idletasks()
root.destroy()
self.fh_hist.close()
self.hist_logger.removeHandler(self.fh_hist)
self.fh_proxy.close()
self.proxy_logger.removeHandler(self.fh_proxy)
self.http_session.close()
def set_default_state(self):
global root
self.session = None
self.btn_stop.config(state=DISABLED)
self.btn_start.config(state=NORMAL)
self.btn_show_recording.config(state=DISABLED)
self.progress.stop()
self.progress.grid_forget()
self.update_title()
root.configure(background='SystemButtonFace')
def update_title(self):
global root
root.title(self.model_name or '<Undefined>')
if self.session is None:
return
if not self.session.is_alive():
return
if self.session.model_name != root.title():
return
root.title(root.title() + " - Recording")
def set_undefined_state(self):
self.model_image = None
self.image_label.config(image=None)
self.model_name = None
self.img_url = None
self.update_title()
def show_recording_model(self):
if self.session is None:
return
self.cb_model.set(self.session.model_name)
self.cb_model.selection_range(0, END)
self.update_model_info(True)
def on_use_proxy_change(self, *args):
if self.use_proxy.get():
self.cb_proxy.config(state=NORMAL)
self.cb_proxy.focus_set()
self.cb_proxy.selection_range(0, END)
else:
self.cb_proxy.config(state=DISABLED)
def toggle_image(self):
if self.show_image:
self.model_image = None
self.image_label.config(image=None)
self.img_url = None
self.image_label.grid_forget()
self.show_image = False
else:
self.show_image = True
self.image_label.grid(row=0,
column=0,
columnspan=5,
sticky=W + E,
padx=PAD,
pady=PAD)
self.update_model_info(True)
def show_full_history(self, period):
if self.hist_window is not None:
self.hist_window.on_close()
self.hist_window = HistoryWindow(self, Toplevel(root),
load_hist_dict(period))
def back_in_history(self):
if len(self.hist_stack) == 0:
return
self.cb_model.set(self.hist_stack.pop())
self.update_model_info(False)
def load_proxy_dict(self):
for file in os.listdir(LOGS):
if not file.startswith('proxy_'):
continue
full_path = os.path.join(LOGS, file)
if os.path.getsize(full_path) == 0:
continue
with open(full_path) as f:
for line in f.readlines():
name = line.strip()
count = self.proxy_dict.get(name, 0)
self.proxy_dict[name] = count + 1
hist = sorted(self.proxy_dict.items(),
key=lambda x: x[1],
reverse=True)
self.cb_proxy.configure(values=[x[0] for x in hist[:10]])
class Home:
"""This is the class which makes the app grid screen - If you log in with
correct password"""
AFTER = None
def __init__(self, a=""):
global truth
global background
global home
global welcome_screen
self.time1 = ""
self.a = a
home = Tk()
home.title("Home")
home.geometry(WINDOW_DIM)
home.resizable(False, False)
home.config(bg=background)
home.lift()
home.attributes("-topmost", True)
self.clock = Label(
home,
font=("TIMES NEW ROMAN", 10),
anchor="e",
bg="black",
fg="white",
width=46,
height=2,
) # clock label
self.clock.place(x=0, y=0)
self.tick1()
wel1 = Label(
home,
text="Here are your apps",
bg="black",
fg="white",
width=46,
height=1,
font=("century", 9),
)
wel1.place(x=-23, y=45)
if self.a == "y":
truth = False
welcome_screen.after_cancel(tick)
welcome_screen.destroy()
welcome_screen = None
else:
pass
"""App buttons"""
sett = Button(
home,
text="Settings",
height=5,
bg="sky blue",
fg="brown",
width=10,
font=("Bahnschrift", 12),
command=self.settings,
) # settings button
sett.place(x=2, y=100)
calcbtn = Button(
home,
text="Calculator",
height=5,
width=10,
bg="grey",
fg="black",
font=("Bahnschrift", 12),
command=self.calc,
) # calculator button
calcbtn.place(x=112, y=100)
design = Button(
home,
text="Designs",
height=5,
width=10,
bg="purple",
fg="cyan",
font=("Bahnschrift", 12),
command=self.design,
) # design button
design.place(x=222, y=100)
notepad = Button(
home,
text="Notepad",
height=5,
width=10,
bg="orange",
fg="black",
font=("Bahnschrift", 12),
command=self.notepad,
) # notepad button
notepad.place(x=2, y=250)
click = Button(
home,
text="Click \n Game",
height=5,
width=10,
bg="blue",
fg="pink",
font=("Bahnschrift", 12),
command=self.click_game,
) # click test button
click.place(x=112, y=250)
sample = Button(
home,
text="Sample \n Pictures",
height=5,
width=10,
bg="red",
fg="yellow",
font=("Bahnschrift", 12),
command=self.sample,
) # sample pictures button
sample.place(x=222, y=250)
lock = Button(
home, text="LOCK", bg="black", fg="yellow", command=welcome
) # lock button
lock.place(x=143, y=368)
home.mainloop()
def tick1(self):
"""Clock"""
global home
time2 = strftime("%H:%M")
newday = time2.split(":")
if newday[0] == "00" and newday[1] == "00":
self.ddate = asctime().split()
self.day = (
self.ddate[0] + " " + self.ddate[1] + " " + self.ddate[2]
)
if time2 != self.time1:
self.time1 = time2
self.clock.config(text=day + " " + time2 + " ")
try:
Home.AFTER = home.after(200, self.tick1)
except Exception:
home.after_cancel(Home.AFTER)
self.ddate = asctime().split()
self.day = self.ddate[0] + " " + self.ddate[1] + " " + self.ddate[2]
global truth
if truth:
welcome_screen.after_cancel(tick)
def settings(self):
"""Called when Settings button is pressed"""
global background
self.setwin = Tk()
self.setwin.title("Settings")
self.setwin.lift()
self.setwin.attributes("-topmost", True)
self.setwin.geometry(WINDOW_DIM)
self.setwin.resizable(False, False)
self.homebtn = Button(
self.setwin,
text="HOME",
bg="black",
fg="white",
command=self.home_button7,
)
self.homebtn.place(x=140, y=370)
self.setwin.config(bg=background)
global home
home.after_cancel(Home.AFTER)
home.destroy()
self.ss = Label(
self.setwin,
text="Choose a setting:",
bg="black",
fg="white",
width=46,
height=2,
font=("Arial", 15),
)
self.ss.place(x=-90, y=0)
self.changingbtn = Button(
self.setwin,
text="Change Password",
height=1,
bg="sky blue",
fg="brown",
width=25,
font=("Bahnschrift", 12),
command=self.change_password,
)
self.changingbtn.place(x=45, y=100)
self.var = StringVar(self.setwin)
self.var.set(background)
self.bglab = Label(
self.setwin,
text="Background colour:",
bg=background,
fg="black",
font=("Arial", 10),
)
self.bglab.place(x=100, y=178)
self.option = OptionMenu(
self.setwin,
self.var,
"yellow",
"green",
"light blue",
"pink",
"white",
)
self.option.place(x=120, y=200)
background = self.var.get()
def save1():
global background
background = self.var.get()
with open("data/background.txt", "w") as file:
file.write(background)
self.sv = Button(
self.setwin, text="Save", command=save1, bg="cyan", fg="black"
)
self.sv.place(x=140, y=235)
"""NOT WORKING ON SOME DEVICES"""
def click_game(self):
"""Calls when click button is pressed"""
global background
self.clickwin = Tk()
self.clickwin.title("Click Game")
self.clickwin.lift()
self.clickwin.attributes("-topmost", True)
self.clickwin.geometry(WINDOW_DIM)
self.clickwin.resizable(False, False)
self.n = 0
self.clickwin.config(bg="cyan")
self.w = Label(self.clickwin, text="CLICK TEST!")
self.w.config(bg="black", fg="white", font=("broadway", 30))
self.w.pack(side=TOP)
self.bt2 = Button(
self.clickwin,
text="Start timer",
height="3",
width="8",
command=self.timer,
)
self.bt2.config(bg="red")
self.bt2.pack()
self.tt = Label(self.clickwin)
self.tt.pack()
self.bt = Button(
self.clickwin,
text="CLICK!",
height="10",
width="20",
state=DISABLED,
command=self.number,
)
self.bt.config(bg="yellow")
self.bt.pack()
self.ans = Label(self.clickwin)
self.ans.pack()
self.res = Label(
self.clickwin, text=" "
)
self.res.config(
bg="dark green", fg=background, font=("arial narrow", 15)
)
self.res.pack()
self.bt3 = Button(
self.clickwin,
text="Reset",
height="5",
width="8",
command=self.reset,
)
self.bt3.pack(side=RIGHT)
global home
home.after_cancel(Home.AFTER)
home.destroy()
self.homebtn = Button(
self.clickwin,
text="HOME",
bg="black",
fg="white",
command=self.home_button4,
)
self.homebtn.place(x=140, y=370)
self.clickwin.mainloop()
def timer(self):
self.bt2.config(state=DISABLED)
self.homebtn.config(state=DISABLED)
self.bt3.config(state=DISABLED)
self.bt.config(state="normal")
self.func1()
def number(self):
self.n += 1
self.ans.config(text=self.n)
def reset(self):
self.homebtn.config(state="normal")
self.bt2.config(state="normal")
self.bt.config(state=DISABLED)
self.res["text"] = " "
self.ans.config(text="0")
self.n = 0
self.tt.config(text="Reset")
def func1(self):
# try:
self.t = threading.Thread(target=self.func2)
self.t.start()
# except:
# pass
def func2(self):
for i in range(0, 10):
self.tt.config(text=10 - i)
sleep(1)
self.bt.config(state=DISABLED)
self.tt.config(text="Time up")
self.bt3.config(state="normal")
if self.n < 50:
self.res["text"] = (
str(self.n) + " clicks in 10 seconds: Bad clicker!"
)
elif 50 <= self.n and self.n < 60:
self.res["text"] = (
str(self.n) + " clicks in 10 seconds: Average clicker!"
)
elif self.n >= 60 and self.n < 70:
self.res["text"] = (
str(self.n) + " clicks in 10 seconds: Master clicker!"
)
elif self.n >= 70:
self.res["text"] = (
str(self.n) + " clicks in 10 seconds: Clicking god!"
)
def notepad(self):
"""Called when notepad button is pressed"""
global background
self.notepad = Tk()
self.notepad.title("Notepad")
f = open("data/notes.txt", "r+")
t = f.read()
self.notepad.lift()
self.notepad.attributes("-topmost", True)
self.notepad.geometry(WINDOW_DIM)
self.notepad.resizable(False, False)
self.notepad.config(bg="purple")
global home
home.after_cancel(Home.AFTER)
home.destroy()
self.homebtn = Button(
self.notepad,
text="HOME",
bg="black",
fg="white",
command=self.home_button3,
)
self.homebtn.place(x=140, y=370)
self.notes = Text(
self.notepad, width=53, height=18, font=("Times New Roman", 10)
)
self.notes.place(x=1, y=60)
self.notes.insert(END, t)
self.head = Label(
self.notepad,
text="NOTEPAD",
bg=background,
width=23,
fg="purple",
font=("Arial black", 15),
)
self.head.place(x=0, y=10)
self.sav = Button(self.notepad, text="Save", command=self.save)
self.sav.place(x=146, y=340)
def save(self):
self.text = self.notes.get(0.0, END)
with open("data/notes.txt", "w") as file:
file.write(self.text)
def sample(self):
"""Called when Sample pictures button is pressed"""
global background
global home
home.after_cancel(Home.AFTER)
home.destroy()
self.samwin = Tk()
self.samwin.title("Sample Pictures")
self.samwin.lift()
self.samwin.attributes("-topmost", True)
self.samwin.geometry(WINDOW_DIM)
self.samwin.resizable(False, False)
self.samwin.config(bg="black")
self.homebtn = Button(
self.samwin,
text="HOME",
bg="white",
fg="black",
command=self.home_button6,
)
self.homebtn.place(x=140, y=370)
self.img = PhotoImage(file="sample_pictures/sample1.gif")
self.pics = Label(
self.samwin, width=325, image=self.img, bg="black", height=300
)
self.pics.place(x=0, y=0)
self.nxt = Button(
self.samwin,
text=">",
bg="yellow",
font=("Bauhaus 93", 20),
command=self.nxtfun,
)
self.nxt.place(x=280, y=310)
self.bck = Button(
self.samwin,
text="<",
bg="yellow",
font=("Bauhaus 93", 20),
command=self.bckfun,
state=DISABLED,
)
self.bck.place(x=10, y=310)
self.i = 1
self.samwin.bind("<Left>", self.lkey)
self.samwin.bind("<Right>", self.rkey)
def lkey(self, event):
if self.i != 1:
self.bckfun()
def rkey(self, event):
if self.i != 10:
self.nxtfun()
def nxtfun(self):
self.i += 1
self.bck["state"] = "normal"
if self.i == 1:
self.img = PhotoImage(file="sample_pictures/sample1.gif")
self.bck["state"] = DISABLED
elif self.i == 2:
self.img = PhotoImage(file="sample_pictures/sample2.gif")
elif self.i == 3:
self.img = PhotoImage(file="sample_pictures/sample3.gif")
elif self.i == 4:
self.img = PhotoImage(file="sample_pictures/sample4.gif")
elif self.i == 5:
self.img = PhotoImage(file="sample_pictures/sample5.gif")
elif self.i == 6:
self.img = PhotoImage(file="sample_pictures/sample6.gif")
elif self.i == 7:
self.img = PhotoImage(file="sample_pictures/sample7.gif")
elif self.i == 8:
self.img = PhotoImage(file="sample_pictures/sample8.gif")
elif self.i == 9:
self.img = PhotoImage(file="sample_pictures/sample9.gif")
elif self.i == 10:
self.img = PhotoImage(file="sample_pictures/sample10.gif")
self.nxt["state"] = DISABLED
self.pics["image"] = self.img
def bckfun(self):
self.i -= 1
self.nxt["state"] = "normal"
if self.i == 1:
self.img = PhotoImage(file="sample_pictures/sample1.gif")
self.bck["state"] = DISABLED
elif self.i == 2:
self.img = PhotoImage(file="sample_pictures/sample2.gif")
elif self.i == 3:
self.img = PhotoImage(file="sample_pictures/sample3.gif")
elif self.i == 4:
self.img = PhotoImage(file="sample_pictures/sample4.gif")
elif self.i == 5:
self.img = PhotoImage(file="sample_pictures/sample5.gif")
elif self.i == 6:
self.img = PhotoImage(file="sample_pictures/sample6.gif")
elif self.i == 7:
self.img = PhotoImage(file="sample_pictures/sample7.gif")
elif self.i == 8:
self.img = PhotoImage(file="sample_pictures/sample8.gif")
elif self.i == 9:
self.img = PhotoImage(file="sample_pictures/sample9.gif")
elif self.i == 10:
self.img = PhotoImage(file="sample_pictures/sample10.gif")
self.nxt["state"] = DISABLED
self.pics["image"] = self.img
def design(self):
"""Called when Designs button is pressed"""
self.deswin = Tk()
self.deswin.title("Designs")
self.deswin.lift()
self.deswin.attributes("-topmost", True)
self.deswin.geometry(WINDOW_DIM)
self.deswin.resizable(False, False)
self.deswin.config(bg="black")
global home
home.after_cancel(Home.AFTER)
home.destroy()
self.homebtn = Button(
self.deswin,
text="HOME",
bg="white",
fg="black",
command=self.home_button2,
)
self.homebtn.place(x=140, y=370)
self.choo = Label(
self.deswin,
text="Choose a design:",
bg="black",
fg="white",
width=28,
height=2,
font=("Candara", 15),
)
self.choo.place(x=0, y=10)
self.des1 = Button(
self.deswin,
text="Design 1 ",
font=("Elephant", 20),
command=self.des1,
)
self.des1.place(x=80, y=80)
self.des2 = Button(
self.deswin,
text="Design 2",
font=("Elephant", 20),
command=self.des2,
)
self.des2.place(x=80, y=150)
self.des3 = Button(
self.deswin,
text="Design 3",
font=("Elephant", 20),
command=self.des3,
)
self.des3.place(x=80, y=220)
self.des4 = Button(
self.deswin,
text="Design 4",
font=("Elephant", 20),
command=self.des4,
)
self.des4.place(x=80, y=290)
def des1(self):
self.deswin.destroy()
self.deswin = Tk()
self.deswin.title("Designs")
self.deswin.lift()
self.deswin.attributes("-topmost", True)
self.deswin.geometry(WINDOW_DIM)
self.deswin.config(bg="yellow")
self.deswin.resizable(False, False)
self.homebtn = Button(
self.deswin,
text="HOME",
bg="black",
fg="white",
command=self.home_button2,
)
self.homebtn.place(x=140, y=370)
self.canvas = Canvas(
master=self.deswin, width=325, height=350, bg="black"
)
self.t = turtle.RawTurtle(self.canvas)
self.canvas.place(x=0, y=0)
colors = ["red", "purple", "blue", "green", "yellow", "orange"]
self.t.speed(0)
for x in range(160):
self.t.pencolor(colors[x % 6])
self.t.width(x / 100 + 1)
self.t.forward(x)
self.t.left(59)
def des2(self):
self.deswin.destroy()
self.deswin = Tk()
self.deswin.title("Designs")
self.deswin.lift()
self.deswin.attributes("-topmost", True)
self.deswin.geometry(WINDOW_DIM)
self.deswin.resizable(False, False)
self.deswin.config(bg="yellow")
self.homebtn = Button(
self.deswin,
text="HOME",
bg="black",
fg="white",
command=self.home_button2,
)
self.homebtn.place(x=140, y=370)
self.canvas = Canvas(
master=self.deswin, width=325, height=350, bg="black"
)
self.t = turtle.RawTurtle(self.canvas)
self.canvas.place(x=0, y=0)
for i in range(0, 24):
self.t.speed(-9)
self.t.right(46)
self.t.pencolor("blue")
self.t.circle(30)
self.t.right(20)
self.t.pencolor("green")
self.t.circle(60)
self.t.circle(70)
self.t.pencolor("red")
self.t.circle(55)
self.t.circle(57)
self.t.left(10)
self.t.pencolor("yellow")
self.t.right(5)
def des3(self):
self.deswin.destroy()
self.deswin = Tk()
self.deswin.title("Designs")
self.deswin.lift()
self.deswin.attributes("-topmost", True)
self.deswin.geometry(WINDOW_DIM)
self.deswin.resizable(False, False)
self.deswin.config(bg="yellow")
self.homebtn = Button(
self.deswin,
text="HOME",
bg="black",
fg="white",
command=self.home_button2,
)
self.homebtn.place(x=140, y=370)
self.canvas = Canvas(
master=self.deswin, width=325, height=350, bg="black"
)
self.t = turtle.RawTurtle(self.canvas)
self.canvas.place(x=0, y=0)
for i in range(50):
self.t.speed(20)
self.t.pencolor("red")
self.t.backward(100)
self.t.pencolor("green")
self.t.circle(30)
self.t.right(70)
def des4(self):
self.deswin.destroy()
self.deswin = Tk()
self.deswin.title("Designs")
self.deswin.lift()
self.deswin.attributes("-topmost", True)
self.deswin.geometry(WINDOW_DIM)
self.deswin.resizable(False, False)
self.deswin.config(bg="yellow")
self.homebtn = Button(
self.deswin,
text="HOME",
bg="black",
fg="white",
command=self.home_button2,
)
self.homebtn.place(x=140, y=370)
self.canvas = Canvas(
master=self.deswin, width=325, height=350, bg="black"
)
self.t = turtle.RawTurtle(self.canvas)
self.canvas.place(x=0, y=0)
self.t.speed(700)
for i in range(180):
self.t.forward(80)
self.t.right(30)
self.t.forward(20)
self.t.left(60)
self.t.forward(50)
self.t.right(30)
self.t.penup()
self.t.setposition(0, 0)
self.t.pendown()
self.t.right(2)
def calc(self):
"""Called when Calculator button is pressed"""
try:
global background
self.calcwin = Tk()
self.calcwin.title("Calculator")
self.calcwin.lift()
self.calcwin.attributes("-topmost", True)
self.calcwin.geometry(WINDOW_DIM)
self.calcwin.resizable(False, False)
self.calcwin.config(bg=background)
global home
home.after_cancel(Home.AFTER)
home.destroy()
self.homebtn = Button(
self.calcwin,
text="HOME",
bg="black",
fg="white",
command=self.home_button1,
)
self.homebtn.place(x=140, y=370)
self.num = Entry(self.calcwin, width=18, font=("Arial black", 20))
self.num.place(x=0, y=10)
self.num.focus_set()
self.ans = Label(
self.calcwin,
bg="light green",
width=17,
fg="black",
font=("Arial black", 20),
)
self.ans.place(x=0, y=60)
self.plus_btn = Button(
self.calcwin,
text="+",
font=("Elephant", 20),
command=self.plus,
)
self.plus_btn.config(width=3)
self.plus_btn.place(x=0, y=120)
self.calcwin.bind("+", self.plus)
self.minus_btn = Button(
self.calcwin,
text="-",
font=("Elephant", 20),
command=self.minus,
)
self.minus_btn.config(width=3)
self.minus_btn.place(x=85, y=120)
self.calcwin.bind("-", self.minus)
self.mult_btn = Button(
self.calcwin,
text="x",
font=("Elephant", 20),
command=self.mult,
)
self.mult_btn.config(width=3)
self.mult_btn.place(x=170, y=120)
self.calcwin.bind("*", self.mult)
self.div_btn = Button(
self.calcwin, text="/", font=("Elephant", 20), command=self.div
)
self.div_btn.config(width=3)
self.div_btn.place(x=255, y=120)
self.calcwin.bind("/", self.div)
self.sqroot_btn = Button(
self.calcwin,
text="sqrt",
font=("Elephant", 20),
command=self.sqroot,
)
self.sqroot_btn.config(height=1, width=3)
self.sqroot_btn.place(x=0, y=200)
self.fact_btn = Button(
self.calcwin,
text="!",
font=("Elephant", 20),
command=self.fact,
)
self.fact_btn.config(width=3)
self.fact_btn.place(x=85, y=200)
self.calcwin.bind("!", self.fact)
self.power_btn = Button(
self.calcwin,
text="x^y",
font=("Elephant", 20),
command=self.power,
)
self.power_btn.config(height=1, width=3)
self.power_btn.place(x=170, y=200)
self.calcwin.bind("^", self.power)
self.clr_btn = Button(
self.calcwin, text="C", font=("Elephant", 20), command=self.c
)
self.clr_btn.config(height=1, width=3)
self.clr_btn.place(x=255, y=200)
self.calcwin.bind("<Delete>", self.c)
self.calcwin.bind("c", self.c)
self.sin_btn = Button(
self.calcwin,
text="sin",
font=("Elephant", 20),
command=self.sin,
)
self.sin_btn.config(height=1, width=3)
self.sin_btn.place(x=0, y=280)
self.cos_btn = Button(
self.calcwin,
text="cos",
font=("Elephant", 20),
command=self.cos,
)
self.cos_btn.config(height=1, width=3)
self.cos_btn.place(x=85, y=280)
self.tan_btn = Button(
self.calcwin,
text="tan",
font=("Elephant", 20),
command=self.tan,
)
self.tan_btn.config(height=1, width=3)
self.tan_btn.place(x=170, y=280)
self.equal_btn = Button(
self.calcwin,
text="=",
font=("Elephant", 20),
command=self.equal,
)
self.equal_btn.config(width=3)
self.equal_btn.place(x=255, y=280)
self.calcwin.bind("<Return>", self.equal)
except TypeError:
self.ans["text"] = "Invalid Input "
except ValueError:
self.ans["text"] = "Invalid Input "
except OverflowError:
self.ans["text"] = "Out of range"
try:
def plus(self, event=None):
self.v = self.num.get()
if "+" in self.v:
self.a = self.v[:-1]
else:
self.a = self.v
self.num.delete(0, END)
self.num.focus_set()
self.operator = "+"
def minus(self, event=None):
self.v = self.num.get()
if "-" in self.v:
self.a = self.v[:-1]
else:
self.a = self.v
self.num.delete(0, END)
self.num.focus_set()
self.operator = "-"
def mult(self, event=None):
self.v = self.num.get()
if "*" in self.v:
self.a = self.v[:-1]
else:
self.a = self.v
self.num.delete(0, END)
self.num.focus_set()
self.operator = "x"
def div(self, event=None):
self.v = self.num.get()
if "/" in self.v:
self.a = self.v[:-1]
else:
self.a = self.v
self.num.delete(0, END)
self.num.focus_set()
self.operator = "/"
def sqroot(self):
try:
self.a = self.num.get()
if float(self.a) >= 0:
self.ans["text"] = math.sqrt(float(self.a))
else:
self.ans["text"] = "Not a real number"
except ValueError:
self.ans["text"] = "Invalid Input "
except TypeError:
self.ans["text"] = "Invalid Input "
except OverflowError:
self.ans["text"] = "Out of range"
def fact(self, event=None):
try:
self.v = self.num.get()
if "!" in self.v:
self.a = self.v[:-1]
else:
self.a = self.v
if int(self.a) >= 0:
self.an = str(math.factorial(int(self.a)))
self.ans["text"] = self.an
if len(self.an) > 17:
self.ans["text"] = "Out of Range"
else:
self.ans["text"] = "Error"
except ValueError:
self.ans["text"] = "Invalid Input "
except TypeError:
self.ans["text"] = "Invalid Input "
except OverflowError:
self.ans["text"] = "Out of range"
def power(self, event=None):
self.v = self.num.get()
if "^" in self.v:
self.a = self.v[:-1]
else:
self.a = self.v
self.num.delete(0, END)
self.num.focus_set()
self.operator = "^"
def sin(self):
try:
self.a = self.num.get()
self.a = float(self.a) / 57.2958
self.an = str(math.sin(float(self.a)))
self.ans["text"] = self.an
if len(self.an) > 17:
self.ans["text"] = "Out of Range"
except ValueError:
self.ans["text"] = "Invalid Input "
except TypeError:
self.ans["text"] = "Invalid Input "
except OverflowError:
self.ans["text"] = "Out of range"
def cos(self):
try:
self.a = self.num.get()
self.a = float(self.a) / 57.2958
self.an = str(math.cos(float(self.a)))
self.ans["text"] = self.an
if len(self.an) > 17:
self.ans["text"] = "Out of Range"
except ValueError:
self.ans["text"] = "Invalid Input "
except TypeError:
self.ans["text"] = "Invalid Input "
except OverflowError:
self.ans["text"] = "Out of range"
def tan(self):
try:
self.a = self.num.get()
self.a = float(self.a) / 57.2958
self.an = str(math.tan(float(self.a)))
self.ans["text"] = self.an
if len(self.an) > 17:
self.ans["text"] = "Out of Range"
except ValueError:
self.ans["text"] = "Invalid Input "
except TypeError:
self.ans["text"] = "Invalid Input "
except OverflowError:
self.ans["text"] = "Out of range"
def c(self, event=None):
"""clear button for calculator"""
self.a = 0
self.b = 0
self.num.delete(0, END)
self.ans["text"] = ""
def equal(self, event=None):
try:
self.b = self.num.get()
if self.operator == "+":
self.an = str(float(self.a) + float(self.b))
if len(self.an) < 17:
self.ans["text"] = self.an
else:
self.ans["text"] = "Out of Range"
elif self.operator == "-":
self.an = str(float(self.a) - float(self.b))
if len(self.an) < 17:
self.ans["text"] = self.an
else:
self.ans["text"] = "Out of Range"
elif self.operator == "x":
self.an = str(float(self.a) * float(self.b))
if len(self.an) < 17:
self.ans["text"] = self.an
else:
self.ans["text"] = "Out of Range"
elif self.operator == "^":
self.an = str(math.pow(float(self.a), float(self.b)))
if len(self.an) < 17:
self.ans["text"] = self.an
else:
self.ans["text"] = "Out of Range"
elif self.operator == "/":
if float(self.b) != 0:
self.an = str(float(self.a) / float(self.b))
if len(self.an) < 17:
self.ans["text"] = self.an
else:
self.ans["text"] = "Out of Range"
else:
self.ans["text"] = "Not a number"
except ValueError:
self.ans["text"] = "Invalid Input "
except TypeError:
self.ans["text"] = "Invalid Input "
except OverflowError:
self.ans["text"] = "Out of range"
except ValueError as e:
self.ans["text"] = "Invalid Input " + e.message
except TypeError as e:
self.ans["text"] = "Invalid Input " + e.message
except OverflowError:
self.ans["text"] = "Out of range"
def next(self):
"""Changing password"""
global password
if self.co == 1:
self.next["text"] = "Next"
self.prev = self.ent.get()
self.k["text"] = " "
if self.prev == password:
self.co = 2
self.f = open("data/password.txt", "r+")
self.ent.delete(0, END)
self.ent.focus_set()
self.lb["text"] = "Enter new password:"******"text"] = "Incorrect password, cannot change."
self.k.place(x=0, y=260)
self.next["text"] = "Retry"
self.lb["text"] = "Enter previous password:"******"text"] = "Confirm new password:"******"data/password.txt", "wb")
self.f.write(base64.b64encode(self.confirm.encode()))
self.f.close()
self.ent.delete(0, END)
password = self.confirm
self.lb["text"] = "Password changed!"
self.k["text"] = "Password changed!"
self.co = 1
else:
self.k["text"] = "Passwords do not match, try again."
self.k.place(x=0, y=260)
self.next["text"] = "Retry"
self.lb["text"] = "Enter previous password:"******"""Called when Change password button is pressed"""
global password
self.passwin = Tk()
self.passwin.title("Settings")
self.passwin.lift()
self.passwin.attributes("-topmost", True)
self.passwin.geometry(WINDOW_DIM)
self.passwin.resizable(False, False)
self.passwin.config(bg="light green")
self.setwin.destroy()
self.homebtn = Button(
self.passwin,
text="HOME",
bg="black",
fg="white",
command=self.home_button5,
)
self.homebtn.place(x=140, y=370)
self.ent = Entry(
self.passwin, show="*", width=18, font=("Arial black", 20)
)
self.ent.place(x=0, y=100)
self.next = Button(
self.passwin,
text="Next",
bg="blue",
fg="yellow",
command=self.next,
)
self.next.place(x=100, y=200)
self.next.config(width=15)
self.lb = Label(
self.passwin,
bg="light green",
text="Enter previous password:"******"Georgia", 12),
width=30,
)
self.lb.place(x=20, y=70)
self.k = Label(
self.passwin,
text="",
bg="red",
fg="pink",
font=("Onyx", 20),
width=40,
)
self.k.place(x=0, y=260)
self.show = Button(
self.passwin,
text="Show",
bg="blue",
fg="yellow",
command=self.show,
)
self.show.place(x=100, y=150)
self.show.config(width=15)
self.co = 1
self.sh = False
def show(self):
if not self.sh:
self.ent["show"] = ""
self.sh = True
self.show.config(text="Hide")
elif not self.sh:
self.ent["show"] = "*"
self.sh = False
self.show.config(text="Show")
def home_button1(self):
"""Home buttons for all screens"""
global home_screen # home button for calculator
self.calcwin.destroy()
home_screen = Home()
def home_button2(self):
global home_screen # home button for design window
self.deswin.destroy()
home_screen = Home()
def home_button3(self):
global home_screen # home button for notepad window
self.notepad.destroy()
home_screen = Home()
def home_button4(self):
global home_screen # home button for click game window
self.clickwin.destroy()
home_screen = Home()
def home_button5(self):
global home_screen # home button for password change window
self.passwin.destroy()
home_screen = Home()
def home_button6(self):
global home_screen # home button for sample pictures window
self.samwin.destroy()
home_screen = Home()
def home_button7(self):
global home_screen # home button for settings window
self.setwin.destroy()
home_screen = Home()
class NumberConverterMasterFrame(Frame):
def __init__(self, root):
Frame.__init__(self, root)
root.title("SeqPilot Order Number Fixer")
self.parent = root
self.initialize()
# Initialize GUI elements
def initialize(self):
print('Setting up the GUI')
# This is the directory the python executable is running from.
FileAndPath = abspath(__file__)
self.idir, self.ifile = split(FileAndPath)
# GUI options
#self.label_opt = {'fill': Tkconstants.BOTH, 'padx': 10, 'pady': 10}
self.button_opt = {'fill': BOTH, 'padx': 50, 'pady': 15}
# "Choose Directory" options change for windows and linux. In windows we want to default
# to the swisslab directory.
if (self.getPlatform() == 'Windows'):
self.dir_opt = {
'initialdir': "Z:\\bin\\TalkMaster\\Output\\Swisslab",
'mustexist': True,
'parent': self,
'title': 'Choose a directory'
}
else:
self.dir_opt = {
'initialdir': "/home",
'mustexist': True,
'parent': self,
'title': 'Choose a directory'
}
self.directoryFrame = self.makeDirectoryFrame()
self.directoryFrame.pack()
self.sampleFileFrame = self.makeSampleFileFrame()
self.sampleFileFrame.pack()
self.idChooserFrame = self.makeidChooserFrame()
self.idChooserFrame.pack()
self.pack()
def makeDirectoryFrame(self):
print('Setting up the directory Frame')
chooseDirectoryFrame = Frame(self)
self.chooseInputButton = Button(chooseDirectoryFrame,
text='Kies Invoer Map',
command=self.chooseInputDirectory)
self.chooseInputButton.grid(row=0, column=0, sticky=W)
#self.chooseOutputButton = Button(chooseDirectoryFrame, text='Choose Output Directory',
# command=self.chooseReadOutputDirectory)
#self.chooseOutputButton.grid(row=1, column=0, sticky=W)
self.outputDirLabel = Label(chooseDirectoryFrame, text="Output Map:")
self.outputDirLabel.grid(row=1, column=0)
self.inputDirectoryText = StringVar()
self.inputDirectoryText.set('Waar zitten de bestanden?')
Entry(chooseDirectoryFrame,
width=80,
textvariable=self.inputDirectoryText).grid(row=0, column=1)
self.outputDirectoryText = StringVar()
self.outputDirectoryText.set('Output Map')
Entry(chooseDirectoryFrame,
width=80,
textvariable=self.outputDirectoryText).grid(row=1, column=1)
#self.outputDirEntry.config(state=DISABLED)
return chooseDirectoryFrame
def makeSampleFileFrame(self):
print('Setting up the directory Frame')
sampleFileFrame = Frame(self)
self.fileFoundLabelText = StringVar()
self.fileFoundLabelText.set("Kies een map.")
self.fileFoundLabel = Label(sampleFileFrame,
textvariable=self.fileFoundLabelText)
self.fileFoundLabel.pack()
return sampleFileFrame
def makeidChooserFrame(self):
print('Setting up the directory Frame')
idChooserFrame = Frame(self)
self.changeIDButton = Button(idChooserFrame,
text='Verander ID in:',
command=self.changeID,
state=DISABLED)
self.changeIDButton.grid(row=0, column=0, sticky=W)
self.newIDEntryText = StringVar()
self.newIDEntryText.trace_add("write", self.changeNewIDMethod)
self.newIDEntryText.set(
'new_id'
) # Underscores arent allowed, but the callback should change this to "-"
Entry(idChooserFrame, width=50,
textvariable=self.newIDEntryText).grid(row=0, column=1)
self.skipFileButton = Button(idChooserFrame,
text='Bestand Overslaan: ',
command=self.skipFile,
state=DISABLED)
self.skipFileButton.grid(row=1, column=0, sticky=W)
self.stopButton = Button(idChooserFrame,
text='Stoppen.',
command=self.skipAllFiles,
state=DISABLED)
self.stopButton.grid(row=1, column=1, sticky=W)
return idChooserFrame
def changeNewIDMethod(self, *args):
# This method triggers when the new ID changes.
# might be hand-typed or come from input from the barcode scanner.
# Either way we should never allow underscores in the ID. Change "_" to "-"
# *args are 3 parameters about who sent the callback. Not really important to me.
#print('These args passed into the callback: ' + str(args))
self.newIDEntryText.set(self.newIDEntryText.get().replace("_", '-'))
# I borrowed this code from:
# https://www.webucator.com/how-to/how-check-the-operating-system-with-python.cfm
# Thanks Nat Dunn.
def getPlatform(self):
platforms = {
'linux1': 'Linux',
'linux2': 'Linux',
'darwin': 'OS X',
'win32': 'Windows'
}
if sys.platform not in platforms:
return sys.platform
return platforms[sys.platform]
# chooseInputDirectory method is called when the user presses the input directory button
def chooseInputDirectory(self):
print('Choosing an input directory.')
# File Dialog to get the new directory
currentInputDirectory = filedialog.askdirectory(**self.dir_opt)
# askdirectory returns an empty tuple when it fails. Why? that seems dumb. String when successful.
if (currentInputDirectory == "" or currentInputDirectory == None
or currentInputDirectory == ()):
print(
"Directory was not found, maybe you closed the window too early?"
)
else:
# Set the text object to new dir
self.inputDirectoryText.set(normpath(currentInputDirectory))
self.fileList = listdir(currentInputDirectory)
self.currentFileIndex = 0
print('These files found:' + str(self.fileList))
# Parse the path to generate the output directory.
parentDir = abspath(join(currentInputDirectory, pardir))
leafDirName = basename(normpath(currentInputDirectory))
todaysDate = datetime.date.today().strftime('%Y%m%d')
# print ('todays date is: ' + str(todaysDate))
currentOutputDirectory = join(
parentDir, leafDirName + '_' + str(todaysDate) + '_fixed')
self.outputDirectoryText.set(currentOutputDirectory)
# If there are files in this directory
if (len(self.fileList) > 0):
# This output directory should exist
if not exists(currentOutputDirectory):
makedirs(currentOutputDirectory)
# Change the GUI to not allow us to change the directory. Enable the ID buttons.
self.chooseInputButton.config(state=DISABLED)
# Present a file to the user.
self.presentAFile()
else:
messagebox.showwarning(
"No Files????",
"There are no files in that directory. Try again.")
def presentAFile(self):
# Files Remaining? Nah I don't need to check i think.
# Open File
currentFile = self.fileList[self.currentFileIndex]
currentFileFullPath = join(self.inputDirectoryText.get(), currentFile)
with open(currentFileFullPath, 'r') as f:
#reader = csv.reader(f, delimiter='\t')
line = next(f)
lineTokens = line.split('\t')
# Get ID, it's the 2nd entry in a tab delimited file.
self.oldSampleID = lineTokens[1]
print('I found this sampleid:' + str(self.oldSampleID))
# Update Label with Instructions. Filename, ID number.
self.fileFoundLabelText.set("(" + str(self.currentFileIndex + 1) +
"/" + str(len(self.fileList)) + ") " +
str(currentFile) + "\n" + "heeft ID " +
str(self.oldSampleID) + "\n" +
"Fix ID of Overslaan?")
self.changeIDButton.config(state=NORMAL)
self.skipFileButton.config(state=NORMAL)
self.stopButton.config(state=NORMAL)
# Update Suggested new ID number.
self.newIDEntryText.set(self.oldSampleID)
def changeID(self):
print('Changing the ID')
# Open Input File
currentFileFullPath = join(self.inputDirectoryText.get(),
self.fileList[self.currentFileIndex])
outputFileName = join(self.outputDirectoryText.get(),
self.fileList[self.currentFileIndex])
outputFile = createOutputFile(outputFileName)
newSampleID = self.newIDEntryText.get()
print('Replacing old id ' + str(self.oldSampleID) + ' with new id ' +
str(newSampleID))
with open(currentFileFullPath, 'r') as f:
for line in f:
newLine = line.replace(self.oldSampleID, newSampleID)
outputFile.write(newLine)
self.nextFilePlease()
def skipFile(self):
print('Skipping the File')
# This method is just copying a file to the output directory.
# Open Input File
currentFileFullPath = join(self.inputDirectoryText.get(),
self.fileList[self.currentFileIndex])
outputFileName = join(self.outputDirectoryText.get(),
self.fileList[self.currentFileIndex])
outputFile = createOutputFile(outputFileName)
with open(currentFileFullPath, 'r') as f:
for line in f:
outputFile.write(line)
self.nextFilePlease()
def skipAllFiles(self):
while (self.currentFileIndex < len(self.fileList)):
self.skipFile()
def nextFilePlease(self):
self.currentFileIndex += 1
# More files Remaining?
# Get the next file in the list.
if (self.currentFileIndex < len(self.fileList)):
self.presentAFile()
# Else? finish up
else:
self.fileFoundLabelText.set("Kies een map.")
self.chooseInputButton.config(state=NORMAL)
self.changeIDButton.config(state=DISABLED)
self.skipFileButton.config(state=DISABLED)
self.stopButton.config(state=DISABLED)
frame2 = Frame(root) frame3 = Frame(root) frame1.grid(column = 0, row = 0) signIn = Label(frame1, text = 'Sign In',fg = 'black',bg = 'tan', font = 'Arial 18 bold', padx =(50)) nameFL = Label(frame2, text = 'Name: ',fg = 'black',bg = 'tan', font = 'Arial 18 bold') password = Label(frame3, text = 'Password: '******'black',bg = 'tan', font = 'Arial 18 bold') entry1 = Entry(root, text='Name', width = 30) entry2 = Entry(root, show='*',text = 'Password', width = 30) frame1.grid(row=0, column = 0) frame2.grid(row=1) frame3.grid(row = 2) signIn.pack(side = 'top') nameFL.pack(side = 'top') entry1.grid(row=1, column = 1) password.pack(side = 'top') entry2.grid(row=2, column = 1) btn1 = Button(root, text='Sign In', command=show) btn1.config(height = 2, width = 20) btn1.grid(row=3,column=1) root.mainloop()
class CalibrationDialog(BeeDialog):
_main_window = None #: tk.Tk
_hive = None #: Hive
_bar = None #: Progressbar
_close_enabled = True
_button_box = None #: Frame
_start_button = None
_calibration = None
_humidity = None
_yes_button = None
_no_button = None
_header = None
_expected_weight_label = None #: : tk.Label
_expected_weight_field = None #: : tk.Entry
_expected_weight_box = None
_weight_display = None
_temp_display = None
def __init__(self, main_window: tk.Tk, hive: Hive):
self._main_window = main_window
self._hive = hive
super().__init__(parent=main_window,
title="Waage kalibrieren",
width=310,
height=120)
def _init_expected_weight_box(self):
self._expected_weight_box = Frame(self)
self._expected_weight_label = Label(self._expected_weight_box,
text='Gewicht (g)',
font=('Arial', 10),
anchor='e',
wraplength=100,
background='#ffffcc')
self._expected_weight_label.grid(column=0, row=0, sticky='e')
self._expected_weight_field = Entry(self._expected_weight_box,
font=('Arial', 8),
width="20")
self._expected_weight_field.grid(column=1, row=0)
def open(self):
pass
def cancel(self, event=None):
if self._close_enabled:
super().cancel(event)
def body(self, master):
self._calibration = HiveCalibration()
self._header = Label(master, text="")
self._bar = Progressbar(master, length=210)
self._init_expected_weight_box()
self._weight_display = Label(master, text="")
self._temp_display = Label(master, text="")
self._prepare_tara()
def _prepare_tara(self):
self._header.config(
text='Drücken Sie "Start" um die Waage\n zu tarieren.')
self._header.pack()
def _standard_buttons(self):
self._button_box = Frame(self)
self._button_box.pack()
self._start_button = Button(self._button_box,
text="Start",
width=10,
command=self._calc_offset,
default=ACTIVE)
self._start_button.pack(side=LEFT, padx=5, pady=5)
w = Button(self._button_box,
text="Abbrechen",
width=10,
command=self.cancel)
w.pack(side=LEFT, padx=5, pady=5)
def _yes_no_buttons(self):
self._yes_no_button_box = Frame(self)
self._yes_button = Button(self._yes_no_button_box,
text="Ja",
width=10,
command=self._satisfied,
default=ACTIVE)
self._yes_button.pack(side=LEFT, padx=5, pady=5)
self._no_button = Button(self._yes_no_button_box,
text="Nein",
width=10,
command=self._not_satisfied)
self._no_button.pack(side=LEFT, padx=5, pady=5)
def init_calc_offset(self):
pass
def _satisfied(self):
DbAccess.update_hive_calibration(self._calibration)
self._close_enabled = True
self.cancel()
def _not_satisfied(self):
self._start_button.config(command=self._calc_offset)
self._calibration = HiveCalibration()
self._yes_no_button_box.pack_forget()
self._temp_display.pack_forget()
self._weight_display.pack_forget()
self._prepare_tara()
self._button_box.pack()
self.update_idletasks()
def buttonbox(self):
self._standard_buttons()
self._yes_no_buttons()
'''add standard button box.
override if you do not want the standard buttons
'''
'''
w = Button(box, text="OK", width=10, command=self.ok, default=ACTIVE)
w.pack(side=LEFT, padx=5, pady=5)
w = Button(box, text="Cancel", width=10, command=self.cancel)
w.pack(side=LEFT, padx=5, pady=5)
self.bind("<Return>", self.ok)
self.bind("<Escape>", self.cancel)
'''
def _progress(self, i, maximum=15):
self._bar['value'] = int(210 / (maximum - i))
self.update_idletasks()
def _calc_reference_unit(self, event=None):
expected_weight_string = self._expected_weight_field.get()
print('calc-reference-unit.expected_weight_string: ',
expected_weight_string)
expected = int(expected_weight_string)
print('calc-reference-unit.expected: ', expected)
self._calibration.entity_id = self._hive.get_id()
self._humidity = None
self._bar['value'] = 0
self._bar.pack()
self.update_idletasks()
try:
self._close_enabled = False
self._button_box.pack_forget()
self._close_enabled = False
self._bar.pack()
self.update_idletasks()
pins = self._hive.get_weight().get_bcm().split(",")
data_pin = pins[0]
clk_pin = pins[1]
print('data_pin ' + data_pin)
print('clk_pin ' + clk_pin)
hx = HX711(int(data_pin), int(clk_pin), gain=128)
hx.set_reading_format("LSB", "MSB")
print('_offset:', self._calibration.offset)
hx.set_offset(self._calibration.offset)
self._calibration.value_per_gram = hx.calc_reference_unit(
lambda i: self._progress(i, 10), expected)
print('reference_unit -> ', self._calibration.value_per_gram)
self._calc_temp()
clean()
self._start_button.config(command=self._check_weight)
self._header.config(
text='Drücken Sie Start um das Gewicht\nzu überprüfen.')
self._button_box.pack()
self._bar.pack_forget()
self._expected_weight_box.pack_forget()
self._weight_display.pack()
self._temp_display.pack()
self.update_idletasks()
self._close_enabled = True
except Exception as e:
print('Error ', e)
clean()
self._calibration.offset = None
self._close_enabled = True
def _calc_temp(self):
temp_sensor = self._hive.get_temperature_outside()
if temp_sensor.get_bcm() == '' or temp_sensor.get_product() == '':
return
if temp_sensor.get_product() == 'DHT22':
self._humidity, self._calibration.temp = dht.read_retry(
dht.DHT22, int(temp_sensor.get_bcm()))
print('Temp={0:0.1f}*C Humidity={1:0.1f}%'.format(
self._calibration.temp, self._humidity))
elif temp_sensor.get_product() == 'DHT11':
self._humidity, self._temp = dht.read_retry(
dht.DHT11, int(temp_sensor.get_bcm()))
print('Temp={0:0.1f}*C Humidity={1:0.1f}%'.format(
self._calibration.temp, self._humidity))
else:
print('Unsupported product ', temp_sensor.get_product())
def _check_weight(self):
try:
self._close_enabled = False
pins = self._hive.get_weight().get_bcm().split(",")
data_pin = pins[0]
clk_pin = pins[1]
hx = HX711(int(data_pin), int(clk_pin), gain=128)
hx.set_reading_format("LSB", "MSB")
print('_reference_unit:', self._calibration.value_per_gram)
hx.set_reference_unit(self._calibration.value_per_gram)
hx.reset()
print('_offset:', self._calibration.offset)
hx.set_offset(self._calibration.offset)
val = hx.get_weight(5)
print('value -> ', val)
self._header.config(text='Sind Sie mit dem Ergebnis\nzufrieden?')
self._weight_display.config(
text=('Gewicht: {0:0.1f}g'.format(val)))
if self._calibration.temp is not None:
self._temp_display.config(
text=('Temp: {0:0.1f}°C'.format(self._calibration.temp)))
else:
self._temp_display.config(text='')
print('reference_unit -> ', self._calibration.value_per_gram)
clean()
self._button_box.pack_forget()
self._yes_no_button_box.pack()
self.update_idletasks()
self._close_enabled = True
except Exception as e:
print('Error ', e)
clean()
self._calibration.offset = None
self._close_enabled = True
def _calc_offset(self, event=None):
self._calibration.offset = None
try:
self._button_box.pack_forget()
self._close_enabled = False
self._bar.pack()
self.update_idletasks()
pins = self._hive.get_weight().get_bcm().split(",")
data_pin = pins[0]
clk_pin = pins[1]
print('data_pin ' + data_pin)
print('clk_pin ' + clk_pin)
hx = HX711(int(data_pin), int(clk_pin), gain=128)
hx.set_reading_format("LSB", "MSB")
self._calibration.offset = hx.calc_offset(
lambda i: self._progress(i))
print('offset -> ', self._calibration.offset)
clean()
self._start_button.config(command=self._calc_reference_unit)
self._header.config(text='Geben Sie ein Gewicht auf die Waage.')
self._expected_weight_box.pack()
self._button_box.pack()
self._bar.pack_forget()
self.update_idletasks()
except Exception as e:
print('Fehler', e)
clean()
self._close_enabled = True
self._calibration.offset = None
class MyGUI():
def __init__(self, probabilityInc, probabilityDec, master):
self.probabilityInc = probabilityInc
self.probabilityDec = probabilityDec
self.master = master
self.button = Button(self.master,
text="Predict Now!",
command=self.predict)
self.restart_button1 = Button(self.master,
text="Reset",
command=self.restart_program)
self.toggle = False
def appOpen(self):
self.master.title("Bitcoin Predictor")
fm = Frame(self.master)
fm.pack()
self.photo = PhotoImage(file="Bitcoin.gif")
self.label12 = Label(fm, image=self.photo)
self.label12.image = self.photo
self.label12.pack(side="top", anchor="n", fill="x", expand="yes")
self.label2 = Label(fm, text=' ').pack(side="top",
anchor="w",
fill="x",
expand="yes")
self.label3 = Label(fm, text=' ').pack(side="top",
anchor="w",
fill="x",
expand="yes")
self.button.pack() #predict button
self.restart_button1.pack() #reRun button
self.restart_button1.config(state="disabled")
#Close Button
self.close_button = Button(self.master,
text="Close",
command=self.master.quit)
self.close_button.pack()
self.im = PIL.Image.open("Graph.png")
self.photo = PIL.ImageTk.PhotoImage(self.im)
self.label12 = Label(self.master, image=self.photo).pack(side="bottom")
fm.pack(fill="both", expand="yes")
##print("probabilityInc, probabilityDec, accumMatch: ", self.probabilityInc,self.probabilityDec ,self.accumMatch)
def predict(self):
if (self.toggle != True):
self.label1 = Label(
self.master,
text="Probability of Increase in the next hour: " +
str(self.probabilityInc)).pack(side="top")
self.label2 = Label(
self.master,
text="Probability of Decrease in the next hour: " +
str(self.probabilityDec)).pack(side="top")
self.toggle = True
self.button.config(state="disabled")
self.restart_button1.config(state="active")
def restart_program(self):
python = sys.executable
os.execl(python, python, *sys.argv)
class Application(tk.Frame):
load_model_btn: Button
save_model_btn: Button
image: Union[Label, Label]
name: str
acc: Union[Label, Label]
loss: Union[Label, Label]
current_epochs: Union[Label, Label]
open_dialog_btn: Union[Button, Button]
predict_frame: Union[Frame, Frame]
train_epochs: Union[Entry, Entry]
train_frame: Union[Frame, Frame]
predict_btn: Button
train_btn: Button
progress_bar: Progressbar
info_label: Union[Label, Label]
num_images: Union[Label, Label]
num_categories: Union[Label, Label]
info_frame: Union[Frame, Frame]
display: Text
download_image_btn: Button
left_frame: Frame
def __init__(self, master=None):
super().__init__(master)
self.master = master
self.classifier = Classifier()
self.left_frame = Frame(master, style="My.TFrame")
self.left_frame.pack(
side=LEFT,
fill=BOTH,
)
# Separator(master, orient=VERTICAL).grid(column=1, row=0, sticky='ns')
self.right_frame = Frame(master)
self.right_frame.pack(side=RIGHT, fill=BOTH, padx=10)
self.create_left()
self.create_right()
def create_left(self):
self.create_download_frame()
self.create_train_frame()
self.create_predict_frame()
self.create_info_frame()
def create_info_frame(self):
self.info_frame = Frame(self.left_frame)
self.info_frame.pack()
info_num_categories = Label(self.info_frame,
text="Number of categories:")
info_num_categories.grid(column=0, row=0, sticky=W)
self.num_categories = Label(self.info_frame,
text=self.classifier.num_categories)
self.num_categories.grid(column=1, row=0)
info_num_images = Label(self.info_frame, text="Number of images:")
info_num_images.grid(column=0, row=1, sticky=W)
self.num_images = Label(self.info_frame,
text=len(self.classifier.image_paths))
self.num_images.grid(column=1, row=1)
# ==== Training ====
label = Label(self.info_frame, text="Epochs:")
label.grid(column=0, row=2, sticky=W)
self.current_epochs = Label(self.info_frame, text=0)
self.current_epochs.grid(column=1, row=2)
label = Label(self.info_frame, text="Acc:")
label.grid(column=0, row=3, sticky=W)
self.acc = Label(self.info_frame, text=0)
self.acc.grid(column=1, row=3)
label = Label(self.info_frame, text="Loss:")
label.grid(column=0, row=4, sticky=W)
self.loss = Label(self.info_frame, text=0)
self.loss.grid(column=1, row=4)
Separator(self.info_frame).grid(row=5, sticky="ew", padx=4)
self.info_label = Label(self.left_frame)
self.info_label.pack(fill=X)
self.progress_bar = Progressbar(self.left_frame,
length=200,
mode="determinate",
orient=HORIZONTAL)
self.progress_bar.pack(fill=X)
self.image = Label(self.left_frame)
self.image.pack(fill=X)
def create_download_frame(self):
self.winfo_toplevel().title("Trainer")
self.download_image_btn = tk.Button(self.left_frame,
text="Download Images",
command=self.download)
self.download_image_btn.pack(fill=X, pady=(20, 10))
self.save_model_btn = tk.Button(self.left_frame,
text="Save Model",
command=self.save,
state=DISABLED)
self.save_model_btn.pack(fill=X, pady=(20, 10))
self.load_model_btn = tk.Button(self.left_frame,
text="Load Model",
command=self.load)
self.load_model_btn.pack(fill=X, pady=(20, 10))
def create_predict_frame(self):
self.predict_frame = Frame(self.left_frame)
self.predict_frame.pack(fill=X, pady=(20, 10))
self.open_dialog_btn = Button(self.predict_frame,
text="Open File",
command=self.openfile,
state=DISABLED)
self.open_dialog_btn.grid(column=0, row=0)
self.predict_btn = tk.Button(self.predict_frame,
text="Predict",
command=self.predict,
state=DISABLED)
self.predict_btn.grid(column=1,
row=0,
padx=5,
sticky='ew',
columnspan=2)
def create_train_frame(self):
self.train_frame = Frame(self.left_frame)
self.train_frame.pack(fill=X, pady=(20, 10))
label = Label(self.train_frame, text="Epochs:")
label.grid(column=1, row=0)
self.train_epochs = Entry(self.train_frame, width=6)
self.train_epochs.grid(column=2, row=0)
self.train_btn = tk.Button(self.train_frame,
text="Train",
command=self.train,
state=DISABLED)
self.train_btn.grid(column=3, row=0, columnspan=2, padx=5)
def create_right(self):
self.display = tk.Text(self.right_frame)
self.display.pack(expand=True, fill=BOTH)
def openfile(self):
name = askopenfilename(filetypes=(("JPG File", "*.jpg"), ("PNG File",
"*.png"),
("BMP File", "*.bmp"), ("All Files",
"*.*")),
title="Choose a file.")
if name and self.classifier.model:
self.predict_btn.config(state=ACTIVE)
self.name = name
def download(self):
t = threading.Thread(target=self.classifier.load_images,
args=(self.download_callback, ))
t.start()
def predict(self):
t = threading.Thread(target=self.classifier.predict,
args=(
self.name,
self.predict_callback,
))
t.start()
def train(self):
epoch = self.train_epochs.get()
if epoch is not None and epoch != "":
for e in epoch:
if e not in "0123456789":
raise ValueError("Value error")
t = threading.Thread(target=self.classifier.train,
args=(int(epoch), self.train_callback))
t.start()
self.train_btn.config(state=DISABLED)
else:
self.display.insert(END, "Epoch value error\n")
def save(self):
self.classifier.save()
self.display.insert(END, "Model has been saved\n")
def load(self):
self.classifier.load()
self.display.insert(END, "Model has been loaded\n")
def train_callback(self,
state: str,
epoch: int = 0,
loss: float = 0,
acc: float = 0):
if state == "start":
self.display.insert(END, "Start training\n")
self.info_label.config(text="Start training")
elif state == "progress":
total_epoch = int(self.train_epochs.get())
progress = ((epoch + 1) / total_epoch) * 100
self.progress_bar['value'] = progress
self.current_epochs.config(text=epoch + 1)
self.acc.config(text='{:.2f}%'.format(100 * acc))
self.loss.config(text=round(loss, 3))
self.display.insert(END, f"Started training on epoch {epoch}\n")
elif state == "end":
self.display.insert(END, "Finished training\n")
self.info_label.config(text="Finished training")
self.train_btn.config(state=ACTIVE)
self.save_model_btn.config(state=ACTIVE)
self.open_dialog_btn.config(state=ACTIVE)
def predict_callback(self, data: dict):
self.display.insert(END, "=====================\n")
print(self.name)
image1 = Image.open(self.name)
image1.thumbnail((200, 200), Image.ANTIALIAS)
photo_img = ImageTk.PhotoImage(image1)
self.image.config(image=photo_img)
self.image.image = photo_img
self.display.insert(
END,
f"Prediction: {data['id']} {data['name']} {round(100 * data['acc'], 4)} %\n",
('important', ))
self.display.insert(END, "=====================\n")
def download_callback(self, label, num_completed, total):
self.info_label.config(text=f"Processing {label}")
progress = ((num_completed + 1) / total) * 100
self.progress_bar['value'] = progress
if progress == 100:
self.display.insert(END, f"{label} finished\n")
self.info_label.config(text=f"{label} finished")
self.train_btn.config(state=ACTIVE)
def interfejs(self):
"""
Funkcja tworzy etykiety obok pól, przyciski i określa obsługę kliknięcia przycisku.
"""
# tworze główną etykiete z tytułem Aplikacji, ustalam kolor tla i czcionki
etykieta1 = Label(self.okno,
text='Automat z napojami',
foreground="white",
background='black')
etykieta1.grid(row=0, column=1, padx=5, pady=5,
sticky=W + S + E + N) # ustalam ułożenie etykiety
etykieta1.config(
font=("Arial", 16,
"italic")) # ustalam rodzaj czcionki i jej wielkość
# tworze etykiete z tytułem Wrzucona kwota, ustalam kolor tla i czcionki
etykieta2 = Label(self.okno,
text='Wrzucona kwota',
foreground="white",
background='black')
etykieta2.grid(row=1, column=0, padx=1, pady=1,
sticky=W + S + E + N) # ustalam ułożenie etykiety
etykieta2.config(
font=("Arial", 13,
"italic")) # ustalam rodzaj czcionki i jej wielkość
# tworze etykiete z tytułem Wybrany numer, ustalam kolor tla i czcionki
etykieta3 = Label(self.okno,
text='Wybrany numer',
foreground="white",
background='black')
etykieta3.grid(row=7, column=0, padx=4,
pady=4) # ustalam ułożenie etykiety
etykieta3.config(
font=("Arial", 13,
"italic")) # ustalam rodzaj czcionki i jej wielkość
# tworze przycisk Zamknij i ustalam obsługe jego kliknięcia
przycisk = Button(self.okno, text="Zamknij", command=self.zamknij)
przycisk.grid(row=22, column=2, padx=4, pady=4,
sticky=E) # ustalam ułożenie przycisku i jego wyrownanie
przycisk.bind(
"<Button-1>", self.zamknij
) # ustalam,że przycisk reaguje na pliknięcie na niego myszką
# ustalam rodzaj czcionki, wielkość oraz kolor przycisku i czcionki
przycisk.config(font=("Arial", 10, "italic"),
background="silver",
foreground='red')
# tworze przycisk Przerwij i ustalam obsługe jego kliknięcia
przycisk0 = Button(self.okno, text="Przerwij", command=self.przerwij)
przycisk0.grid(row=6, column=1, padx=4,
pady=4) # ustalam ułożenie przycisku
przycisk0.bind(
"<Button-1>", self.przerwij
) # ustalam,że przycisk reaguje na pliknięcie na niego myszką
# ustalam rodzaj czcionki i jej wielkość oraz kolor przycisku i czcionki
przycisk0.config(font=("Arial", 12, "italic"),
foreground="black",
background='silver')
# tworze przyciski do wrzucania monet, ustalam obsługe ich kliknięcia, tytuł, rodzaj i wielkosc czcionki
przycisk1 = Button(self.okno,
text="1 gr",
command=lambda: self.wrzucono_monete(1),
font=("Arial", 14, "italic"),
foreground="white",
background='black')
przycisk2 = Button(self.okno,
text="2 gr",
command=lambda: self.wrzucono_monete(2),
font=("Arial", 14, "italic"),
foreground="white",
background='black')
przycisk5 = Button(self.okno,
text="5 gr",
command=lambda: self.wrzucono_monete(5),
font=("Arial", 14, "italic"),
foreground="white",
background='black')
przycisk10 = Button(self.okno,
text="10 gr",
command=lambda: self.wrzucono_monete(10),
font=("Arial", 14, "italic"),
foreground="white",
background='black')
przycisk20 = Button(self.okno,
text="20 gr",
command=lambda: self.wrzucono_monete(20),
font=("Arial", 14, "italic"),
foreground="white",
background='black')
przycisk50 = Button(self.okno,
text="50 gr",
command=lambda: self.wrzucono_monete(50),
font=("Arial", 14, "italic"),
foreground="white",
background='black')
przycisk_1 = Button(self.okno,
text="1 zł",
command=lambda: self.wrzucono_monete(100),
font=("Arial", 14, "italic"),
foreground="white",
background='black')
przycisk_2 = Button(self.okno,
text="2 zł",
command=lambda: self.wrzucono_monete(200),
font=("Arial", 14, "italic"),
foreground="white",
background='black')
przycisk_5 = Button(self.okno,
text="5 zł",
command=lambda: self.wrzucono_monete(500),
font=("Arial", 14, "italic"),
foreground="white",
background='black')
# dodaje przyciski do wrzucania monet do zmiennej klasy Interfejs_automatu przyciski_monety(listy)
przyciski = \
[przycisk1, przycisk2, przycisk5, przycisk10, przycisk20, przycisk50, przycisk_1, przycisk_2, przycisk_5]
self.przyciski_monety = [n for n in przyciski] # list comprehension
# ustalam położenie przycisków i ich rozciagniecie
przycisk1.grid(row=2, column=0, padx=1, pady=1, sticky=W + S + E + N)
przycisk2.grid(row=2, column=1, padx=1, pady=1, sticky=W + S + E + N)
przycisk5.grid(row=2, column=2, padx=1, pady=1, sticky=W + S + E + N)
przycisk10.grid(row=3, column=0, padx=1, pady=1, sticky=W + S + E + N)
przycisk20.grid(row=3, column=1, padx=1, pady=1, sticky=W + S + E + N)
przycisk50.grid(row=3, column=2, padx=1, pady=1, sticky=W + S + E + N)
przycisk_1.grid(row=4, column=0, padx=1, pady=1, sticky=W + S + E + N)
przycisk_2.grid(row=4, column=1, padx=1, pady=1, sticky=W + S + E + N)
przycisk_5.grid(row=4, column=2, padx=1, pady=1, sticky=W + S + E + N)
# tworze przyciski do wyboru numeru produktu i ustalam obsługe ich kliknięcia, tytuł, rodzaj i rozmiar czcionki
przyc1 = Button(self.okno,
text="1",
command=lambda: self.kliknieto_przycisk(1),
font=("Arial", 14, "italic"),
foreground="white",
background='black')
przyc2 = Button(self.okno,
text="2",
command=lambda: self.kliknieto_przycisk(2),
font=("Arial", 14, "italic"),
foreground="white",
background='black')
przyc3 = Button(self.okno,
text="3",
command=lambda: self.kliknieto_przycisk(3),
font=("Arial", 14, "italic"),
foreground="white",
background='black')
przyc4 = Button(self.okno,
text="4",
command=lambda: self.kliknieto_przycisk(4),
font=("Arial", 14, "italic"),
foreground="white",
background='black')
przyc5 = Button(self.okno,
text="5",
command=lambda: self.kliknieto_przycisk(5),
font=("Arial", 14, "italic"),
foreground="white",
background='black')
przyc6 = Button(self.okno,
text="6",
command=lambda: self.kliknieto_przycisk(6),
font=("Arial", 14, "italic"),
foreground="white",
background='black')
przyc7 = Button(self.okno,
text="7",
command=lambda: self.kliknieto_przycisk(7),
font=("Arial", 14, "italic"),
foreground="white",
background='black')
przyc8 = Button(self.okno,
text="8",
command=lambda: self.kliknieto_przycisk(8),
font=("Arial", 14, "italic"),
foreground="white",
background='black')
przyc9 = Button(self.okno,
text="9",
command=lambda: self.kliknieto_przycisk(9),
font=("Arial", 14, "italic"),
foreground="white",
background='black')
przyc0 = Button(self.okno,
text="0",
command=lambda: self.kliknieto_przycisk(0),
font=("Arial", 14, "italic"),
foreground="white",
background='black')
# dodaje przyciski do wyboru numeru produktu do zmiennej klasy Interfejs_automatu pinpad(listy)
przyc = [
przyc1, przyc2, przyc3, przyc4, przyc5, przyc6, przyc7, przyc8,
przyc9, przyc0
]
self.pinpad = [n for n in przyc] # list comprehension
# ustalam położenie przycisków i ich rozciagniecie
przyc1.grid(row=8, column=0, padx=1, pady=1, sticky=W + S + E + N)
przyc2.grid(row=8, column=1, padx=1, pady=1, sticky=W + S + E + N)
przyc3.grid(row=8, column=2, padx=1, pady=1, sticky=W + S + E + N)
przyc4.grid(row=9, column=0, padx=1, pady=1, sticky=W + S + E + N)
przyc5.grid(row=9, column=1, padx=1, pady=1, sticky=W + S + E + N)
przyc6.grid(row=9, column=2, padx=1, pady=1, sticky=W + S + E + N)
przyc7.grid(row=10, column=0, padx=1, pady=1, sticky=W + S + E + N)
przyc8.grid(row=10, column=1, padx=1, pady=1, sticky=W + S + E + N)
przyc9.grid(row=10, column=2, padx=1, pady=1, sticky=W + S + E + N)
przyc0.grid(row=11, column=1, padx=1, pady=1, sticky=W + S + E + N)
ety = Label(self.okno,
text='Napoje') # tworze etykiete z tytułem Napoje
ety.grid(row=13, column=1, padx=5, pady=5) # ustalam ułożenie etykiety
ety.config(
font=("Arial", 15, "italic"),
foreground="white",
background='black'
) # ustalam rodzaj czcionki i jej wielkość, kolor tła i czcionki
# tworze etykiety z numerami produktow i ich nazwami
ety1 = Label(self.okno, text='30:woda gazowana')
ety2 = Label(self.okno, text='31:woda niegazowana')
ety3 = Label(self.okno, text='32:sok pomarańczowy')
ety4 = Label(self.okno, text='33:sok porzeczkowy')
ety5 = Label(self.okno, text='34:sok jabłkowy')
ety6 = Label(self.okno, text='35:mirinda')
ety7 = Label(self.okno, text='36:pepsi')
ety8 = Label(self.okno, text='37:pepsi light')
ety9 = Label(self.okno, text='38:cola')
ety10 = Label(self.okno, text='39:cola zero')
ety11 = Label(self.okno, text='40:nestea brzoskwiniowe')
ety12 = Label(self.okno, text='41:nestea cytrynowe')
ety13 = Label(self.okno, text='42:nestea zielona herbata')
ety14 = Label(self.okno, text='43:tymbark pomarańcza-mięta')
ety15 = Label(self.okno, text='44:tymbark jabłko-brzoskwinia')
ety16 = Label(self.okno, text='45:tymbark jabłko-wiśnia')
ety17 = Label(self.okno, text='46:tymbark jabłko-kiwi')
ety18 = Label(self.okno, text='47:sprite')
ety19 = Label(self.okno, text='48:7up')
ety20 = Label(self.okno, text='49:oranżada cytrynowa')
ety21 = Label(self.okno, text='50:oranżada wiśniowa')
# ustalam ułozennie etykiet i ich wyrowanie
ety1.grid(row=14, column=0, padx=1, pady=1, sticky=W)
ety2.grid(row=14, column=1, padx=1, pady=1, sticky=W)
ety3.grid(row=14, column=2, padx=1, pady=1, sticky=W)
ety4.grid(row=15, column=0, padx=1, pady=1, sticky=W)
ety5.grid(row=15, column=1, padx=1, pady=1, sticky=W)
ety6.grid(row=15, column=2, padx=1, pady=1, sticky=W)
ety7.grid(row=16, column=0, padx=1, pady=1, sticky=W)
ety8.grid(row=16, column=1, padx=1, pady=1, sticky=W)
ety9.grid(row=16, column=2, padx=1, pady=1, sticky=W)
ety10.grid(row=17, column=0, padx=1, pady=1, sticky=W)
ety11.grid(row=17, column=1, padx=1, pady=1, sticky=W)
ety12.grid(row=17, column=2, padx=1, pady=1, sticky=W)
ety13.grid(row=18, column=0, padx=1, pady=1, sticky=W)
ety14.grid(row=18, column=1, padx=1, pady=1, sticky=W)
ety15.grid(row=18, column=2, padx=1, pady=1, sticky=W)
ety16.grid(row=19, column=0, padx=1, pady=1, sticky=W)
ety17.grid(row=19, column=1, padx=1, pady=1, sticky=W)
ety18.grid(row=19, column=2, padx=1, pady=1, sticky=W)
ety19.grid(row=20, column=0, padx=1, pady=1, sticky=W)
ety20.grid(row=20, column=1, padx=1, pady=1, sticky=W)
ety21.grid(row=20, column=2, padx=1, pady=1, sticky=W)
# ustalam kolor tla, kolor,rodzaj i wielkosc czcionki w etykietach
ety1.config(font=("Arial", 11, "italic"),
foreground="white",
background='black')
ety2.config(font=("Arial", 11, "italic"),
foreground="white",
background='black')
ety3.config(font=("Arial", 11, "italic"),
foreground="white",
background='black')
ety4.config(font=("Arial", 11, "italic"),
foreground="white",
background='black')
ety5.config(font=("Arial", 11, "italic"),
foreground="white",
background='black')
ety6.config(font=("Arial", 11, "italic"),
foreground="white",
background='black')
ety7.config(font=("Arial", 11, "italic"),
foreground="white",
background='black')
ety8.config(font=("Arial", 11, "italic"),
foreground="white",
background='black')
ety9.config(font=("Arial", 11, "italic"),
foreground="white",
background='black')
ety10.config(font=("Arial", 11, "italic"),
foreground="white",
background='black')
ety11.config(font=("Arial", 11, "italic"),
foreground="white",
background='black')
ety12.config(font=("Arial", 11, "italic"),
foreground="white",
background='black')
ety13.config(font=("Arial", 11, "italic"),
foreground="white",
background='black')
ety14.config(font=("Arial", 11, "italic"),
foreground="white",
background='black')
ety15.config(font=("Arial", 11, "italic"),
foreground="white",
background='black')
ety16.config(font=("Arial", 11, "italic"),
foreground="white",
background='black')
ety17.config(font=("Arial", 11, "italic"),
foreground="white",
background='black')
ety18.config(font=("Arial", 11, "italic"),
foreground="white",
background='black')
ety19.config(font=("Arial", 11, "italic"),
foreground="white",
background='black')
ety20.config(font=("Arial", 11, "italic"),
foreground="white",
background='black')
ety21.config(font=("Arial", 11, "italic"),
foreground="white",
background='black')
def queryDate():
dates=[]
# returnDates = []
# dateButtons = []
today = datetime.now()
daysForward = ""
if today.weekday()<2:
daysForward = 3
else:
daysForward = 5
#remove the +1 for actual use
for i in range(daysForward):
thisDay = getDaysForward(i, True)
if thisDay:
dates.append(thisDay)
bgC = "lavender"
top = Tk()
top.config(bg = bgC)
L1 = Label(top, text="Please select the date to run on\nPlease only select one date.", bg = bgC, padx = 20)
L1.config(font=("serif", 16))
L1.grid(row=0, column=0, sticky=constants.W+constants.E)
dateVar=StringVar()
dateVar.set(dates[-1])
f = Frame(top)
f.grid(row=1, column=0)
print("here")
for date in dates:
Radiobutton(f, text=date, variable=dateVar, value=date, bg=bgC, font = ("serif", 16)).pack()
# check = BooleanVar()
# checkButton = Checkbutton(top, text=date, variable=check, font=("serif", 16), bg=bgC)
# checkButton.grid(row=i, column=0, sticky=constants.W+constants.E)
# if i==daysForward:
# check.set(True)
# i+=1
# dateButtons.append((check, date))
def callbackDates():
# for button, date in dateButtons:
# if button.get():
# returnDates.append(date)
top.destroy()
MyButton = Button(top, text="OK", command=callbackDates)
MyButton.grid(row=2, column=0, sticky=constants.W+constants.E, padx = 20, pady = (0,20))
MyButton.config(font=("serif", 30), bg="green")
top.update()
w = top.winfo_width() # width for the Tk root
h = top.winfo_height() # height for the Tk root
ws = top.winfo_screenwidth() # width of the screen
hs = top.winfo_screenheight() # height of the screen
x = (ws/2) - (w/2)
y = (hs/2) - (h/2)
top.geometry('%dx%d+%d+%d' % (w, h, x, y))
top.update()
top.lift()
top.attributes('-topmost',True)
top.after_idle(top.attributes,'-topmost',False)
moveTo(MyButton.winfo_width()/2 + MyButton.winfo_rootx(), MyButton.winfo_height()/2 + MyButton.winfo_rooty())
top.mainloop()
return dateVar.get()
command
# Комманда exe при активации виджета(fx обратного вызова)
# Полныи lst ⊃ args
# Man options:https://www.tcl.tk/man/tcl8.5/TkCmd/options.htm
# Man-страницы соотв виджета, напр man button(разделы "STANDART OPTIONS" & "WIDGET-SPECIFIC OPTIONS":
# Http://www.tcl.tk/man/tcl8.5/TkCmd/button.htm
МЕТОДЫ ВИДЖЕТОВ
.config[ure](**kwargs)
# Δ конфигурации ∃ виджета(при exe app)
# ~ <widget>['<opt>'] = new_val
# Examples
btn0 = Button()
btn0.config(text='send')
.cget
# Обратен .config[ure]()
# Получение параметров виджета
# ~ val = <widget>['opt']
.destroy()
# Уничтожение виджета & ∀ его потомков
.grid_remove()
# Скрытие виджета, с сохранение взаимного расположения виджетов
# Examples
from tkinter import Tk, Label, Button
...
...
class GUIRoot(Tk):
"""The tkinter GUI root class."""
def __init__(self, thread_cls):
super().__init__()
self.thread_cls = thread_cls
self.img = None
self.title("Emotion API")
self.grid()
self.grid_columnconfigure(0, weight=1)
self.grid_columnconfigure(1, weight=2)
self.grid_rowconfigure(4, weight=1)
# Create LabelFrames
lf_key = LabelFrame(self, text="Emotion API Key")
lf_key.grid(row=0,
column=0,
columnspan=1,
sticky=W + E,
padx=5,
pady=3)
lf_key.grid_columnconfigure(0, weight=1)
lf_mode = LabelFrame(self, text="Mode")
lf_mode.grid(row=1,
column=0,
columnspan=1,
sticky=W + E,
padx=5,
pady=3)
for i in range(3):
lf_mode.grid_columnconfigure(i, weight=1)
lf_source = LabelFrame(self, text="Image Source", height=50)
lf_source.grid(row=2,
column=0,
columnspan=1,
sticky=W + E,
padx=5,
pady=3)
lf_source.rowconfigure(0, weight=1)
lf_source.grid_propagate(False)
lf_source.columnconfigure(0, weight=1)
lf_source.columnconfigure(1, weight=5)
lf_source.columnconfigure(2, weight=1)
lf_request = LabelFrame(self, text="Request Result")
lf_request.grid(row=3,
column=0,
columnspan=1,
sticky=W + E,
padx=5,
pady=3)
lf_request.grid_columnconfigure(0, weight=1)
lf_console = LabelFrame(self, text="Console")
lf_console.grid(row=4,
column=0,
columnspan=1,
sticky=N + S + W + E,
padx=5,
pady=3)
lf_console.grid_columnconfigure(0, weight=1)
lf_console.grid_rowconfigure(0, weight=1)
lf_img = LabelFrame(self, text="Output Image")
lf_img.grid(row=0, column=1, rowspan=5, sticky=N + S + W + E)
lf_img.grid_columnconfigure(0, weight=1)
lf_img.grid_rowconfigure(0, weight=1)
# Create Input Fields
self.ety_key = Entry(lf_key)
self.ety_key.insert(END, "bfe9b2f471e04b29a8fabfe3dd9f647d")
self.ety_key.grid(sticky=W + E, padx=3)
self.var_mode = StringVar()
Radiobutton(lf_mode,
text="Local Image",
variable=self.var_mode,
value='local',
command=self.change_mode).grid(row=1, column=0)
Radiobutton(lf_mode,
text="URL Image",
variable=self.var_mode,
value='url',
command=self.change_mode).grid(row=1, column=1)
Radiobutton(lf_mode,
text="Camera",
variable=self.var_mode,
value='cam',
command=self.change_mode).grid(row=1, column=2)
# Local Image Source
self.lb_filename = Label(lf_source, text="..")
self.btn_fileopen = Button(lf_source,
text="Open..",
command=self.get_local_img)
# URL Image Source
self.lb_url = Label(lf_source, text="URL")
self.ety_url = Entry(lf_source)
self.ety_url.insert(END, "https://i.imgflip.com/qiev6.jpg")
self.btn_url = Button(lf_source,
text="Get Image",
command=self.get_url_img)
# Camera Image Source
self.btn_get_cam = Button(lf_source,
text="Get the Camera Image",
command=self.get_cam_img)
# set default mode: local raw image
self.var_mode.set('local')
self.change_mode()
# request btn
self.btn_request = Button(lf_request,
text="Request Result",
command=self.run_request,
state='disable')
self.btn_request.grid(sticky=W + E)
# Create Output Console
self.console = ScrolledText(lf_console,
state='disable',
width=60,
bg='gray20',
fg='white')
self.console.grid(sticky=N + S + W + E)
# Create Output Image
self.plot = ResultImg(lf_img)
self.plot.grid(sticky=N + S + W + E)
def change_mode(self):
"""Change the image source mode."""
if self.var_mode.get() == 'local':
self.lb_filename.grid(row=0, column=0, columnspan=2)
self.btn_fileopen.grid(row=0, column=2)
self.lb_url.grid_forget()
self.ety_url.grid_forget()
self.btn_url.grid_forget()
self.btn_get_cam.grid_forget()
elif self.var_mode.get() == 'url':
self.lb_filename.grid_forget()
self.btn_fileopen.grid_forget()
self.btn_get_cam.grid_forget()
self.lb_url.grid(row=0, column=0)
self.ety_url.grid(row=0, column=1, sticky=W + E, padx=3)
self.btn_url.grid(row=0, column=2)
else:
self.lb_filename.grid_forget()
self.btn_fileopen.grid_forget()
self.lb_url.grid_forget()
self.ety_url.grid_forget()
self.btn_url.grid_forget()
self.btn_get_cam.grid(row=0, column=0, columnspan=3)
def run_request(self):
"""Create the requesting thread to request the result from Emotion API."""
source = self.ety_url.get() if self.var_mode.get(
) == 'url' else self.img
self.thread_cls(self.ety_key.get(), self.var_mode.get(), source,
self.plot, self.print_console).start()
def get_local_img(self):
"""Open the dialog let user to choose test file and get the test data."""
max_name_len = 20
filename = askopenfilename(filetypes=(("JPEG", "*.jpg"),
("PNG", "*.png"), ("All Files",
"*.*")),
title="Choose an Image")
if filename:
with open(filename, 'rb') as f:
self.img = f.read()
self.plot.imshow(img_decode(self.img))
self.print_console("Open a local raw image file.")
self.btn_request.config(state='normal')
if len(filename) > max_name_len:
self.lb_filename.config(text=".." + filename[-max_name_len:])
else:
self.lb_filename.config(text=filename)
def get_url_img(self):
"""Get the image from the given URL."""
try:
self.plot.imshow(
Image.open(BytesIO(requests.get(self.ety_url.get()).content)))
except Exception as e:
self.print_console(e.args)
else:
self.print_console("Open a online image from URL.")
self.btn_request.config(state='normal')
def get_cam_img(self):
"""Get the image from the laptop camera."""
cam = cv2.VideoCapture(0) # 0 -> index of camera
s, self.img = cam.read()
self.img = cv2.imencode('.jpg', self.img)[1].tostring()
if s: # frame captured without any errors
self.print_console("Camera image captured.")
self.plot.imshow(img_decode(self.img))
self.btn_request.config(state='normal')
def print_console(self, input_str):
"""Print the text on the conolse."""
self.console.config(state='normal')
self.console.insert(END, "{}\n".format(input_str))
self.console.config(state='disable')
self.console.see(END)
class wm_seg:
"""
Simple GUI application
If the application inside a container, automatic updates are removed.
The application uses two frames (tabs):
- training
- testing
"""
def __init__(self, master, container):
self.master = master
master.title("nicMSlesions")
# running on a container
self.container = container
# gui attributes
self.path = os.getcwd()
self.default_config = None
self.user_config = None
self.current_folder = os.getcwd()
self.list_train_pretrained_nets = []
self.list_test_nets = []
self.version = __version__
if self.container is False:
# version_number
self.commit_version = subprocess.check_output(
['git', 'rev-parse', 'HEAD'])
# queue and thread parameters. All processes are embedded
# inside threads to avoid freezing the application
self.train_task = None
self.test_task = None
self.test_queue = Queue()
self.train_queue = Queue()
# --------------------------------------------------
# parameters. Mostly from the config/*.cfg files
# --------------------------------------------------
# data parameters
self.param_training_folder = StringVar()
self.param_test_folder = StringVar()
self.param_FLAIR_tag = StringVar()
self.param_T1_tag = StringVar()
self.param_MOD3_tag = StringVar()
self.param_MOD4_tag = StringVar()
self.param_mask_tag = StringVar()
self.param_model_tag = StringVar()
self.param_register_modalities = BooleanVar()
self.param_skull_stripping = BooleanVar()
self.param_denoise = BooleanVar()
self.param_denoise_iter = IntVar()
self.param_save_tmp = BooleanVar()
self.param_debug = BooleanVar()
# train parameters
self.param_net_folder = os.path.join(self.current_folder, 'nets')
self.param_use_pretrained_model = BooleanVar()
self.param_pretrained_model = StringVar()
self.param_inference_model = StringVar()
self.param_num_layers = IntVar()
self.param_net_name = StringVar()
self.param_net_name.set('None')
self.param_balanced_dataset = StringVar()
self.param_fract_negatives = DoubleVar()
# model parameters
self.param_pretrained = None
self.param_min_th = DoubleVar()
self.param_patch_size = IntVar()
self.param_weight_paths = StringVar()
self.param_load_weights = BooleanVar()
self.param_train_split = DoubleVar()
self.param_max_epochs = IntVar()
self.param_patience = IntVar()
self.param_batch_size = IntVar()
self.param_net_verbose = IntVar()
self.param_t_bin = DoubleVar()
self.param_l_min = IntVar()
self.param_min_error = DoubleVar()
self.param_mode = BooleanVar()
self.param_gpu_number = IntVar()
# load the default configuration from the conf file
self.load_default_configuration()
# self frame (tabbed notebook)
self.note = Notebook(self.master)
self.note.pack()
os.system('cls' if platform.system() == 'Windows' else 'clear')
print("##################################################")
print("# ------------ #")
print("# nicMSlesions #")
print("# ------------ #")
print("# MS WM lesion segmentation #")
print("# #")
print("# ------------------------------- #")
print("# (c) Sergi Valverde 2018 #")
print("# Neuroimage Computing Group #")
print("# ------------------------------- #")
print("##################################################\n)")
print("Please select options for training or inference in the menu...")
# --------------------------------------------------
# training tab
# --------------------------------------------------
self.train_frame = Frame()
self.note.add(self.train_frame, text="Training")
self.test_frame = Frame()
self.note.add(self.test_frame, text="Inference")
# label frames
cl_s = 5
self.tr_frame = LabelFrame(self.train_frame, text="Training images:")
self.tr_frame.grid(row=0,
columnspan=cl_s,
sticky='WE',
padx=5,
pady=5,
ipadx=5,
ipady=5)
self.model_frame = LabelFrame(self.train_frame, text="CNN model:")
self.model_frame.grid(row=5,
columnspan=cl_s,
sticky='WE',
padx=5,
pady=5,
ipadx=5,
ipady=5)
# training options
self.inFolderLbl = Label(self.tr_frame, text="Training folder:")
self.inFolderLbl.grid(row=0, column=0, sticky='E', padx=5, pady=2)
self.inFolderTxt = Entry(self.tr_frame)
self.inFolderTxt.grid(row=0,
column=1,
columnspan=5,
sticky="W",
pady=3)
self.inFileBtn = Button(self.tr_frame,
text="Browse ...",
command=self.load_training_path)
self.inFileBtn.grid(row=0,
column=5,
columnspan=1,
sticky='W',
padx=5,
pady=1)
self.optionsBtn = Button(self.tr_frame,
text="Other options",
command=self.parameter_window)
self.optionsBtn.grid(row=0,
column=10,
columnspan=1,
sticky="W",
padx=(100, 1),
pady=1)
# setting input modalities: FLAIR + T1 are mandatory
# Mod 3 / 4 are optional
self.flairTagLbl = Label(self.tr_frame, text="FLAIR tag:")
self.flairTagLbl.grid(row=1, column=0, sticky='E', padx=5, pady=2)
self.flairTxt = Entry(self.tr_frame, textvariable=self.param_FLAIR_tag)
self.flairTxt.grid(row=1, column=1, columnspan=1, sticky="W", pady=1)
self.t1TagLbl = Label(self.tr_frame, text="T1 tag:")
self.t1TagLbl.grid(row=2, column=0, sticky='E', padx=5, pady=2)
self.t1Txt = Entry(self.tr_frame, textvariable=self.param_T1_tag)
self.t1Txt.grid(row=2, column=1, columnspan=1, sticky="W", pady=1)
self.mod3TagLbl = Label(self.tr_frame, text="mod 3 tag:")
self.mod3TagLbl.grid(row=3, column=0, sticky='E', padx=5, pady=2)
self.mod3Txt = Entry(self.tr_frame, textvariable=self.param_MOD3_tag)
self.mod3Txt.grid(row=3, column=1, columnspan=1, sticky="W", pady=1)
self.mod4TagLbl = Label(self.tr_frame, text="mod 4 tag:")
self.mod4TagLbl.grid(row=4, column=0, sticky='E', padx=5, pady=2)
self.mod4Txt = Entry(self.tr_frame, textvariable=self.param_MOD4_tag)
self.mod4Txt.grid(row=4, column=1, columnspan=1, sticky="W", pady=1)
self.maskTagLbl = Label(self.tr_frame, text="MASK tag:")
self.maskTagLbl.grid(row=5, column=0, sticky='E', padx=5, pady=2)
self.maskTxt = Entry(self.tr_frame, textvariable=self.param_mask_tag)
self.maskTxt.grid(row=5, column=1, columnspan=1, sticky="W", pady=1)
# model options
self.modelTagLbl = Label(self.model_frame, text="Model name:")
self.modelTagLbl.grid(row=6, column=0, sticky='E', padx=5, pady=2)
self.modelTxt = Entry(self.model_frame,
textvariable=self.param_net_name)
self.modelTxt.grid(row=6, column=1, columnspan=1, sticky="W", pady=1)
self.checkPretrain = Checkbutton(self.model_frame,
text="use pretrained",
var=self.param_use_pretrained_model)
self.checkPretrain.grid(row=6, column=3, padx=5, pady=5)
self.update_pretrained_nets()
self.pretrainTxt = OptionMenu(self.model_frame,
self.param_pretrained_model,
*self.list_train_pretrained_nets)
self.pretrainTxt.grid(row=6, column=5, sticky='E', padx=5, pady=5)
# START button links
self.trainingBtn = Button(self.train_frame,
state='disabled',
text="Start training",
command=self.train_net)
self.trainingBtn.grid(row=7, column=0, sticky='W', padx=1, pady=1)
# --------------------------------------------------
# inference tab
# --------------------------------------------------
self.tt_frame = LabelFrame(self.test_frame, text="Inference images:")
self.tt_frame.grid(row=0,
columnspan=cl_s,
sticky='WE',
padx=5,
pady=5,
ipadx=5,
ipady=5)
self.test_model_frame = LabelFrame(self.test_frame, text="CNN model:")
self.test_model_frame.grid(row=5,
columnspan=cl_s,
sticky='WE',
padx=5,
pady=5,
ipadx=5,
ipady=5)
# testing options
self.test_inFolderLbl = Label(self.tt_frame, text="Testing folder:")
self.test_inFolderLbl.grid(row=0, column=0, sticky='E', padx=5, pady=2)
self.test_inFolderTxt = Entry(self.tt_frame)
self.test_inFolderTxt.grid(row=0,
column=1,
columnspan=5,
sticky="W",
pady=3)
self.test_inFileBtn = Button(self.tt_frame,
text="Browse ...",
command=self.load_testing_path)
self.test_inFileBtn.grid(row=0,
column=5,
columnspan=1,
sticky='W',
padx=5,
pady=1)
self.test_optionsBtn = Button(self.tt_frame,
text="Other options",
command=self.parameter_window)
self.test_optionsBtn.grid(row=0,
column=10,
columnspan=1,
sticky="W",
padx=(100, 1),
pady=1)
self.test_flairTagLbl = Label(self.tt_frame, text="FLAIR tag:")
self.test_flairTagLbl.grid(row=1, column=0, sticky='E', padx=5, pady=2)
self.test_flairTxt = Entry(self.tt_frame,
textvariable=self.param_FLAIR_tag)
self.test_flairTxt.grid(row=1,
column=1,
columnspan=1,
sticky="W",
pady=1)
self.test_t1TagLbl = Label(self.tt_frame, text="T1 tag:")
self.test_t1TagLbl.grid(row=2, column=0, sticky='E', padx=5, pady=2)
self.test_t1Txt = Entry(self.tt_frame, textvariable=self.param_T1_tag)
self.test_t1Txt.grid(row=2, column=1, columnspan=1, sticky="W", pady=1)
self.test_mod3TagLbl = Label(self.tt_frame, text="mod 3 tag:")
self.test_mod3TagLbl.grid(row=3, column=0, sticky='E', padx=5, pady=2)
self.test_mod3Txt = Entry(self.tt_frame,
textvariable=self.param_MOD3_tag)
self.test_mod3Txt.grid(row=3,
column=1,
columnspan=1,
sticky="W",
pady=1)
self.test_mod4TagLbl = Label(self.tt_frame, text="mod 4 tag:")
self.test_mod4TagLbl.grid(row=4, column=0, sticky='E', padx=5, pady=2)
self.test_mod4Txt = Entry(self.tt_frame,
textvariable=self.param_MOD4_tag)
self.test_mod4Txt.grid(row=4,
column=1,
columnspan=1,
sticky="W",
pady=1)
self.test_pretrainTxt = OptionMenu(self.test_model_frame,
self.param_inference_model,
*self.list_test_nets)
self.param_inference_model.set('None')
self.test_pretrainTxt.grid(row=5, column=0, sticky='E', padx=5, pady=5)
# START button links cto docker task
self.inferenceBtn = Button(self.test_frame,
state='disabled',
text="Start inference",
command=self.infer_segmentation)
self.inferenceBtn.grid(row=7, column=0, sticky='W', padx=1, pady=1)
# train / test ABOUT button
self.train_aboutBtn = Button(self.train_frame,
text="about",
command=self.about_window)
self.train_aboutBtn.grid(row=7,
column=4,
sticky='E',
padx=(1, 1),
pady=1)
self.test_aboutBtn = Button(self.test_frame,
text="about",
command=self.about_window)
self.test_aboutBtn.grid(row=7,
column=4,
sticky='E',
padx=(1, 1),
pady=1)
# Processing state
self.process_indicator = StringVar()
self.process_indicator.set(' ')
self.label_indicator = Label(master,
textvariable=self.process_indicator)
self.label_indicator.pack(side="left")
# Closing processing events is implemented via
# a master protocol
self.master.protocol("WM_DELETE_WINDOW", self.close_event)
def parameter_window(self):
"""
Setting other parameters using an emerging window
CNN parameters, CUDA device, post-processing....
"""
t = Toplevel(self.master)
t.wm_title("Other parameters")
# data parameters
t_data = LabelFrame(t, text="data options:")
t_data.grid(row=0, sticky="WE")
checkPretrain = Checkbutton(t_data,
text="Register modalities",
var=self.param_register_modalities)
checkPretrain.grid(row=0, sticky='W')
checkSkull = Checkbutton(t_data,
text="Skull-strip modalities",
var=self.param_skull_stripping)
checkSkull.grid(row=1, sticky="W")
checkDenoise = Checkbutton(t_data,
text="Denoise masks",
var=self.param_denoise)
checkDenoise.grid(row=2, sticky="W")
denoise_iter_label = Label(t_data,
text=" Denoise iter: ")
denoise_iter_label.grid(row=3, sticky="W")
denoise_iter_entry = Entry(t_data,
textvariable=self.param_denoise_iter)
denoise_iter_entry.grid(row=3, column=1, sticky="E")
check_tmp = Checkbutton(t_data,
text="Save tmp files",
var=self.param_save_tmp)
check_tmp.grid(row=4, sticky="W")
checkdebug = Checkbutton(t_data,
text="Debug mode",
var=self.param_debug)
checkdebug.grid(row=5, sticky="W")
# model parameters
t_model = LabelFrame(t, text="Model:")
t_model.grid(row=5, sticky="EW")
maxepochs_label = Label(t_model, text="Max epochs: ")
maxepochs_label.grid(row=6, sticky="W")
maxepochs_entry = Entry(t_model, textvariable=self.param_max_epochs)
maxepochs_entry.grid(row=6, column=1, sticky="E")
trainsplit_label = Label(t_model, text="Validation %: ")
trainsplit_label.grid(row=7, sticky="W")
trainsplit_entry = Entry(t_model, textvariable=self.param_train_split)
trainsplit_entry.grid(row=7, column=1, sticky="E")
batchsize_label = Label(t_model, text="Test batch size:")
batchsize_label.grid(row=8, sticky="W")
batchsize_entry = Entry(t_model, textvariable=self.param_batch_size)
batchsize_entry.grid(row=8, column=1, sticky="E")
mode_label = Label(t_model, text="Verbosity:")
mode_label.grid(row=9, sticky="W")
mode_entry = Entry(t_model, textvariable=self.param_net_verbose)
mode_entry.grid(row=9, column=1, sticky="E")
#gpu_mode = Checkbutton(t_model,
# text="GPU:",
# var=self.param_mode)
#gpu_mode.grid(row=10, sticky="W")
gpu_number = Label(t_model, text="GPU number:")
gpu_number.grid(row=10, sticky="W")
gpu_entry = Entry(t_model, textvariable=self.param_gpu_number)
gpu_entry.grid(row=10, column=1, sticky="W")
# training parameters
tr_model = LabelFrame(t, text="Training:")
tr_model.grid(row=12, sticky="EW")
balanced_label = Label(tr_model, text="Balanced dataset: ")
balanced_label.grid(row=13, sticky="W")
balanced_entry = Entry(tr_model,
textvariable=self.param_balanced_dataset)
balanced_entry.grid(row=13, column=1, sticky="E")
fraction_label = Label(tr_model, text="Fraction negative/positives: ")
fraction_label.grid(row=14, sticky="W")
fraction_entry = Entry(tr_model,
textvariable=self.param_fract_negatives)
fraction_entry.grid(row=14, column=1, sticky="E")
# postprocessing parameters
t_post = LabelFrame(t, text="Post-processing: ")
t_post.grid(row=15, sticky="EW")
t_bin_label = Label(t_post, text="Out probability th: ")
t_bin_label.grid(row=16, sticky="W")
t_bin_entry = Entry(t_post, textvariable=self.param_t_bin)
t_bin_entry.grid(row=16, column=1, sticky="E")
l_min_label = Label(t_post, text="Min out region size: ")
l_min_label.grid(row=17, sticky="W")
l_min_entry = Entry(t_post, textvariable=self.param_l_min)
l_min_entry.grid(row=17, column=1, sticky="E")
vol_min_label = Label(t_post, text="Min vol error (ml): ")
vol_min_label.grid(row=18, sticky="W")
vol_min_entry = Entry(t_post, textvariable=self.param_min_error)
vol_min_entry.grid(row=18, column=1, sticky="E")
def load_default_configuration(self):
"""
load the default configuration from /config/default.cfg
This method assign each of the configuration parameters to
class attributes
"""
default_config = ConfigParser.SafeConfigParser()
default_config.read(os.path.join(self.path, 'config', 'default.cfg'))
# dastaset parameters
self.param_training_folder.set(
default_config.get('database', 'train_folder'))
self.param_test_folder.set(
default_config.get('database', 'inference_folder'))
self.param_FLAIR_tag.set(default_config.get('database', 'flair_tags'))
self.param_T1_tag.set(default_config.get('database', 't1_tags'))
self.param_MOD3_tag.set(default_config.get('database', 'mod3_tags'))
self.param_MOD4_tag.set(default_config.get('database', 'mod4_tags'))
self.param_mask_tag.set(default_config.get('database', 'roi_tags'))
self.param_register_modalities.set(
default_config.get('database', 'register_modalities'))
self.param_denoise.set(default_config.get('database', 'denoise'))
self.param_denoise_iter.set(
default_config.getint('database', 'denoise_iter'))
self.param_skull_stripping.set(
default_config.get('database', 'skull_stripping'))
self.param_save_tmp.set(default_config.get('database', 'save_tmp'))
self.param_debug.set(default_config.get('database', 'debug'))
# train parameters
self.param_use_pretrained_model.set(
default_config.get('train', 'full_train'))
self.param_pretrained_model.set(
default_config.get('train', 'pretrained_model'))
self.param_inference_model.set(" ")
self.param_balanced_dataset.set(
default_config.get('train', 'balanced_training'))
self.param_fract_negatives.set(
default_config.getfloat('train', 'fraction_negatives'))
# model parameters
self.param_net_folder = os.path.join(self.current_folder, 'nets')
self.param_net_name.set(default_config.get('model', 'name'))
self.param_train_split.set(
default_config.getfloat('model', 'train_split'))
self.param_max_epochs.set(default_config.getint('model', 'max_epochs'))
self.param_patience.set(default_config.getint('model', 'patience'))
self.param_batch_size.set(default_config.getint('model', 'batch_size'))
self.param_net_verbose.set(default_config.get('model', 'net_verbose'))
self.param_gpu_number.set(default_config.getint('model', 'gpu_number'))
# self.param_mode.set(default_config.get('model', 'gpu_mode'))
# post-processing
self.param_l_min.set(default_config.getint('postprocessing', 'l_min'))
self.param_t_bin.set(default_config.getfloat('postprocessing',
't_bin'))
self.param_min_error.set(
default_config.getfloat('postprocessing', 'min_error'))
def write_user_configuration(self):
"""
write the configuration into config/configuration.cfg
"""
user_config = ConfigParser.RawConfigParser()
# dataset parameters
user_config.add_section('database')
user_config.set('database', 'train_folder',
self.param_training_folder.get())
user_config.set('database', 'inference_folder',
self.param_test_folder.get())
user_config.set('database', 'flair_tags', self.param_FLAIR_tag.get())
user_config.set('database', 't1_tags', self.param_T1_tag.get())
user_config.set('database', 'mod3_tags', self.param_MOD3_tag.get())
user_config.set('database', 'mod4_tags', self.param_MOD4_tag.get())
user_config.set('database', 'roi_tags', self.param_mask_tag.get())
user_config.set('database', 'register_modalities',
self.param_register_modalities.get())
user_config.set('database', 'denoise', self.param_denoise.get())
user_config.set('database', 'denoise_iter',
self.param_denoise_iter.get())
user_config.set('database', 'skull_stripping',
self.param_skull_stripping.get())
user_config.set('database', 'save_tmp', self.param_save_tmp.get())
user_config.set('database', 'debug', self.param_debug.get())
# train parameters
user_config.add_section('train')
user_config.set('train', 'full_train',
not (self.param_use_pretrained_model.get()))
user_config.set('train', 'pretrained_model',
self.param_pretrained_model.get())
user_config.set('train', 'balanced_training',
self.param_balanced_dataset.get())
user_config.set('train', 'fraction_negatives',
self.param_fract_negatives.get())
# model parameters
user_config.add_section('model')
user_config.set('model', 'name', self.param_net_name.get())
user_config.set('model', 'pretrained', self.param_pretrained)
user_config.set('model', 'train_split', self.param_train_split.get())
user_config.set('model', 'max_epochs', self.param_max_epochs.get())
user_config.set('model', 'patience', self.param_patience.get())
user_config.set('model', 'batch_size', self.param_batch_size.get())
user_config.set('model', 'net_verbose', self.param_net_verbose.get())
# user_config.set('model', 'gpu_mode', self.param_mode.get())
user_config.set('model', 'gpu_number', self.param_gpu_number.get())
# postprocessing parameters
user_config.add_section('postprocessing')
user_config.set('postprocessing', 't_bin', self.param_t_bin.get())
user_config.set('postprocessing', 'l_min', self.param_l_min.get())
user_config.set('postprocessing', 'min_error',
self.param_min_error.get())
# Writing our configuration file to 'example.cfg'
with open(os.path.join(self.path, 'config', 'configuration.cfg'),
'w') as config_file:
user_config.write(config_file)
def load_training_path(self):
"""
Select training path from disk and write it.
If the app is run inside a container,
link the iniitaldir with /data
"""
initialdir = '/data' if self.container else os.getcwd()
fname = askdirectory(initialdir=initialdir)
if fname:
try:
self.param_training_folder.set(fname)
self.inFolderTxt.delete(0, END)
self.inFolderTxt.insert(0, self.param_training_folder.get())
self.trainingBtn['state'] = 'normal'
except:
pass
def load_testing_path(self):
"""
Selecet the inference path from disk and write it
If the app is run inside a container,
link the iniitaldir with /data
"""
initialdir = '/data' if self.container else os.getcwd()
fname = askdirectory(initialdir=initialdir)
if fname:
try:
self.param_test_folder.set(fname)
self.test_inFolderTxt.delete(0, END)
self.test_inFolderTxt.insert(0, self.param_test_folder.get())
self.inferenceBtn['state'] = 'normal'
except:
pass
def update_pretrained_nets(self):
"""
get a list of the different net configuration present in the system.
Each model configuration is represented by a folder containing the network
weights for each of the networks. The baseline net config is always
included by default
"""
folders = os.listdir(self.param_net_folder)
self.list_train_pretrained_nets = folders
self.list_test_nets = folders
def write_to_console(self, txt):
"""
to doc:
important method
"""
self.command_out.insert(END, str(txt))
def write_to_test_console(self, txt):
"""
to doc:
important method
"""
self.test_command_out.insert(END, str(txt))
def infer_segmentation(self):
"""
Method implementing the inference process:
- Check network selection
- write the configuration to disk
- Run the process on a new thread
"""
if self.param_inference_model.get() == 'None':
print("ERROR: Please, select a network model before starting...\n")
return
if self.test_task is None:
self.inferenceBtn.config(state='disabled')
self.param_net_name.set(self.param_inference_model.get())
self.param_use_pretrained_model.set(False)
self.write_user_configuration()
print("\n-----------------------")
print("Running configuration:")
print("-----------------------")
print("Inference model:", self.param_model_tag.get())
print("Inference folder:", self.param_test_folder.get(), "\n")
print("Method info:")
print("------------")
self.test_task = ThreadedTask(self.write_to_test_console,
self.test_queue,
mode='testing')
self.test_task.start()
self.master.after(100, self.process_container_queue)
def train_net(self):
"""
Method implementing the training process:
- write the configuration to disk
- Run the process on a new thread
"""
if self.param_net_name.get() == 'None':
print("ERROR: Please, define network name before starting...\n")
return
self.trainingBtn['state'] = 'disable'
if self.train_task is None:
self.trainingBtn.update()
self.write_user_configuration()
print("\n-----------------------")
print("Running configuration:")
print("-----------------------")
print("Train model:", self.param_net_name.get())
print("Training folder:", self.param_training_folder.get(), "\n")
print("Method info:")
print("------------")
self.train_task = ThreadedTask(self.write_to_console,
self.test_queue,
mode='training')
self.train_task.start()
self.master.after(100, self.process_container_queue)
def check_update(self):
"""
check update version and propose to download it if differnt
So far, a rudimentary mode is used to check the last version.
"""
# I have to discard possible local changes :(
print("---------------------------------------")
print("Updating software")
print("current version:", self.commit_version)
remote_commit = subprocess.check_output(['git', 'stash'])
remote_commit = subprocess.check_output(['git', 'fetch'])
remote_commit = subprocess.check_output(
['git', 'rev-parse', 'origin/master'])
if remote_commit != self.commit_version:
proc = subprocess.check_output(['git', 'pull', 'origin', 'master'])
self.check_link.config(text="Updated")
self.commit_version = remote_commit
print("updated version:", self.commit_version)
else:
print("This software is already in the latest version")
print("---------------------------------------")
def about_window(self):
"""
Window showing information about the software and
version number, including auto-update. If the application
is run from a container, then auto-update is disabled
"""
def callback(event):
"""
open webbrowser when clicking links
"""
webbrowser.open_new(event.widget.cget("text"))
# main window
t = Toplevel(self.master, width=500, height=500)
t.wm_title("About")
# NIC logo + name
title = Label(t,
text="nicMSlesions v" + self.version + "\n"
"Multiple Sclerosis White Matter Lesion Segmentation")
title.grid(row=2, column=1, padx=20, pady=10)
img = ImageTk.PhotoImage(Image.open('./logonic.png'))
imglabel = Label(t, image=img)
imglabel.image = img
imglabel.grid(row=1, column=1, padx=10, pady=10)
group_name = Label(t,
text="Copyright Sergi Valverde (2018-) \n " +
"NeuroImage Computing Group")
group_name.grid(row=3, column=1)
group_link = Label(t,
text=r"http://atc.udg.edu/nic",
fg="blue",
cursor="hand2")
group_link.grid(row=4, column=1)
group_link.bind("<Button-1>", callback)
license_content = "Licensed under the BSD 2-Clause license. \n" + \
"A copy of the license is present in the root directory."
license_label = Label(t, text=license_content)
license_label.grid(row=5, column=1, padx=20, pady=20)
# if self.container is False:
# # check version and updates
# version_number = Label(t, text="commit: " + self.commit_version)
# version_number.grid(row=6, column=1, padx=20, pady=(1, 1))
#
# self.check_link = Button(t,
# text="Check for updates",
# command=self.check_update)
# self.check_link.grid(row=7, column=1)
def process_container_queue(self):
"""
Process the threading queue. When the threaded processes are
finished, buttons are reset and a message is shown in the app.
"""
self.process_indicator.set('Running... please wait')
try:
msg = self.test_queue.get(0)
self.process_indicator.set('Done. See log for more details.')
self.inferenceBtn['state'] = 'normal'
self.trainingBtn['state'] = 'normal'
except multiprocessing.queues.Empty:
self.master.after(100, self.process_container_queue)
def close_event(self):
"""
Stop the thread processes using OS related calls.
"""
if self.train_task is not None:
self.train_task.stop_process()
if self.test_task is not None:
self.test_task.stop_process()
os.system('cls' if platform.system == "Windows" else 'clear')
root.destroy()
class GUI_signup():
from Mysqsl_module import Connector as consql
def __init__(self, clear: bool):
self.id_user = -1
self.checked = False
self.reader = PyFingerprint('/dev/ttyUSB0', 57600, 0xFFFFFFFF,
0x00000000)
if clear:
self.reader.clearDatabase()
if (self.reader.verifyPassword() == False):
raise ValueError('The given fingerprint sensor password is wrong!')
options = [
'User name:', 'User password:'******'Check in time:', 'Departure time:'
]
self.txtWidgets = {}
self.gui = Tk(className='Sign up a new fingerprint')
self.gui.geometry("700x600+450+70")
self.gui.config(bg="#3465A4")
self.photo = getImage(os.path.dirname(__file__) + "/reader.gif")
self.gui.iconphoto(False, self.photo)
r = 0
for op in options:
lbl = Label(text=op, relief=RIDGE)
lbl.grid(row=r, column=0, padx=10, pady=10)
lbl.config(width=20, height=2)
txt = Text(bg="white",
relief=SUNKEN,
width=50,
height=2,
fg="black")
txt.grid(row=r, column=1)
self.txtWidgets.update({op: txt})
r += 1
self.txtVarAction = StringVar()
self.lblAction = Label(bg="#3465A4",
fg="white",
textvariable=self.txtVarAction)
self.lblAction.grid(row=r, column=0, padx=10, pady=20)
self.txtVarAction.set("Not reading finger yet")
r += 1
self.lblImageFinger = Label(bg="#729FCF", fg="black")
self.lblImageFinger['image'] = self.photo
self.lblImageFinger.grid(row=r, column=0, padx=10, pady=10)
self.btnReadFinger = Button(text="Read fingerprint",
command=self.startFingerPrint)
self.btnReadFinger.grid(row=r + 1, column=0, padx=10)
self.btnReadFinger.config(width=20, height=2)
btnStore = Button(text="Store data in database",
command=self.storageDatabase)
btnStore.grid(row=r, column=1)
def storageDatabase(self):
for txts in self.txtWidgets.values():
if not txts.get(1.0, 'end').strip():
messagebox.showerror(message="All data files must be typed",
title="Values empty")
return
if self.id_user == -1:
messagebox.showerror(
message="You must scan your finger to get your id",
title="Not scanned finger yet")
return
msg, flag = self.consql.exeProcedure('Insert_user', [
self.id_user, self.txtWidgets['User name:'].get(
1.0, 'end').strip(), self.txtWidgets['User password:'******'end').strip(), self.txtWidgets['Check in time:'].get(
1.0, 'end').strip(),
self.txtWidgets['Departure time:'].get(1.0, 'end').strip()
], (0, 1))
if flag == 0:
messagebox.showerror(title='Error in insertion', message=msg)
else:
self.id_user = -1
self.lblImageFinger['image'] = self.photo
messagebox.showinfo(title='All is ok', message=msg)
def startFingerPrint(self):
threading.Thread(target=self.readFingerPrint,
args=("Thread Reader")).start()
def readFingerPrint(self, *argss):
try:
print('Waiting for finger...')
self.txtVarAction.set("Waiting for finger...")
while (self.reader.readImage() == False):
pass
self.reader.convertImage(0x01)
result = self.reader.searchTemplate()
positionNumber = result[0]
if (positionNumber >= 0):
print('Template already exists at position #' +
str(positionNumber))
self.txtVarAction.set("Template already\nexists")
return
print('Remove finger...')
self.txtVarAction.set("Remove finger...")
time.sleep(2)
print('Waiting for same finger again...')
self.txtVarAction.set('Waiting for same finger again...')
## Wait that finger is read again
while (self.reader.readImage() == False):
pass
print('Downloading image (this take a while)...')
self.txtVarAction.set('Downloading image\n(this take a while)...')
imagePath = os.path.dirname(__file__) + "/fingerprint.bmp"
self.reader.downloadImage(imagePath)
self.reader.convertImage(0x02)
if (self.reader.compareCharacteristics() == 0):
print('Fingers do not match')
self.txtVarAction.set('Fingers do not match')
return
self.reader.createTemplate()
self.id_user = self.reader.storeTemplate() + 1
print('The image was saved to "' + imagePath + '".')
print('Finger enrolled successfully!')
self.txtVarAction.set('Finger enrolled successfully!')
self.fingerImage = getImage(imagePath)
self.lblImageFinger['image'] = self.fingerImage
print('New template position #' + str(self.id_user - 1))
except Exception as e:
print('Operation failed!')
self.txtVarAction.set('Operation failed!')
print('Exception message: ' + str(e))
return
def run(self):
self.gui.mainloop()
buttons[previousx,previousy]['text']= ' '
buttons[x,y]['text']= ' '
else:
buttons[previousx,previousy]['command']=DISABLED
buttons[x,y]['command']=DISABLED
first=True
win=Tk()
winsound.PlaySound('Little_Jam.wav', winsound.SND_ALIAS | winsound.SND_ASYNC)
win.title("TileMatcher")
win.resizable(width=False,height=True)
first=True
previousx=0
previousy=0
buttons={}
button_symbols={}
symbol=[u'\u2702',u'\u2705',u'\u2708',u'\u2709',u'\u270B',u'\u270A',u'\u270C',u'\u270F',u'\u2712',u'\u2714',u'\u2716',u'\u2728', u'\u2702',u'\u2705',u'\u2708',u'\u2709',u'\u270B',u'\u270A',u'\u270C',u'\u270F',u'\u2712',u'\u2714',u'\u2716',u'\u2728']
random.shuffle(symbol)
hel = tkFont.Font(size=22, weight='bold')
for x in range(6):
for y in range(4):
button=Button(command= lambda x=x,y=y: show_symbol(x,y),width=8,height=4,bg='#000',fg='#fff',borderwidth="2px")
button['font'] = hel
button.config(relief=GROOVE)
button.grid(column=x,row=y)
buttons[x,y]=button
button_symbols[x,y]=symbol.pop()
win.mainloop()
class Wizard(Frame):
def __init__(self, parent, data):
super().__init__(parent)
self.parent = parent
self.current_step = None
self.current_step_index = 0
self.steps = []
self.data = data
self.button_frame = Frame(self, bd=1, relief="raised")
self.content_frame = Frame(self)
self.back_button = Button(self.button_frame, text="<< Back", command=self.back)
self.next_button = Button(self.button_frame, text="Next >>", command=self.next)
self.finish_button = Button(self.button_frame, text="Finish", command=self.finish)
#self.content_frame.pack_propagate(0) # Don't allow the widgets inside to determine the frame's width / height
self.content_frame.pack(side="top", fill="both", expand=True)
#self.button_frame.pack_propagate(0)
self.button_frame.pack(side="bottom", fill="x")
print("wizard bound to step_complete event")
self.bind("<<step_complete>>", self.step_complete)
# Example custom event call for above bind()
# self.event_generate("<<step_complete>>", when="tail")
def step_complete(self, event):
#print("Wizard:step_complete()")
self.next_button.config(state="normal")
self.finish_button.config(state="normal")
def set_steps(self, steps):
self.steps = steps
def start(self):
self.show_step(self.current_step_index)
def back(self):
self.current_step_index -= 1
self.show_step(self.current_step_index)
def next(self):
self.current_step_index += 1
self.show_step(self.current_step_index)
def finish(self):
self.current_step_index = 0
print("data is: ")
print(self.data)
self.parent.quit()
def show_step(self, step):
if step < len(self.steps):
if self.current_step is not None:
# remove current step
self.current_step.onscreen_exit()
self.current_step.pack_forget()
self.current_step = self.steps[step]
self.current_step.pack(fill="both", expand=True)
self.current_step.onscreen_enter()
if len(self.steps) != 0:
if len(self.steps) == 1:
self.back_button.pack_forget()
self.next_button.pack_forget()
self.finish_button.pack(side="right")
elif step == 0:
# first step
self.back_button.pack_forget()
self.next_button.pack(side="right")
self.finish_button.pack_forget()
elif step == len(self.steps)-1:
# last step
self.back_button.pack(side="left")
self.next_button.pack_forget()
self.finish_button.pack(side="right")
else:
# all other steps
self.back_button.pack(side="left")
self.next_button.pack(side="right")
self.finish_button.pack_forget()
else:
self.back_button.pack_forget()
self.next_button.pack_forget()
self.finish_button.pack(side="right")
if self.current_step is not None:
if self.current_step.allow_next():
self.next_button.config(state="normal")
self.finish_button.config(state="normal")
else:
self.next_button.config(state="disabled")
self.finish_button.config(state="disabled")
if not self.current_step.allow_previous():
self.back_button.pack_forget()
class QueryBrowserUI(Tk):
appName = "PySQLiTk3 - query browser"
initSize = "900x600"
configFile = 'conf.ini'
sqlSqliteUrl = "http://www.sqlite.org/lang.html"
tablesAtLeft = True
selectedTable = ''
def __init__(self, app):
self.app = app
super().__init__()
self.configureLocale()
self.title(self.appName)
self.geometry(self.initSize)
self.createMenu()
self.createContent()
self.loadLastDataBaseFile()
def configureLocale(self):
if sys.platform.startswith('win'):
import locale
if os.getenv('LANG') is None:
lang, enc = locale.getdefaultlocale()
os.environ['LANG'] = lang
textdomain("app")
bindtextdomain("app","./locale")
def start(self):
self.mainloop()
def createMenu(self):
menu = Menu(self)
self.config(menu=menu)
#File
mnFile = Menu(menu, tearoff=0)
menu.add_cascade(label=_("File"), underline=0, menu=mnFile)
mnFile.add_command(label=_("New..."), underline=0, command=lambda cmd='NEW': self.onCommand(cmd))
mnFile.add_command(label=_("Open..."), underline=0, command=lambda cmd='OPEN': self.onCommand(cmd))
mnFile.add_separator()
mnFile.add_command(label=_("Quit"), underline=0, command=lambda cmd='EXIT': self.onCommand(cmd))
#View
self.mnView = Menu(menu, tearoff=0)
menu.add_cascade(label=_("View"), underline=0, menu=self.mnView)
self.mnView.add_command(label=_("Tables at %s") % _('right'), underline=0, command=lambda cmd='TABLES_RL': self.onCommand(cmd))
#Help
mnHelp = Menu(menu, tearoff=0)
menu.add_cascade(label=_("Help"), underline=0, menu=mnHelp)
mnHelp.add_command(label=_("SQL by SQLite..."), underline=0, command=lambda: webbrowser.open(self.sqlSqliteUrl))
mnHelp.add_command(label=_("About..."), underline=0, command=lambda cmd='ABOUT': self.onCommand(cmd))
def createContent(self):
# Top Panel: ---------------------------------
pnlTop = Frame(self)
pnlTop.pack(side="top", fill="both", pady=10, padx=10)
self.btnDB = Button(pnlTop, text=_("Open Data Base..."), command=lambda cmd='OPEN': self.onCommand(cmd))
self.btnDB.grid(row=1, column=2, padx=5)
# Query Panel: -----------------------------------
self.pnlQuery = Frame(self)
self.pnlQuery.pack(side="right", fill="both", expand=True, padx=10)
#-- SQL Panel:
pnlSQL = Frame(self.pnlQuery)
pnlSQL.pack(side="top", fill="both")
Label(pnlSQL, text = "SQL:").grid(row=1, column=1, padx=5)
self.txtSQL = TextSQL(pnlSQL, height=10, width = 60)
self.txtSQL.grid(row=1, column=2, padx=5, pady=10)
Button(pnlSQL, text = _("Run"), command=lambda cmd='RUN': self.onCommand(cmd)).grid(row=1, column=3, padx=5)
#-- Buttons Panel
pnlBtns = Frame(pnlSQL)
pnlBtns.grid(row=2, column=2)
Button(pnlBtns, text='INSERT', width = 12, command=lambda cmd='QUERY',query='INSERT': self.onCommand(cmd,query=query)).grid(row=1, column=1)
Button(pnlBtns, text='SELECT', width = 12, command=lambda cmd='QUERY',query='SELECT': self.onCommand(cmd,query=query)).grid(row=1, column=2)
Button(pnlBtns, text='UPDATE', width = 12, command=lambda cmd='QUERY',query='UPDATE': self.onCommand(cmd,query=query)).grid(row=1, column=3)
Button(pnlBtns, text='DELETE', width = 12, command=lambda cmd='QUERY',query='DELETE': self.onCommand(cmd,query=query)).grid(row=1, column=4)
#-- Result Panel:
self.pnlResult = Frame(self.pnlQuery)
self.pnlResult.pack(side="top", fill="both", expand=True, pady=10, padx=10)
self.resultGrid = TextResult(self.pnlResult)
self.resultGrid.pack(side="top", fill="both", expand=True)
#Table List Panel: ---------------------------------------
self.pnlTables = Frame(self)
self.pnlTables.pack(side="left", fill="both", pady=10, padx=10)
#---Tables Buttons Panel:
self.pnlTableList = Frame(self.pnlTables)
self.pnlTableList.pack(side="top", fill="both", pady=10)
#---Panel Nueva: Button
pnlNewTable = Frame(self.pnlTables)
pnlNewTable.pack(side="bottom", pady=10, padx=10)
Button(pnlNewTable, text=_("New Table"), command=lambda cmd='QUERY',query='CREATE': self.onCommand(cmd,query=query,table='<table>')).grid(row=1, column=2, padx=5)
def tableContextMenu(self, event, table=''):
popup = Menu(self, tearoff=0)
popup.add_command(label=_("Add Column"), command=lambda cmd='QUERY',query='ADD', table=table: self.onCommand(cmd,query=query,table=table))
popup.add_command(label=_("Rename Table"), command=lambda cmd='QUERY',query='RENAME', table=table: self.onCommand(cmd,query=query,table=table))
popup.add_command(label=_("Drop Table"), command=lambda cmd='QUERY',query='DROP', table=table: self.onCommand(cmd,query=query,table=table))
popup.post(event.x_root, event.y_root)
def showTables(self):
tables = self.app.getTables()
self.pnlTableList.destroy()
self.pnlTableList = Frame(self.pnlTables)
self.pnlTableList.pack(side="top", fill="both", pady=10)
self.btnTables = {}
Label(self.pnlTableList, text=_('Tables')).grid(row=0, column=1)
for n,table in enumerate(tables):
self.btnTables[table] = Button(self.pnlTableList, text=table,width=20, command=lambda cmd='QUERY',query='SELECT',table=table: self.onCommand(cmd,query=query,table=table))
self.btnTables[table].grid(row=n+1, column=1)
self.btnTables[table].bind("<Button-3>", lambda event, table=table:self.tableContextMenu(event, table))
if table == self.selectedTable:
self.markTable(table)
def onCommand(self, comando, **args):
comandos = {
'NEW':self.newDataBaseFile,
'OPEN':self.openDataBaseFile,
'EXIT':self.exitApp,
'ABOUT':self.about,
'QUERY':self.showQuery,
'RUN':self.run,
'TABLES_RL': self.showTablesAtRightOrLeft
}
try:
comandos[comando](**args)
except KeyError:
showerror(_('Error'), _('Unknown command: ')+ comando)
def exitApp(self):
self.destroy()
def about(self):
showinfo(_('About...'), self.appName+'\n'+_('Desarrollado por:')+'\n'+_('Martín Nicolás Carbone')+'\n'+_('Agosto 2014'))
def showTablesAtRightOrLeft(self):
self.tablesAtLeft = not self.tablesAtLeft
querySide, tablesSide = ("right", "left") if self.tablesAtLeft else ("left", "right")
self.pnlTables.pack(side=tablesSide, fill="both", pady=10, padx=10)
self.pnlQuery.pack(side=querySide, fill="both", expand=True, padx=10)
self.mnView.entryconfigure(0, label=_("Tables at %s") % _(querySide))
def selectTable(self, table):
self.unMarkTable(self.selectedTable)
self.selectedTable = table if table != '' else self.selectedTable
self.markTable(self.selectedTable)
return self.selectedTable
def unMarkTable(self, table):
try:
self.btnTables[table].config(relief='raised')
except KeyError:
pass
def markTable(self, table):
try:
self.btnTables[table].config(relief='sunken')
except KeyError:
pass
def newDataBaseFile(self):
path = asksaveasfilename(defaultextension=".db")
if path != '':
self.openDataBase(path)
def openDataBaseFile(self):
path = askopenfilename(filetypes=((_("Data base files"), "*.db;*.dat;*.sqlite;*.sqlite3;*.sql;"),(_("All files"), "*.*") ))
if path != '':
self.openDataBase(path)
def loadLastDataBaseFile(self):
path = self.readPath()
if path != '':
self.openDataBase(path)
def savePath(self, path):
with open(self.configFile, 'w') as f:
f.write(str(path))
def readPath(self):
try:
with open(self.configFile, 'r') as f:
return str(f.read())
except IOError:
return ''
def openDataBase(self, path):
self.basePath = path if path != '' else self.basePath
try:
self.app.openDataBase(self.basePath)
self.savePath(self.basePath)
self.btnDB.config(text=self.basePath)
self.selectedTable = ''
self.showTables()
except IOError:
showerror(_('Error'),_('Error')+' '+_("Open Data Base..."))
def showQuery(self, query, table=''):
table = self.selectTable(table)
sql=self.app.createQuery(query, table)
self.txtSQL.setText(sql)
def run(self):
query = self.txtSQL.getText()
result = self.app.runQuery(query)
self.resultGrid.setText(result)
if result == '':
self.showTables()
lbl_apellido.grid(row=1, column=0, padx=10, pady=10, sticky="e")
lbl_edad.grid(row=2, column=0, padx=10, pady=10, sticky="e")
lbl_comentario.pack(side="left", fill="both", expand=True, padx=10, pady=10)
# Colocando Entry
entry_nombre.grid(row=0, column=1, padx=10, pady=10)
entry_apellido.grid(row=1, column=1, padx=10, pady=10)
entry_edad.grid(row=2, column=1, padx=10, pady=10)
# Colocando el Text y los Scrollbar
txt_comentario.grid(row=0, column=0, sticky="nsew")
scrolly.grid(row=0, column=1, sticky="ns")
scrollx.grid(row=1, column=0, sticky="ew")
# Colocando el Button
btn_enviar.pack(side="bottom", padx=10, pady=10)
btn_enviar.config(relief="flat")
fr_text.grid_rowconfigure(0, weight=1)
fr_text.grid_columnconfigure(0, weight=1)
# Colocando Frames
fr_top.pack(side="top")
fr_bottom.pack(side="bottom")
fr_text.pack(side="right")
fr_principal.pack(fill="both", expand=True)
# Configurando la raiz
root.title("Prueba Scrollbar")
root.mainloop()
class GUI(Frame):
def __init__(self, game, size, margin, colors=('black', 'white'), master=None):
color = '#333333'
Frame.__init__(self, master, bg=color)
self.game = game
self.cell_size = (size - 2*margin) / self.game.size
self.coordinates = lambda position: self.cell_size * (np.array(position) + 1/2) + margin
self.player_move = lambda event: self.move(pause=1000, event=event)
self.grid()
self.master.title("Pythello")
self.colors = colors[::-1] # Flip color order so that the first color input corresponds to player 1
max_turns = self.game.size**2 - 4
figure = Figure(figsize=(size/100, size/100), dpi=100, facecolor=color)
axes = figure.add_subplot(111, axisbg=color)
self.line = axes.plot(0, 0, 'w-', [0, max_turns], [0, 0], 'w--')[0]
axes.grid(True, color='w')
axes.set_xlim(0, max_turns)
axes.set_ylim(-max_turns, max_turns)
[tick.set_color('w') for axis in [axes.xaxis, axes.yaxis] for tick in axis.get_ticklines()]
[label.set_color('w') for axis in [axes.xaxis, axes.yaxis] for label in axis.get_ticklabels()]
[axes.spines[side].set_color('w') for side in ['top', 'bottom', 'left', 'right']]
self.canvas = Canvas(self, width=size, height=size, background=color, highlightthickness=0)
self.canvas.create_rectangle(margin, margin, size - margin, size - margin, outline='white')
self.canvas.grid(row=0, column=1, rowspan=50)
self.figure = FigureCanvasTkAgg(figure, master=self)
self.figure.get_tk_widget().grid(row=0, column=2, rowspan=50)
self.refresh()
if all([isinstance(player, AI) for player in self.game.players]):
self.play_button = Button(self, text='Play', highlightbackground=color, command=self.play)
self.move_button = Button(self, text='Move', highlightbackground=color, command=self.move)
self.reset_button = Button(self, text='Reset', highlightbackground=color, command=self.reset)
self.play_button.grid(row=0, column=0)
self.move_button.grid(row=1, column=0)
self.reset_button.grid(row=2, column=0)
self.running = False
else:
Button(self, text='Reset', highlightbackground=color, command=self.reset).grid(row=0, column=0)
self.running = True
for i in range(self.game.size):
line_shift = self.cell_size * (i+1) + margin
self.canvas.create_text(margin-10, line_shift - self.cell_size/2, text=str(i+1), fill='white')
self.canvas.create_text(line_shift - self.cell_size/2, margin-10, text=chr(97+i), fill='white')
self.canvas.create_line(margin, line_shift, size - margin, line_shift, fill='white')
self.canvas.create_line(line_shift, margin, line_shift, size - margin, fill='white')
def configure_buttons(self):
(state, text, command) = ('disabled', 'Pause', self.pause) if self.running else ('normal', 'Reset', self.reset)
self.play_button.config(state=state)
self.move_button.config(state=state)
self.reset_button.config(text=text, command=command)
def draw_piece(self, position, radius, color):
(y, x) = self.coordinates(position)
return self.canvas.create_oval(x-radius, y-radius, x+radius, y+radius, fill=color, tags='circle')
def move(self, pause=10, event=None):
if event is None:
move = self.game.player.move(self.game)
else:
move = eval(self.canvas.gettags(event.widget.find_withtag("current"))[-2])
self.game.move(move)
is_over = self.game.is_over()
self.refresh()
if not is_over and isinstance(self.game.player, AI) and self.running:
self.after(pause, self.move)
elif is_over:
self.reset_button.config(text='Reset', command=self.reset)
def pause(self):
self.running = False
self.configure_buttons()
def play(self):
self.running = True
self.configure_buttons()
self.move()
def refresh(self):
self.line.set_data(range(len(self.game.score)), self.game.score)
self.figure.draw()
[self.canvas.delete(tag) for tag in ['circle', 'text']]
for position in zip(*np.nonzero(self.game.board)):
color = self.colors[int((self.game.board[position] + 1) / 2)]
self.draw_piece(position, (self.cell_size-2) / 2, color)
if not isinstance(self.game.player, AI):
for position in self.game.valid:
(y, x) = self.coordinates(position)
turned = len(self.game.valid[position]) - 1
valid = self.draw_piece(position, self.cell_size / 4, 'green')
self.canvas.addtag(str(position), 'withtag', valid)
text = self.canvas.create_text(x+1, y+1, text=str(turned), tags=('text', str(position)))
[self.canvas.tag_bind(tag, "<Button-1>", self.player_move) for tag in [valid, text]]
def reset(self):
self.running = not all([isinstance(player, AI) for player in self.game.players])
self.game.reset()
self.refresh()
if not self.running:
self.configure_buttons()
class h2incGUI:
def __init__(self, master):
self.sourcedir = StringVar()
self.destdir = StringVar()
self.addinc = StringVar()
self.infofolder = 'Number of folders: 0'
self.infofile = 'Number of headers: 0'
self.sourcedir.set('Select source directory!')
self.destdir.set('Select destination directory!')
self.master = master
self.master.title('Translate C-header files to Nasm include files!')
self.master.grid_columnconfigure(1, weight=1)
self.frame = LabelFrame(master, text='Select folders')
self.frame.grid(row=0,
column=0,
columnspan=3,
sticky=N + S + E + W,
padx=5,
pady=5)
self.frame.grid_columnconfigure(1, weight=1)
self.sourcelabel = Label(self.frame, text='Source: ')
self.sourcelabel.grid(row=0, column=0, sticky=E, padx=(5, 1), pady=5)
self.sourceentry = Entry(self.frame, textvariable=self.sourcedir)
self.sourceentry.grid(row=0, column=1, sticky=E + W, pady=5)
self.sourcedir_button = Button(self.frame,
text="Source directory...",
command=lambda: self.select_sourcedir(
self.sourcedir, self.infofiles))
self.sourcedir_button.grid(row=0,
column=2,
sticky=W,
padx=(3, 5),
pady=5)
self.destlabel = Label(self.frame, text='Destination: ')
self.destlabel.grid(row=1, column=0, sticky=E, padx=(5, 1), pady=5)
self.destlabel.config(state=DISABLED)
self.destentry = Entry(self.frame, textvariable=self.destdir)
self.destentry.grid(row=1, column=1, sticky=E + W, pady=5)
self.destentry.config(state=DISABLED)
self.destdir_button = Button(
self.frame,
text="Destination directory...",
command=lambda: self.select_destdir(self.destdir))
self.destdir_button.grid(row=1,
column=2,
sticky=W,
padx=(3, 5),
pady=5)
self.destdir_button.config(state=DISABLED)
self.incchkbox = Checkbutton(
self.frame,
text='Create "include" folder if it does not exist.',
variable=self.addinc,
onvalue='yes',
offvalue='no')
self.incchkbox.grid(row=2,
column=0,
columnspan=2,
sticky=W,
padx=5,
pady=5)
self.incchkbox.config(state=DISABLED)
self.addinc.set('yes')
self.transframe = LabelFrame(master, text='Translation')
self.transframe.grid(row=1,
rowspan=2,
column=0,
columnspan=3,
sticky=N + S + E + W,
padx=5,
pady=5)
self.transframe.grid_columnconfigure(1, weight=1)
self.transframe.grid_rowconfigure(1, weight=1)
self.infoframe = LabelFrame(self.transframe, text='Source information')
self.infoframe.grid(row=1,
rowspan=2,
column=0,
columnspan=3,
sticky=N + S + E + W,
padx=5,
pady=5)
self.infoframe.grid_columnconfigure(1, weight=1)
self.infofolders = Label(self.infoframe, text=self.infofolder)
self.infofolders.grid(row=0, column=0, sticky=W, padx=5, pady=5)
self.infofolders.config(state=DISABLED)
self.infofiles = Label(self.infoframe, text=self.infofile)
self.infofiles.grid(row=1, column=0, sticky=W, padx=5, pady=5)
self.infofiles.config(state=DISABLED)
self.translate_button = Button(
self.transframe,
text="Translate!",
command=lambda: self.select_destdir(self.destdir))
self.translate_button.grid(row=3, column=0, sticky=W, padx=5, pady=5)
self.translate_button.config(state=DISABLED)
def select_sourcedir(self, sourcedir, infofile):
root.directory = os.path.abspath(filedialog.askdirectory())
if root.directory:
sourcedir.set(root.directory)
filecnt = sourcedir_filecnt(root.directory)
if filecnt > 0:
tempstr = 'Number of headers: ' + str(filecnt)
print('Source directory: ', sourcedir.get())
self.destlabel.config(state=NORMAL)
self.destentry.config(state=NORMAL)
self.destdir_button.config(state=NORMAL)
self.infofiles.config(text=tempstr)
foldercnt = sourcedir_foldercnt(root.directory)
if foldercnt > 0:
tempstr = 'Number of folders: ' + str(foldercnt)
self.infofolders.config(text=tempstr)
def select_destdir(self, destdir):
root.directory = filedialog.askdirectory()
if root.directory:
destdir.set(root.directory)
print('Destination directory: ', destdir.get())
self.incchkbox.config(state=NORMAL)
self.infofolders.config(state=NORMAL)
self.infofiles.config(state=NORMAL)
self.translate_button.config(state=NORMAL)
class BackupGuiTk(Frame):
"""
The main widget of the robobackup GUI made with tkinter.
"""
def __init__(self, method=None, master=None):
self.method = method
self.picframe = Frame.__init__(self, master)
self.master.title("Robobackup")
self.image = PhotoImage()
self.image["file"] = os.path.join(os.path.dirname(\
os.path.relpath(__file__)), "resources", "ASK.png")
self.piclabel = Label(self.picframe, image=self.image)
self.piclabel.grid(row=0, column=0, columnspan=4, rowspan=6)
self.clocklabel = Label(self.picframe, text=_("Elapsed time:"))
self.clocklabel.grid(row=0, column=4, sticky="NSEW")
self.clock = Label(self.picframe, text="")
self.clock.grid(row=1, column=4, sticky="NSEW")
self.start = Button(self.picframe, text=_("Start Backup"), command=self.__clk)
self.start.grid(row=3, column=4, sticky="NSEW")
self.errorlabel = Label(self.picframe)
self.errorlabel.grid(row=4, column=4, sticky="NSEW")
self.close = Button(self.picframe, text=_("Close"), command=self.__cls)
self.close.grid(row=5, column=4, sticky="NSEW")
self.loglabel = Label(self.picframe, text=_("Log:"), justify="left")
self.loglabel.grid(row=6, column=0, columnspan=5, sticky="NSEW")
self.text = Text(self.picframe)
self.text.grid(row=7, column=0, rowspan=6, columnspan=5, sticky="NSEW")
self.timeout = False
self.starttime = -1
def __clk(self):
"""
This method starts the backup. It is a slot which is connected
to the signal "click" of the button "btnStart".
"""
self.start.config(state="disabled")
self.close.config(state="disabled")
self.clock_tick()
try:
self.method()
except:
if __debug__:
logbook.exception("")
self.set_backup_failure()
messagebox.showinfo(_("Critical"), _("Robobackup " \
"failed. Contact your admin."))
finally:
self.timeout = True
self.close.config(state="normal")
def __cls(self):
"""
This method is used to close the GUI.
"""
self.master.destroy()
def clock_tick(self):
"""
This is used to count the seconds the backup method runs.
"""
if not self.timeout:
self.starttime = int(time.time() * 1000)
milliseconds = int(time.time() * 1000) - self.starttime
seconds, milliseconds = divmod(milliseconds, 1000)
minutes, seconds = divmod(seconds, 60)
hours, minutes = divmod(minutes, 60)
digitalclock = "{hh:02d}:{mm:02d}:{ss:02d}".format(hh=hours, \
mm=minutes, ss=seconds)
self.clock.configure(text=digitalclock)
if not self.timeout:
self.master.after(1000, self.clock_tick)
def update(self):
"""
This method will be called, if logs are changing.
"""
color = logbook.get_severity()
self.set_log(logbook.get_string())
if color is Severity.green:
self.set_backup_success()
elif color is Severity.orange:
self.set_backup_check()
elif color is Severity.red:
self.set_backup_failure()
else:
raise RuntimeError(_("Color does not match an action."))
def set_backup_success(self):
"""
Set everything green.
"""
self.errorlabel.configure(text=_("Success"))
self.errorlabel["bg"] = "green"
self.image["file"] = os.path.join(os.path.dirname(\
os.path.relpath(__file__)), "resources", "SUCCESS.png")
def set_backup_check(self):
"""
Set everything orange.
"""
self.errorlabel.configure(text=_("Check backup"))
self.errorlabel["bg"] = "orange"
self.image["file"] = os.path.join(os.path.dirname(\
os.path.relpath(__file__)), "resources", "CHECK.png")
def set_backup_failure(self):
"""
Set everything red.
"""
self.errorlabel.configure(text=_("Failure"))
self.errorlabel["bg"] = "red"
self.image["file"] = os.path.join(os.path.dirname(\
os.path.relpath(__file__)), "resources", "FAIL.png")
def set_log(self, log):
"""
Write text to the GUI.
"""
self.text.delete("1.0", END)
self.text.insert(END, log)
def view_details(self, Medikom, id):
self.selected_id = id
self.overview(Medikom)
entry_results, attachments = Medikom.get_entry(id)
ts, title, notes = entry_results
ts = self.format_ts(ts)[:-3]
details_text = 'Details zu %s (zuletzt geändert am %s)' % (title, ts)
details_label = Label(
self, text=details_text, font='Liberation 10', fg='Black', anchor='w')
details_label.place(
x=self.SPACE_TWO,
y=(self.n + 2) * (self.ROW_HIGHT + self.ROW_SPACE),
width=self.WIN_WIDTH - self.SPACE_TWO, height=self.ROW_HIGHT)
details_label.bind(sequence='<Button-1>',
func=Callable(self.view_edit_title, Medikom, id, title))
# add attachment button and list attachments
attach_button = Button(
self, text='Neuer Anhang',
command=lambda: self.attach_file(Medikom, id))
attach_button.place(
x=self.SPACE_TWO,
y=(self.n + 3) * (self.ROW_HIGHT + self.ROW_SPACE),
width=self.WIN_WIDTH / 8, height=self.ROW_HIGHT)
if attachments:
xpos = (1.5 * self.SPACE_TWO) + (self.WIN_WIDTH / 8)
for i, attachment in enumerate(attachments):
attachment = attachment[0]
filename = ''
if '\\' in attachment:
filename = attachment.split('\\')[-1]
elif '/' in attachment:
filename = attachment.split('/')[-1]
width = len(filename) * 7.2
attachment_button = Button(
self, text=filename, font='Courier 9', fg="blue",
command=Callable(self.open_attachment, attachment))
attachment_button.place(
x=xpos,
y=(self.n + 3) * (self.ROW_HIGHT + self.ROW_SPACE),
width=width, height=self.ROW_HIGHT)
xpos = xpos + width + (self.SPACE_TWO/2)
attachment_button.config(relief='flat')
attachment_button.bind(sequence='<Button-3>',
func=Callable(self.unattach_file, Medikom, id, attachment))
# text element and scrollbar
textframe = Text(
self, font='Liberation 12', height=self.TEXT_FRAME_LINES,
width=int(self.WIN_WIDTH / 4))
scrollbar = Scrollbar(self)
textframe.place(
x=self.SPACE_TWO,
y=(self.n + 4) * (self.ROW_HIGHT + self.ROW_SPACE),
width=self.WIN_WIDTH - self.SPACE_ONE - 10,
height=self.ROW_HIGHT * self.TEXT_FRAME_LINES)
scrollbar.place(
x=self.SPACE_TWO + self.WIN_WIDTH - self.SPACE_ONE - 10,
y=(self.n + 4) * (self.ROW_HIGHT + self.ROW_SPACE),
width=10,
height=self.ROW_HIGHT * self.TEXT_FRAME_LINES)
scrollbar.config(command=textframe.yview)
textframe.config(yscrollcommand=scrollbar.set)
textframe.insert(END, notes)
# update button
update_button = Button(
self, text='Text Aktualisieren',
command=lambda: self.update_entry_notes(
Medikom, id, textframe.get(1.0, END)))
update_button.place(
x=self.WIN_WIDTH / 2 - 0.125 * self.WIN_WIDTH,
y=(self.n + 4) * (self.ROW_HIGHT + self.ROW_SPACE) + (self.ROW_HIGHT * self.TEXT_FRAME_LINES + 5),
width=self.WIN_WIDTH/4, height=self.ROW_HIGHT)
class LintGui:
"""Build and control a window to interact with pylint"""
def __init__(self, root=None):
"""init"""
self.root = root or Tk()
self.root.title("Pylint")
# reporter
self.reporter = None
# message queue for output from reporter
self.msg_queue = queue.Queue()
self.msgs = []
self.filenames = []
self.rating = StringVar()
self.tabs = {}
self.report_stream = BasicStream(self)
# gui objects
self.lbMessages = None
self.showhistory = None
self.results = None
self.btnRun = None
self.information_box = None
self.convention_box = None
self.refactor_box = None
self.warning_box = None
self.error_box = None
self.fatal_box = None
self.txtModule = None
self.status = None
self.msg_type_dict = None
self.init_gui()
def init_gui(self):
"""init helper"""
# setting up frames
top_frame = Frame(self.root)
mid_frame = Frame(self.root)
radio_frame = Frame(self.root)
res_frame = Frame(self.root)
msg_frame = Frame(self.root)
check_frame = Frame(self.root)
history_frame = Frame(self.root)
btn_frame = Frame(self.root)
rating_frame = Frame(self.root)
top_frame.pack(side=TOP, fill=X)
mid_frame.pack(side=TOP, fill=X)
history_frame.pack(side=TOP, fill=BOTH, expand=True)
radio_frame.pack(side=TOP, fill=BOTH, expand=True)
rating_frame.pack(side=TOP, fill=BOTH, expand=True)
res_frame.pack(side=TOP, fill=BOTH, expand=True)
check_frame.pack(side=TOP, fill=BOTH, expand=True)
msg_frame.pack(side=TOP, fill=BOTH, expand=True)
btn_frame.pack(side=TOP, fill=X)
# Message ListBox
rightscrollbar = Scrollbar(msg_frame)
rightscrollbar.pack(side=RIGHT, fill=Y)
bottomscrollbar = Scrollbar(msg_frame, orient=HORIZONTAL)
bottomscrollbar.pack(side=BOTTOM, fill=X)
self.lbMessages = Listbox(
msg_frame, yscrollcommand=rightscrollbar.set, xscrollcommand=bottomscrollbar.set, bg="white"
)
self.lbMessages.pack(expand=True, fill=BOTH)
rightscrollbar.config(command=self.lbMessages.yview)
bottomscrollbar.config(command=self.lbMessages.xview)
# History ListBoxes
rightscrollbar2 = Scrollbar(history_frame)
rightscrollbar2.pack(side=RIGHT, fill=Y)
bottomscrollbar2 = Scrollbar(history_frame, orient=HORIZONTAL)
bottomscrollbar2.pack(side=BOTTOM, fill=X)
self.showhistory = Listbox(
history_frame, yscrollcommand=rightscrollbar2.set, xscrollcommand=bottomscrollbar2.set, bg="white"
)
self.showhistory.pack(expand=True, fill=BOTH)
rightscrollbar2.config(command=self.showhistory.yview)
bottomscrollbar2.config(command=self.showhistory.xview)
self.showhistory.bind("<Double-Button-1>", self.select_recent_file)
self.set_history_window()
# status bar
self.status = Label(self.root, text="", bd=1, relief=SUNKEN, anchor=W)
self.status.pack(side=BOTTOM, fill=X)
# labels
self.lblRatingLabel = Label(rating_frame, text="Rating:")
self.lblRatingLabel.pack(side=LEFT)
self.lblRating = Label(rating_frame, textvariable=self.rating)
self.lblRating.pack(side=LEFT)
Label(mid_frame, text="Recently Used:").pack(side=LEFT)
Label(top_frame, text="Module or package").pack(side=LEFT)
# file textbox
self.txtModule = Entry(top_frame, background="white")
self.txtModule.bind("<Return>", self.run_lint)
self.txtModule.pack(side=LEFT, expand=True, fill=X)
# results box
rightscrollbar = Scrollbar(res_frame)
rightscrollbar.pack(side=RIGHT, fill=Y)
bottomscrollbar = Scrollbar(res_frame, orient=HORIZONTAL)
bottomscrollbar.pack(side=BOTTOM, fill=X)
self.results = Listbox(
res_frame, yscrollcommand=rightscrollbar.set, xscrollcommand=bottomscrollbar.set, bg="white", font="Courier"
)
self.results.pack(expand=True, fill=BOTH, side=BOTTOM)
rightscrollbar.config(command=self.results.yview)
bottomscrollbar.config(command=self.results.xview)
# buttons
Button(top_frame, text="Open", command=self.file_open).pack(side=LEFT)
Button(top_frame, text="Open Package", command=(lambda: self.file_open(package=True))).pack(side=LEFT)
self.btnRun = Button(top_frame, text="Run", command=self.run_lint)
self.btnRun.pack(side=LEFT)
Button(btn_frame, text="Quit", command=self.quit).pack(side=BOTTOM)
# radio buttons
self.information_box = IntVar()
self.convention_box = IntVar()
self.refactor_box = IntVar()
self.warning_box = IntVar()
self.error_box = IntVar()
self.fatal_box = IntVar()
i = Checkbutton(
check_frame,
text="Information",
fg=COLORS["(I)"],
variable=self.information_box,
command=self.refresh_msg_window,
)
c = Checkbutton(
check_frame,
text="Convention",
fg=COLORS["(C)"],
variable=self.convention_box,
command=self.refresh_msg_window,
)
r = Checkbutton(
check_frame, text="Refactor", fg=COLORS["(R)"], variable=self.refactor_box, command=self.refresh_msg_window
)
w = Checkbutton(
check_frame, text="Warning", fg=COLORS["(W)"], variable=self.warning_box, command=self.refresh_msg_window
)
e = Checkbutton(
check_frame, text="Error", fg=COLORS["(E)"], variable=self.error_box, command=self.refresh_msg_window
)
f = Checkbutton(
check_frame, text="Fatal", fg=COLORS["(F)"], variable=self.fatal_box, command=self.refresh_msg_window
)
i.select()
c.select()
r.select()
w.select()
e.select()
f.select()
i.pack(side=LEFT)
c.pack(side=LEFT)
r.pack(side=LEFT)
w.pack(side=LEFT)
e.pack(side=LEFT)
f.pack(side=LEFT)
# check boxes
self.box = StringVar()
# XXX should be generated
report = Radiobutton(
radio_frame, text="Report", variable=self.box, value="Report", command=self.refresh_results_window
)
rawMet = Radiobutton(
radio_frame, text="Raw metrics", variable=self.box, value="Raw metrics", command=self.refresh_results_window
)
dup = Radiobutton(
radio_frame, text="Duplication", variable=self.box, value="Duplication", command=self.refresh_results_window
)
ext = Radiobutton(
radio_frame,
text="External dependencies",
variable=self.box,
value="External dependencies",
command=self.refresh_results_window,
)
stat = Radiobutton(
radio_frame,
text="Statistics by type",
variable=self.box,
value="Statistics by type",
command=self.refresh_results_window,
)
msgCat = Radiobutton(
radio_frame,
text="Messages by category",
variable=self.box,
value="Messages by category",
command=self.refresh_results_window,
)
msg = Radiobutton(
radio_frame, text="Messages", variable=self.box, value="Messages", command=self.refresh_results_window
)
report.select()
report.grid(column=0, row=0, sticky=W)
rawMet.grid(column=1, row=0, sticky=W)
dup.grid(column=2, row=0, sticky=W)
msg.grid(column=3, row=0, sticky=E)
stat.grid(column=0, row=1, sticky=W)
msgCat.grid(column=1, row=1, sticky=W)
ext.grid(column=2, row=1, columnspan=2, sticky=W)
# dictionary for check boxes and associated error term
self.msg_type_dict = {
"I": lambda: self.information_box.get() == 1,
"C": lambda: self.convention_box.get() == 1,
"R": lambda: self.refactor_box.get() == 1,
"E": lambda: self.error_box.get() == 1,
"W": lambda: self.warning_box.get() == 1,
"F": lambda: self.fatal_box.get() == 1,
}
self.txtModule.focus_set()
def select_recent_file(self, event):
"""adds the selected file in the history listbox to the Module box"""
if not self.showhistory.size():
return
selected = self.showhistory.curselection()
item = self.showhistory.get(selected)
# update module
self.txtModule.delete(0, END)
self.txtModule.insert(0, item)
def refresh_msg_window(self):
"""refresh the message window with current output"""
# clear the window
self.lbMessages.delete(0, END)
for msg in self.msgs:
if self.msg_type_dict.get(msg[0])():
msg_str = self.convert_to_string(msg)
self.lbMessages.insert(END, msg_str)
fg_color = COLORS.get(msg_str[:3], "black")
self.lbMessages.itemconfigure(END, fg=fg_color)
def refresh_results_window(self):
"""refresh the results window with current output"""
# clear the window
self.results.delete(0, END)
try:
for res in self.tabs[self.box.get()]:
self.results.insert(END, res)
except:
pass
def convert_to_string(self, msg):
"""make a string representation of a message"""
if msg[2] != "":
return "(" + msg[0] + ") " + msg[1] + "." + msg[2] + " [" + msg[3] + "]: " + msg[4]
else:
return "(" + msg[0] + ") " + msg[1] + " [" + msg[3] + "]: " + msg[4]
def process_incoming(self):
"""process the incoming messages from running pylint"""
while self.msg_queue.qsize():
try:
msg = self.msg_queue.get(0)
if msg == "DONE":
self.report_stream.output_contents()
return False
# adding message to list of msgs
self.msgs.append(msg)
# displaying msg if message type is selected in check box
if self.msg_type_dict.get(msg[0])():
msg_str = self.convert_to_string(msg)
self.lbMessages.insert(END, msg_str)
fg_color = COLORS.get(msg_str[:3], "black")
self.lbMessages.itemconfigure(END, fg=fg_color)
except queue.Empty:
pass
return True
def periodic_call(self):
"""determine when to unlock the run button"""
if self.process_incoming():
self.root.after(100, self.periodic_call)
else:
# enabling button so it can be run again
self.btnRun.config(state=NORMAL)
def mainloop(self):
"""launch the mainloop of the application"""
self.root.mainloop()
def quit(self, _=None):
"""quit the application"""
self.root.quit()
def halt(self):
"""program halt placeholder"""
return
def file_open(self, package=False, _=None):
"""launch a file browser"""
if not package:
filename = askopenfilename(
parent=self.root, filetypes=[("pythonfiles", "*.py"), ("allfiles", "*")], title="Select Module"
)
else:
filename = askdirectory(title="Select A Folder", mustexist=1)
if filename == ():
return
self.txtModule.delete(0, END)
self.txtModule.insert(0, filename)
def update_filenames(self):
"""update the list of recent filenames"""
filename = self.txtModule.get()
if not filename:
filename = os.getcwd()
if filename + "\n" in self.filenames:
index = self.filenames.index(filename + "\n")
self.filenames.pop(index)
# ensure only 10 most recent are stored
if len(self.filenames) == 10:
self.filenames.pop()
self.filenames.insert(0, filename + "\n")
def set_history_window(self):
"""update the history window with info from the history file"""
# clear the window
self.showhistory.delete(0, END)
# keep the last 10 most recent files
try:
view_history = open(HOME + HISTORY, "r")
for hist in view_history.readlines():
if not hist in self.filenames:
self.filenames.append(hist)
self.showhistory.insert(END, hist.split("\n")[0])
view_history.close()
except IOError:
# do nothing since history file will be created later
return
def run_lint(self, _=None):
"""launches pylint"""
self.update_filenames()
self.root.configure(cursor="watch")
self.reporter = GUIReporter(self, output=self.report_stream)
module = self.txtModule.get()
if not module:
module = os.getcwd()
# cleaning up msgs and windows
self.msgs = []
self.lbMessages.delete(0, END)
self.tabs = {}
self.results.delete(0, END)
self.btnRun.config(state=DISABLED)
# setting up a worker thread to run pylint
worker = Thread(target=lint_thread, args=(module, self.reporter, self))
self.periodic_call()
worker.start()
# Overwrite the .pylint-gui-history file with all the new recently added files
# in order from filenames but only save last 10 files
write_history = open(HOME + HISTORY, "w")
write_history.writelines(self.filenames)
write_history.close()
self.set_history_window()
self.root.configure(cursor="")
class Convert_Table_Auto(Frame):
def __init__(self, master=None):
self.cur_dir = os.getcwd()
Frame.__init__(self, master)
self.master = master
window_width = 460
window_heigh = 510
x_pos = (screen_width / 2) - (window_width / 2)
y_pos = (screen_heigh / 2) - (window_heigh / 2)
# self.master.geometry("420x200")
self.master.geometry('%dx%d+%d+%d' %
(window_width, window_heigh, x_pos, y_pos))
self.master.title("Conver Table Automation")
######################################################################################################
self.config_file_PATH_label = Label(self.master,
text="4G Config file path")
self.config_file_PATH_label.grid(row=0, column=0, sticky=W, pady=2)
self.config_file_PATH_txt = Text(self.master, heigh=1, width=35)
self.config_file_PATH_txt.grid(row=0, column=1, pady=2)
self.config_file_PATH_label_5g = Label(self.master,
text="5G Config file path")
self.config_file_PATH_label_5g.grid(row=1, column=0, sticky=W, pady=2)
self.config_file_5g_PATH_txt = Text(self.master, heigh=1, width=35)
self.config_file_5g_PATH_txt.grid(row=1, column=1, pady=2)
self.log_file_PATH_label = Label(self.master, text="Log files dir")
self.log_file_PATH_label.grid(row=2, column=0, sticky=W, pady=2)
self.log_file_PATH_txt = Text(self.master, heigh=1, width=35)
self.log_file_PATH_txt.grid(row=2, column=1, pady=2)
self.qcat_input_label = Label(self.master, text='')
self.log_type_label = Label(self.master, text="Information")
self.log_type_label.grid(row=3, column=0, sticky=W)
self.log_type_txt = ScrolledText(self.master, undo=True, width=55)
self.log_type_txt.grid(row=3,
rowspan=4,
column=0,
columnspan=3,
sticky=W)
self.csv_dir_label = Label(self.master, text="CSV directory")
self.csv_dir_label.grid(row=9, column=0, sticky=W)
self.csv_dir_txt = Text(self.master, heigh=1, width=35)
self.csv_dir_txt.grid(row=9, column=0, columnspan=3, padx=80, sticky=W)
######################################################################################################
self.convert_csv_button = Button(self.master,
text='Convert to csv',
command=self.call_convert_csv)
self.convert_csv_button.grid(row=9,
column=1,
columnspan=2,
sticky=E,
pady=2,
padx=3)
self.convert_csv_button.config(width=11, heigh=2)
self.extract_config_button = Button(self.master,
text="Extract",
command=self.call_extract)
self.extract_config_button.grid(row=0, column=2, sticky=E, padx=4)
# self.view_log_button = Button(self.master, text = "View")
# self.view_log_button.grid(row=1, column=2, sticky=E, padx=4)
###############################################################################
# creating a menu instance
self.menu = Menu(self.master)
self.master.config(menu=self.menu)
# create the file object)
self.file = Menu(self.menu)
# adds a command to the menu option, calling it exit, and the
# command it runs on event is client_exit
# self.file.add_command(label="QCAT Automation", command = self.openQCAT)
self.file.add_command(label="Open Config 4G", command=self.open_config)
self.file.add_command(label="Open Config 5G",
command=self.open_config_5g)
self.file.add_command(label="Choose Log Files", command=self.open_log)
self.file.add_command(label="Set CSV Directory",
command=self.set_csv_directory)
self.file.add_command(label="Exit", command=self.client_exit)
self.menu.add_cascade(label="File", menu=self.file)
# menu.add_cascade(label="Open config", menu=file)
self.edit = Menu(self.menu)
self.menu.add_cascade(label="Edit", menu=self.edit)
self.help = Menu(self.menu)
self.help.add_command(label="About", command=self.show_about)
self.help.add_command(label="Instruction",
command=self.show_instruction)
self.menu.add_cascade(label="Help", menu=self.help)
####################################################################################
def client_exit(self):
exit()
def is_uniconfig(self):
if self.config_file_PATH_txt.get(
'1.0', END) != '\n' and self.config_file_5g_PATH_txt.get(
'1.0', END) != '\n':
self.config_file_5g_PATH_txt.delete("1.0", "end")
return False
else:
return True
def open_config(self):
###Test
# global config_file_PATH
# config_file_PATH = r'G:\PycharmProjects\Log_Extractor\parser.cfg'
if self.cur_dir == None:
self.cur_dir = os.getcwd()
filename = askopenfilename(initialdir=self.cur_dir,
title="Select file",
filetypes=(("config file", "*.cfg"),
("all files", "*.*")))
if filename:
global config_file_PATH
config_file_PATH = filename
print(config_file_PATH)
# self.update_text()
self.config_file_PATH_txt.delete("1.0", "end")
self.config_file_5g_PATH_txt.delete("1.0", "end")
self.config_file_PATH_txt.insert(END, config_file_PATH)
else:
showerror("Error", "No file selected")
if self.is_uniconfig() == False:
showerror("Error", "Cannot choose more than two config files!!!")
def open_config_5g(self):
###Test
# global config_file_PATH
# config_file_PATH = r'G:\PycharmProjects\Log_Extractor\parser.cfg'
if self.cur_dir == None:
self.cur_dir = os.getcwd()
filename = askopenfilename(initialdir=self.cur_dir,
title="Select file",
filetypes=(("config file", "*.cfg"),
("all files", "*.*")))
if filename:
global config_file_PATH
config_file_PATH = filename
print(config_file_PATH)
# self.update_text()
self.config_file_PATH_txt.delete("1.0", "end")
self.config_file_5g_PATH_txt.delete("1.0", "end")
self.config_file_5g_PATH_txt.insert(END, config_file_PATH)
else:
showerror("Error", "No file selected")
if self.is_uniconfig() == False:
showerror("Error", "Cannot choose more than one config file!!!")
def open_log(self):
# Test
# global log_file_PATH
# log_file_PATH = r'G:\PycharmProjects\Log_Extractor\Test\log_test.txt'
if self.cur_dir == None:
self.cur_dir = os.getcwd()
log_paths = askopenfilenames(initialdir=self.cur_dir,
title="Select file",
filetypes=(("log file", "*.log *txt"),
("text file", "*.txt"),
("all files", "*.*")))
# log_path = askdirectory()
if log_paths:
global log_file_PATH
for path in log_paths:
log_file_PATH.append(path)
# log_file_PATH = log_paths
print(log_paths)
self.log_file_PATH_txt.delete("1.0", "end")
self.log_file_PATH_txt.insert(END, log_file_PATH)
else:
showerror("Error", "No file selected")
def set_csv_directory(self):
csv_dir = askdirectory()
if csv_dir:
global csv_folder_PATH
csv_folder_PATH = csv_dir
self.csv_dir_txt.delete("1.0", "end")
self.csv_dir_txt.insert(END, csv_dir)
else:
showerror("Error", "No directory selected")
##Test'
# global csv_folder_PATH
# csv_folder_PATH = r'C:\Users\Admin\Desktop\test'
def call_extract(self):
global config_file_PATH
global log_type_list_brief, log_type_list_full
# if config_file_PATH == '':
# self.log_type_txt.insert("Error, No file selected")
# # showerror("Error", "No file selected")
# return
try:
self.log_type_txt.delete("1.0", "end")
self.log_type_txt.insert(END, "Extracting...\n")
lines = read_file(config_file_PATH)
log_type_list_brief, log_type_list_full, grids = read_config_log_types(
lines)
if len(log_type_list_brief) != 0:
# self.log_type_txt.delete("1.0", "end")
self.log_type_txt.insert(END, '\n#Packets\n')
for log in log_type_list_brief:
self.log_type_txt.insert(END, log + '\n')
if len(grids) != 0:
self.log_type_txt.insert(END, '\n#Grids\n')
for grid in grids.keys():
self.log_type_txt.insert(END, grid + '\n')
self.log_type_txt.insert(END, "\nExtract successfully!!!\n")
# showinfo("Respond", "Extract successfully")
else:
showwarning("Config Empty",
"No log type found in config file. Try again!")
except:
# self.log_type_txt.delete("1.0", "end")
self.log_type_txt.insert(END, "Error extracting\n")
def call_convert_csv(self):
global csv_dict, csv_folder_PATH, log_file_PATH, log_type_list_brief, config_file_PATH
print(log_type_list_brief)
if csv_folder_PATH == '':
self.log_type_txt.insert(
END, "You need to select csv directory before convert\n")
return
try:
#TODO: Fix error: No grid name 'LTE Serving Cell Meas vs .TIme)
# Filter signaling message
from tool_summary import concat_signaling
self.log_type_txt.insert(END, "Filtering signal packets...\n")
for log in log_file_PATH:
concat_signaling(config_file_PATH, log, csv_folder_PATH)
self.log_type_txt.insert(END, "Exported signal packets!\n")
# Convert CSV
self.log_type_txt.insert(END, "Converting! Please wait...\n")
for t in log_type_list_brief: # init dict of log data list for csv
csv_dict[t] = [0, []]
for path in log_file_PATH:
parse_log(path, log_type_list_brief, csv_dict)
write_csv(csv_folder_PATH, csv_dict)
self.log_type_txt.insert(END, "Converting successful\n")
except:
self.log_type_txt.insert(END, "Fail converting!\n")
# showerror("Error", "Error Converting")
# def openQCAT(self):
# self.newWindow = Toplevel(self.master)
# self.app = QCAT_Auto(self.newWindow)
def show_instruction(self):
pass
def show_about(self):
pass
class Momentary:
def __init__(self, master, valves):
self.valves = valves
self.master = master
self.frame1 = Frame(master)
self.frame2 = Frame(master)
self.master.configure(bg='sky blue')
self.frame1.configure(bg='sky blue')
self.frame2.configure(bg='sky blue')
index = 0
while index < 6:
self.frame1.grid_columnconfigure(index, minsize=6)
self.frame2.grid_columnconfigure(index, minsize=6)
self.frame1.grid_rowconfigure(index, minsize=140)
self.frame2.grid_rowconfigure(index, minsize=140)
index += 1
self.end_all_image = PhotoImage(file="img/stop.png").subsample(x=6, y=6)
self.end_all_button = Button(self.master, image=self.end_all_image, command=lambda: self.end_all() )
self.end_all_button.config(bg='brown3', activebackground='brown4', border=5, width=850)
self.label = [Label(self.frame1, textvariable=self.valves[0].get_name()),
Label(self.frame1, textvariable=self.valves[1].get_name()),
Label(self.frame1, textvariable=self.valves[2].get_name()),
Label(self.frame1, textvariable=self.valves[3].get_name()),
Label(self.frame2, textvariable=self.valves[4].get_name()),
Label(self.frame2, textvariable=self.valves[5].get_name()),
Label(self.frame2, textvariable=self.valves[6].get_name()),
Label(self.frame2, textvariable=self.valves[7].get_name())]
row = 0
for each in self.label:
each.config(width=7, height=2)
each.config(bg='sky blue', fg='RoyalBlue4', font=('Lucida Console', 30), padx=18)
each.grid(row=row % 4, column=0)
row += 1
self.lightsA = [LED(self.frame1, 30, 'green1', 'green', 'dark green', 'Dark Green', False),
LED(self.frame1, 30, 'green1', 'green', 'dark green', 'Dark Green', False),
LED(self.frame1, 30, 'green1', 'green', 'dark green', 'Dark Green', False),
LED(self.frame1, 30, 'green1', 'green', 'dark green', 'Dark Green', False),
LED(self.frame2, 30, 'green1', 'green', 'dark green', 'Dark Green', False),
LED(self.frame2, 30, 'green1', 'green', 'dark green', 'Dark Green', False),
LED(self.frame2, 30, 'green1', 'green', 'dark green', 'Dark Green', False),
LED(self.frame2, 30, 'green1', 'green', 'dark green', 'Dark Green', False)
]
self.lightsB = [LED(self.frame1, 30, 'red', 'dark red', 'red4', 'DarkRed', False),
LED(self.frame1, 30, 'red', 'dark red', 'red4', 'DarkRed', False),
LED(self.frame1, 30, 'red', 'dark red', 'red4', 'DarkRed', False),
LED(self.frame1, 30, 'red', 'dark red', 'red4', 'DarkRed', False),
LED(self.frame2, 30, 'red', 'dark red', 'red4', 'DarkRed', False),
LED(self.frame2, 30, 'red', 'dark red', 'red4', 'DarkRed', False),
LED(self.frame2, 30, 'red', 'dark red', 'red4', 'DarkRed', False),
LED(self.frame2, 30, 'red', 'dark red', 'red4', 'DarkRed', False)
]
self.v = [IntVar(),
IntVar(),
IntVar(),
IntVar(),
IntVar(),
IntVar(),
IntVar(),
IntVar()]
for each in self.v:
each.set(3)
self.a = [Radiobutton(self.frame1, text='A', command=lambda: self.activate_a(0), value=1),
Radiobutton(self.frame1, text='A', command=lambda: self.activate_a(1), value=1),
Radiobutton(self.frame1, text='A', command=lambda: self.activate_a(2), value=1),
Radiobutton(self.frame1, text='A', command=lambda: self.activate_a(3), value=1),
Radiobutton(self.frame2, text='A', command=lambda: self.activate_a(4), value=1),
Radiobutton(self.frame2, text='A', command=lambda: self.activate_a(5), value=1),
Radiobutton(self.frame2, text='A', command=lambda: self.activate_a(6), value=1),
Radiobutton(self.frame2, text='A', command=lambda: self.activate_a(7), value=1)]
index = 0
for each in self.a:
each.grid(row=index % 4, column=2)
each.config(width=4, height=2, indicatoron=0, variable=self.v[index], font=('Lucida Console', 30))
each.config(bg='SkyBlue4', activebackground='midnight blue', selectcolor='midnight blue', fg='white')
each.config(activeforeground='white')
index += 1
self.b = [Radiobutton(self.frame1, text='B', command=lambda: self.activate_b(0), value=0),
Radiobutton(self.frame1, text='B', command=lambda: self.activate_b(1), value=0),
Radiobutton(self.frame1, text='B', command=lambda: self.activate_b(2), value=0),
Radiobutton(self.frame1, text='B', command=lambda: self.activate_b(3), value=0),
Radiobutton(self.frame2, text='B', command=lambda: self.activate_b(4), value=0),
Radiobutton(self.frame2, text='B', command=lambda: self.activate_b(5), value=0),
Radiobutton(self.frame2, text='B', command=lambda: self.activate_b(6), value=0),
Radiobutton(self.frame2, text='B', command=lambda: self.activate_b(7), value=0)]
index = 0
for each in self.b:
each.grid(row=index % 4, column=3)
each.config(width=4, height=2, indicatoron=0, variable=self.v[index], font=('Lucida Console', 30))
each.config(bg='SkyBlue4', activebackground='midnight blue', selectcolor='midnight blue', fg='white')
each.config(activeforeground='white')
index += 1
self.end_image = PhotoImage(file="img/no.png").subsample(x=6, y=6)
self.end_button = [Radiobutton(self.frame1, image=self.end_image, command=lambda: self.end(0)),
Radiobutton(self.frame1, image=self.end_image, command=lambda: self.end(1)),
Radiobutton(self.frame1, image=self.end_image, command=lambda: self.end(2)),
Radiobutton(self.frame1, image=self.end_image, command=lambda: self.end(3)),
Radiobutton(self.frame2, image=self.end_image, command=lambda: self.end(4)),
Radiobutton(self.frame2, image=self.end_image, command=lambda: self.end(5)),
Radiobutton(self.frame2, image=self.end_image, command=lambda: self.end(6)),
Radiobutton(self.frame2, image=self.end_image, command=lambda: self.end(7)),
]
index = 0
for each in self.end_button:
each.grid(row=index % 4, column=5)
each.config(value=2, variable=self.v[index], indicatoron=0)
each.config(bg='brown3', activebackground='brown4')
index += 1
def make_frame(self):
self.frame1.grid(row=2, column=0, rowspan=5)
self.frame2.grid(row=2, column=1, rowspan=5)
self.end_all_button.grid(row=1, column=0, columnspan=2)
row = 0
for each in self.lightsA:
each.grid(row=row % 4, column=1, padx=20, pady=20)
row += 1
row = 0
for each in self.lightsB:
each.grid(row=row % 4, column=4, padx=20, pady=20)
row += 1
def delete_frame(self):
self.frame1.grid_remove()
self.frame2.grid_remove()
self.end_all_button.grid_remove()
for each in self.lightsA:
each.grid_remove()
for each in self.lightsB:
each.grid_remove()
def activate_a(self, number):
pin_number = 65 + number
pin_opposite = 80 - number
if self.v[number].get() == 1:
self.lightsA[number].set_state(True)
self.lightsB[number].set_state(False)
wiringpi.digitalWrite(pin_number, 1)
wiringpi.digitalWrite(pin_opposite, 0)
def activate_b(self, number):
pin_number = 80 - number
pin_opposite = 65 + number
if self.v[number].get() == 0:
self.lightsA[number].set_state(False)
self.lightsB[number].set_state(True)
wiringpi.digitalWrite(pin_number, 1)
wiringpi.digitalWrite(pin_opposite, 0)
def end(self, number):
pin_number = 65 + number
pin_opposite = 80 - number
wiringpi.digitalWrite(pin_number, 0)
wiringpi.digitalWrite(pin_opposite, 0)
self.v[number].set(3)
self.lightsA[number].set_state(False)
self.lightsB[number].set_state(False)
def end_all(self):
number = 0
while number < 8:
self.end(number)
number += 1
class EguanaGUI(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.initUI()
# if not EguanaInit.eguana_root_dir_exists():
# EguanaInit.create_eguana_root_dir()
def initUI(self):
self.parent.title("EGUANA")
self.style = ttk.Style()
self.style.theme_use("alt")
self.photoName = "eguana.gif"
self.frame = Frame(self, relief=FLAT, borderwidth=10,bg='#FADC46')
self.frame.pack(fill=BOTH, expand=True)
self.pack(fill=BOTH, expand=True)
self.setupMenuBar()
self.setupTopBar()
def setupMenuBar(self):
self.menubar = EguanaMenu(self.parent,self)
self.parent.config(menu=self.menubar)
def setupTopBar(self):
self.supportedDevices = []
for fileName in [name for name in os.listdir('./machineConfig') if os.path.isfile('./machineConfig/' + name) and not name == 'eguanaMachineConfig.py' and name.endswith('.py')]:
# try:{
components = fileName.split('.')
fileName = components[0]
className = fileName[0].upper() + fileName[1:]
try:
module = __import__("machineConfig."+fileName,fromlist=["machineConfig."])
classVar = getattr(module,className)
except:
continue
self.supportedDevices.append(classVar())
# except:
# pass
self.selectMachineFrame = Frame(self.frame,relief=FLAT,bg='#FADC46')
self.selectMachineFrame.pack(fill=BOTH,expand=True)
self.setupSelectMachineButtons()
def setupSelectMachineButtons(self):
numDevices = len(self.supportedDevices)
numColumns = 3
numRows = math.ceil((numDevices+1)/3)
self.photo = PhotoImage(file="eguana.gif")
self.photo = self.photo.subsample(2);
self.photo_label = Label(self.selectMachineFrame,image=self.photo,borderwidth=0,highlightthickness=0)
self.photo_label.configure(bg='#FADC46')
self.photo_label.grid(row=int(numRows/2),column=1, sticky=N+S+E+W,padx=2,pady =2)
self.photo_label.image = self.photo
index = 0
for i in range(numRows):
for j in range(numColumns):
if not(j == 1 and i == int(numRows/2)) and (index < numDevices):
device = self.supportedDevices[index]
b = Button(self.selectMachineFrame,text=device.name,relief=RAISED, command=lambda device=device :self.machineButtonPressed(device))
b.grid(row=i,column=j, sticky=N+S+E+W,padx=2,pady =2)
index += 1
for i in range(numRows):
self.selectMachineFrame.rowconfigure(i,weight=1)
for i in range(numColumns):
self.selectMachineFrame.columnconfigure(i,weight=1)
def machineButtonPressed(self,inputDevice):
dirStr = filedialog.askdirectory()
if len(dirStr) and inputDevice.isDirectoryValid(dirStr):
inputDevice.setDirPath(dirStr)
EguanaModel().machine = inputDevice
self.selectMachineFrame.destroy()
self.menubar.inputSelected()
self.photo_label.destroy()
dirStr = 'Input Path : '+dirStr
self.selectPlotFrame = Frame(self.frame, relief=FLAT,bg='#FADC46')
self.selectPlotFrame.pack(fill=BOTH,expand=True)
self.selectPlotFrame.rowconfigure(0,weight=1)
self.selectPlotFrame.rowconfigure(1,weight=2)
self.selectPlotFrame.columnconfigure(0,weight=1)
self.infoFrame = Frame(self.selectPlotFrame, relief=FLAT, bg='#FADC46')
self.infoFrame.grid(row=0,column=0, sticky=N+S+E+W,padx=2,pady =2)
self.machineNameLabel = Label(self.infoFrame, text=inputDevice.name,relief=FLAT)
self.machineNameLabel.grid(row=0,column=0,columnspan=2, sticky=N+S+E+W,padx=2,pady =2)
self.directoryLabel = Label(self.infoFrame, text="No project currently selected",relief=FLAT)
self.directoryLabel.grid(row=1,column=0,columnspan=2, sticky=N+S+E+W,padx=2,pady =2)
self.directoryLabel.config(text=dirStr)
self.outputDirButton = Button(self.infoFrame,text="No output directory selected. Click to select an output directory ",relief=RAISED,fg='red',command=self.askOutputDirectory)
self.outputDirButton.grid(row=2,column=0,columnspan=2, sticky=N+S+E+W,padx=2,pady =2)
self.filterButton = Button(self.infoFrame,text="No filter selected. Click to select a filter",relief=RAISED,fg='red',command=self.selectFilter)
self.filterButton.grid(row=3,column=0,columnspan=2, sticky=N+S+E+W,padx=2,pady =2)
self.trialLabel = Label(self.infoFrame,text="Trial Number",relief=FLAT,justify=RIGHT,anchor=E)
self.trialLabel.grid(row=4,column=0, sticky=N+S+E+W,padx=2,pady =2)
vcmd = (self.master.register(self.validate),'%d', '%i', '%P', '%s', '%S', '%v', '%V', '%W')
self.trialEntry = Entry(self.infoFrame,validate = 'key', validatecommand = vcmd)
self.trialEntry.grid(row=4,column=1, sticky=N+S+E+W,padx=2,pady =2)
self.infoFrame.columnconfigure(0, weight=1)
self.infoFrame.columnconfigure(1, weight=1)
self.infoFrame.rowconfigure(0, weight=1)
self.infoFrame.rowconfigure(1, weight=10)
self.infoFrame.rowconfigure(2, weight=10)
self.infoFrame.rowconfigure(3, weight=10)
self.infoFrame.rowconfigure(4, weight=10)
self.showPlotTools()
def validate(self, action, index, value_if_allowed,
prior_value, text, validation_type, trigger_type, widget_name):
if len(value_if_allowed)==0 :
return True
if text in '0123456789.-+ ':
try:
float(value_if_allowed)
return True
except ValueError:
return False
else:
return False
def askOutputDirectory(self):
dirStr = filedialog.askdirectory()
if len(dirStr):
dirStr = 'Output Path : '+dirStr
self.outputDirButton.config(text=dirStr)
def showPlotTools(self):
f2= Frame(self.selectPlotFrame, relief=FLAT,bg='#FADC46')
f2.grid(row=1,column=0,sticky=N+S+E+W,padx=10,pady =10)
b1 = Button(f2,text='3D K',relief=RAISED,command= lambda:self.plotButtonPressed(1))
b1.grid(row=0, column=0,sticky=N+S+E+W,padx=5,pady =5)
b2 = Button(f2,text='3D Dist',relief=RAISED,command=lambda:self.plotButtonPressed(2))
b2.grid(row=0, column=1,sticky=N+S+E+W,padx=5,pady =5)
b3 = Button(f2,text='3D DP',relief=RAISED,command=lambda:self.plotButtonPressed(3))
b3.grid(row=0, column=2,sticky=N+S+E+W,padx=5,pady =5)
b4 = Button(f2,text='2D K',relief=RAISED,command=lambda:self.plotButtonPressed(4))
b4.grid(row=1, column=0,sticky=N+S+E+W,padx=5,pady =5)
b5 = Button(f2,text='2D Dist',relief=RAISED,command=lambda:self.plotButtonPressed(5))
b5.grid(row=1, column=1,sticky=N+S+E+W,padx=5,pady =5)
b6 = Button(f2,text='2D DP',relief=RAISED,command=lambda:self.plotButtonPressed(6))
b6.grid(row=1, column=2,sticky=N+S+E+W,padx=5,pady =5)
b1.config(state=EguanaModel().machine.plot3DKButtonState)
b2.config(state=EguanaModel().machine.plot3DDstButtonState)
b3.config(state=EguanaModel().machine.plot3DDpButtonState)
b4.config(state=EguanaModel().machine.plot2DKButtonState)
b5.config(state=EguanaModel().machine.plot2DDstButtonState)
b6.config(state=EguanaModel().machine.plot2DDpButtonState)
f2.columnconfigure(0, weight=1)
f2.columnconfigure(1, weight=1)
f2.columnconfigure(2, weight=1)
f2.rowconfigure(0, weight=1)
f2.rowconfigure(1, weight=1)
def plotButtonPressed(self,number):
trialNum = self.trialEntry.get()
try:
trialNum = int(trialNum)
print(EguanaModel().machine.ifTrialExists(trialNum))
if EguanaModel().machine.ifTrialExists(trialNum):
self.plotFigure(number)
return True
else:
messagebox.showerror(
"Trial Number Error",
"The trial doesn't exist"
)
return False
except ValueError:
messagebox.showerror(
"Trial Number Error",
"Error with the trial number"
)
return False
def plotFigure(self,number):
m = CoilNumDialog(self.frame)
if m.isSet():
print(m.getValues())
EguanaModel().machine.getDataForTrialNumber(number)
def selectFilter(self):
ffPopup = FilterFunctionPopup(self)
if ffPopup.selectedFilter is not None:
EguanaModel().filterFunction = ffPopup.selectedFilter
ftPopup = FilterTypePopup(self,ffPopup.selectedFilter)
if (ftPopup.selectedHeadFilterType is not None) and (ftPopup.selectedHeadFilterType is not None):
self.menubar.setSelectedFilters(ffPopup.selectedFilter,ftPopup.selectedHeadFilterType,ftPopup.selectedJawFilterType)
EguanaModel().filterTypeHead = ftPopup.selectedHeadFilterType
EguanaModel().filterTypeJaw = ftPopup.selectedJawFilterType
EguanaModel().filterFunction = ffPopup.selectedFilter
buttonText = '{} - Jaw Filter : {} - Head Filter {}'.format(ffPopup.selectedFilter.name,ftPopup.selectedJawFilterType.name, ftPopup.selectedHeadFilterType.name)
self.filterButton.config(text=buttonText)
def updateSelectedFilters(self,ffName,ftHeadName,ftJawName):
buttonText = '{} - Jaw Filter : {} - Head Filter {}'.format(ffName,ftHeadName,ftJawName)
self.filterButton.config(text=buttonText)
def changeImage(self):
self.photo = PhotoImage(file=self.photoName)
self.photo = self.photo.subsample(2);
self.photo_label.image = self.photo
self.photo_label.config(image=self.photo)
def cursorPosition(self,event):
if event.widget == self.openButton3D:
if self.photoName == "eguana2.gif":
self.photoName = "eguana.gif"
self.changeImage()
elif event.widget == self.openButton2D:
if self.photoName == "eguana.gif":
self.photoName = "eguana2.gif"
self.changeImage()
class Example(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.threading_start = None
self.queue = Queue()
self.initUI()
def initUI(self):
self.parent.title("Facebook searching tool")
self.style = Style()
self.style.theme_use("classic")
self.pack(fill=BOTH, expand=1)
frame1 = Frame(self)
frame1.pack(fill=X)
lbl1 = Label(frame1,
text="Facebook searching tool !!!",
font="VNI-Dom 15",
width=50,
foreground="blue")
lbl1.pack(side=TOP, padx=8, pady=8, expand=True)
menubar = Menu(self.parent)
self.parent.config(menu=menubar)
fileMenu = Menu(menubar)
submenu = Menu(fileMenu)
submenu.add_command(label="Watch result Button",
command=self.onChoose2)
submenu.add_command(label="Stop Button", command=self.onChoose3)
submenu.add_command(label="Start Button", command=self.onChoose5)
submenu.add_command(label="Extract Button", command=self.onChoose1)
submenu.add_command(label="Background", command=self.onChoose6)
fileMenu.add_cascade(label='Change colour', menu=submenu)
fileMenu.add_separator()
fileMenu.add_command(label="Go to the result folder",
command=self.onOpen)
fileMenu.add_separator()
fileMenu.add_command(label="Exit", command=self.quit)
menubar.add_cascade(label="Option", menu=fileMenu)
frame1 = Frame(self)
frame1.pack(fill=X)
lbl1 = Label(frame1,
text="Key word",
font="VNI-Dom 12",
foreground="black",
width=13)
lbl1.pack(side=LEFT, padx=18, pady=12)
self.entry1 = Entry(frame1)
self.entry1.insert(0, 'i want this shirt')
self.entry1.pack(fill=X, padx=5, expand=True)
frame2 = Frame(self)
frame2.pack(fill=X)
lbl2 = Label(frame2,
text="Extract file",
font="VNI-Dom 12",
foreground="black",
width=13)
lbl2.pack(side=LEFT, padx=18, pady=12)
self.entry2 = Entry(frame2)
self.entry2.pack(fill=X, padx=5, expand=True)
# bard = Image.open("28.jpg")
# bardejov = ImageTk.PhotoImage(bard)
# label1 = Label(self, image=bardejov)
# label1.image = bardejov
# label1.pack(side=BOTTOM, padx=10, expand=True)
self.quitButton = Button(self,
text="Quit",
height=1,
width=10,
command=self.onQuest,
background="black",
foreground="white")
self.quitButton.pack(side=RIGHT, padx=5, pady=5)
self.newkeywordButton = Button(self,
text="Delete key word",
height=1,
width=10,
command=self.onDeleteentry,
background="red",
foreground="white")
self.newkeywordButton.pack(side=RIGHT, padx=5, pady=5)
self.deleteresultButton = Button(self,
text="Delete result",
height=1,
width=10,
command=self.deleteAllfile,
background="red",
foreground="white")
self.deleteresultButton.pack(side=RIGHT, padx=5, pady=5)
self.extractButton = Button(self,
text="Extract",
height=1,
width=10,
command=self.outFile,
background="black",
foreground="white")
self.extractButton.pack(side=RIGHT, padx=5, pady=5)
self.okButton1 = Button(self,
text="Watch result",
height=1,
width=10,
command=self.onshowImages,
background="green",
foreground="white")
self.okButton1.pack(side=RIGHT, padx=5, pady=5)
self.closeButton = Button(self,
text="Stop",
height=1,
width=10,
command=self.onStop,
background="green",
foreground="white")
self.closeButton.pack(side=RIGHT, padx=5, pady=5)
self.okButton = Button(self,
text="Start",
height=1,
width=10,
command=self.onStartentry,
background="green",
foreground="white")
self.okButton.pack(side=RIGHT, padx=5, pady=5)
def onQuest(self):
outButton = mbox.askquestion("Question", "Are you sure to quit ?")
if outButton == "yes":
for i in range(1, 10):
self.quit()
def onStop(self):
stopButton = mbox.askquestion("Question", "Do you want to stop ?")
if stopButton == 'yes':
setattr(self.queue, 'do_run', False)
os.system("TASKKILL /F /IM firefox.exe")
self.okButton.config(state=tk.NORMAL)
def process_queue(self):
self.queue = Queue(maxsize=0)
num_threads = 5
for i in range(num_threads):
worker = Thread(target=do_stuff, args=(self.queue, ))
worker.setDaemon(True)
worker.start()
for x in range(50):
self.queue.put(x)
self.queue.join()
self.okButton.config(state=tk.NORMAL)
def onStartentry(self):
# outButton = mbox.askquestion("Question", "Do you want to remove old images before start ?")
# if outButton == "yes":
# src = "./IM/"
# for d in os.listdir(src):
# sublink="{}{}".format(src,d)
# os.remove(sublink)
key_word = self.entry1.get()
self.threading_start = Thread(target=self.process_queue)
self.threading_start.setDaemon(True)
self.threading_start.start()
self.okButton.config(state=tk.DISABLED)
def onOpen(self):
ftypes = {('All files', '*'), ('Text files', '*.txt'),
('jpg file', '*.jpg'), ('gif file', '*.gif')}
dlg = Open(self, filetypes=ftypes)
fl = dlg.show()
if fl != '':
images = fl
if images.endswith("png") \
or images.endswith("jpg") \
or images.endswith("jpeg") \
or images.endswith("gif") \
or images.endswith("tiff") \
or images.endswith("bmp") \
or images.endswith("PNG") \
or images.endswith("JPG") \
or images.endswith("JPEG") \
or images.endswith("GIF") \
or images.endswith("TIFF") \
or images.endswith("BMP"):
window = tk.Toplevel()
str = fl.split('/', 100)
number_last = len(fl.split('/', 100)) - 1
window.title(str[number_last])
self.mg = Image.open(fl)
w, h = Image.open(fl).size
window.geometry(("%dx%d + 300 + 300") % (w, h))
window.configure(background='grey')
path = fl
self.img = Image.open(path)
img = ImageTk.PhotoImage(Image.open(path))
panel = tk.Label(window, image=img)
panel.pack(side="bottom", fill="both", expand=True)
window.mainloop()
else:
mbox.showerror("Error", "Could not open file")
def onChoose1(self):
(rgb, hx) = askcolor()
self.extractButton.config(bg=hx)
def onChoose2(self):
(rgb, hx) = askcolor()
self.okButton1.config(bg=hx)
def onChoose3(self):
(rgb, hx) = askcolor()
self.closeButton.config(bg=hx)
def onChoose4(self):
(rgb, hx) = askcolor()
self.okButton.config(bg=hx)
def onChoose5(self):
(rgb, hx) = askcolor()
self.newkeywordButton.config(bg=hx)
def onChoose6(self):
(rgb, hx) = askcolor()
self.config(bg=hx)
def deleteAllfile(self):
outButton = mbox.askquestion("Question",
"Do you want to remove all images ?")
if outButton == "yes":
src = "./IM/"
for d in os.listdir(src):
sublink = "{}{}".format(src, d)
os.remove(sublink)
def outFile(self):
link = self.entry2.get()
src = "./TestImages/"
self.list_images = []
pdf = FPDF('p', 'mm', 'A4')
x, y, w, h = 0, 0, 200, 250
for d in os.listdir(src):
images = d
if (images.endswith("png") or images.endswith("jpg")
or images.endswith("jpeg") or images.endswith("gif")
or images.endswith("tiff") or images.endswith("bmp")
or images.endswith("PNG") or images.endswith("JPG")
or images.endswith("JPEG") or images.endswith("GIF")
or images.endswith("TIFF") or images.endswith("BMP")):
sublink = "{}{}".format("./TestImages/", d)
shutil.copy(sublink, link)
pdf.add_page()
pdf.image(sublink, x, y, w, h)
now = datetime.now()
current_year = now.year
current_month = now.month
current_day = now.day
curent_hour = now.hour
current_minute = now.minute
current_second = now.second
date_time = "Reportimages_%s_%s_%s_%s_%s_%s" % (
current_year, current_month, current_day, curent_hour,
current_minute, current_second)
outlink = "{}{}".format(link, date_time)
pdf.output(outlink, "F")
def onDeleteentry(self):
self.entry1.delete(0, 10000)
def onshowImages(self):
root = tk.Toplevel()
MyApp = ImageClassifyer(root)
tk.mainloop()
class Uplink_Analysis(Frame):
def __init__(self, master):
Frame.__init__(self, master)
self.master = master
window_width = 480
window_heigh = 230
x_pos = (screen_width / 2) - (window_width / 2)
y_pos = (screen_heigh / 2) - (window_heigh / 2)
# self.master.geometry("420x200")
self.master.geometry('%dx%d+%d+%d' %
(window_width, window_heigh, x_pos, y_pos))
self.master.title("Uplink Analysis")
self.Auto_detect_file_input_label = Label(self.master,
text='Uplink Directory')
self.Auto_detect_file_input_label.grid(row=0,
column=0,
sticky=W,
pady=2)
self.Auto_detect_file_input_txt = Text(self.master, heigh=1, width=35)
self.Auto_detect_file_input_txt.grid(row=0, column=1, pady=2, padx=2)
self.PwCtrl_file_PATH_label = Label(self.master,
text="Power Control File Path")
self.PwCtrl_file_PATH_label.grid(row=1, column=0, sticky=W, pady=2)
self.PwCtrl_file_PATH_txt = Text(self.master, heigh=1, width=42)
self.PwCtrl_file_PATH_txt.grid(row=1, column=1, columnspan=2, pady=2)
self.DCI_file_PATH_label = Label(self.master, text="DCI File Path")
self.DCI_file_PATH_label.grid(row=2, column=0, sticky=W, pady=2)
self.DCI_file_PATH_txt = Text(self.master, heigh=1, width=42)
self.DCI_file_PATH_txt.grid(row=2, column=1, columnspan=2, pady=2)
self.TxReport_file_PATH_label = Label(self.master,
text="Tx Report File Path")
self.TxReport_file_PATH_label.grid(row=3, column=0, sticky=W, pady=2)
self.TxReport_file_PATH_txt = Text(self.master, heigh=1, width=42)
self.TxReport_file_PATH_txt.grid(row=3, column=1, columnspan=2, pady=2)
self.PHICH_file_PATH_label = Label(self.master, text="PHICH File Path")
self.PHICH_file_PATH_label.grid(row=4, column=0, sticky=W, pady=2)
self.PHICH_file_PATH_txt = Text(self.master, heigh=1, width=42)
self.PHICH_file_PATH_txt.grid(row=4, column=1, columnspan=2, pady=2)
self.Output_dir_label = Label(self.master, text="Output directory")
self.Output_dir_label.grid(row=5, column=0, sticky=W, pady=2)
self.Output_dir_txt = Text(self.master, heigh=1, width=42)
self.Output_dir_txt.grid(row=5, column=1, columnspan=2, pady=2)
# Button config
self.auto_button = Button(self.master,
text='Auto find',
command=self.find_files)
self.auto_button.grid(row=0, column=2, columnspan=2, sticky=E)
self.merge_button = Button(self.master,
text='Merge Table',
state=DISABLED,
command=self.call_merge)
self.merge_button.config(width=10, heigh=4)
self.merge_button.grid(row=6, column=0, columnspan=3, sticky=E)
#Merge condition in order to press merge button
self.merge_condition_1 = False
self.merge_condition_2 = False
self.merge_condition_3 = False
self.merge_condition_4 = False
self.menu = Menu(self.master)
self.master.config(menu=self.menu)
# create the file object)
self.file = Menu(self.menu)
# adds a command to the menu option, calling it exit, and the
# command it runs on event is client_exit
self.file.add_command(label="Set input dir",
command=self.set_input_dir)
self.file.add_command(label="Open Power Control file",
command=self.open_PwCtrl)
self.file.add_command(label="Open DCI file", command=self.open_DCI)
self.file.add_command(label="Open Tx Report file",
command=self.open_TxReport)
self.file.add_command(label="Open PHICH file", command=self.open_PHICH)
self.file.add_command(label="Set oput directory", command=self.set_dir)
self.file.add_command(label="Exit", command=self.client_exit)
self.menu.add_cascade(label="File", menu=self.file)
# menu.add_cascade(label="Open config", menu=file)
self.edit = Menu(self.menu)
self.menu.add_cascade(label="Edit", menu=self.edit)
self.help = Menu(self.menu)
self.help.add_command(label="About", command=self.show_about)
self.help.add_command(label="Instruction",
command=self.show_instruction)
self.menu.add_cascade(label="Help", menu=self.help)
def set_input_dir(self):
dir = askdirectory()
if dir:
global input_dir
input_dir = dir
# print(input_dir)
self.Auto_detect_file_input_txt.delete("1.0", "end")
self.Auto_detect_file_input_txt.insert(END, input_dir)
else:
showerror("Error", "No directory selected")
def check_merge_condition(self):
#Check if merge conditions are met, then turn the button on/off
if self.merge_condition_1 and (self.merge_condition_2
or self.merge_condition_3
or self.merge_condition_4):
return True
else:
return False
def find_files(self):
global input_dir, pw_ctrl_path, dci_path, tx_report_path, phich_path
for file in os.listdir(input_dir):
if file.endswith(".csv"):
if file == '0xB16C.csv':
dci_path = os.path.join(input_dir, file)
self.DCI_file_PATH_txt.delete("1.0", "end")
self.DCI_file_PATH_txt.insert(END, dci_path)
self.merge_condition_2 = True
if self.check_merge_condition():
self.merge_button.config(state=NORMAL)
elif file == '0xB139.csv':
tx_report_path = os.path.join(input_dir, file)
self.TxReport_file_PATH_txt.delete("1.0", "end")
self.TxReport_file_PATH_txt.insert(END, tx_report_path)
self.merge_condition_3 = True
if self.check_merge_condition():
self.merge_button.config(state=NORMAL)
elif file == '0xB16E.csv':
pw_ctrl_path = os.path.join(input_dir, file)
self.PwCtrl_file_PATH_txt.delete("1.0", "end")
self.PwCtrl_file_PATH_txt.insert(END, pw_ctrl_path)
self.merge_condition_1 = True
if self.check_merge_condition():
self.merge_button.config(state=NORMAL)
elif file == '0xB12C.csv':
phich_path = os.path.join(input_dir, file)
self.PHICH_file_PATH_txt.delete("1.0", "end")
self.PHICH_file_PATH_txt.insert(END, phich_path)
self.merge_condition_4 = True
if self.check_merge_condition():
self.merge_button.config(state=NORMAL)
def open_PwCtrl(self):
filename = askopenfilename(initialdir='/',
title="Select file",
filetypes=(("csv file", "*.csv"),
("all files", "*.*")))
if filename:
global pw_ctrl_path
pw_ctrl_path = filename
print(pw_ctrl_path)
# self.update_text()
self.PwCtrl_file_PATH_txt.delete("1.0", "end")
self.PwCtrl_file_PATH_txt.insert(END, pw_ctrl_path)
self.merge_condition_1 = True
if self.check_merge_condition():
self.merge_button.config(state=NORMAL)
else:
showerror("Error", "No file selected")
def open_DCI(self):
filename = askopenfilename(initialdir='/',
title="Select file",
filetypes=(("csv file", "*.csv"),
("all files", "*.*")))
if filename:
global dci_path
dci_path = filename
print(dci_path)
# self.update_text()
self.DCI_file_PATH_txt.delete("1.0", "end")
self.DCI_file_PATH_txt.insert(END, dci_path)
self.merge_condition_2 = True
if self.check_merge_condition():
self.merge_button.config(state=NORMAL)
else:
showerror("Error", "No file selected")
def open_TxReport(self):
filename = askopenfilename(initialdir='/',
title="Select file",
filetypes=(("csv file", "*.csv"),
("all files", "*.*")))
if filename:
global tx_report_path
tx_report_path = filename
print(tx_report_path)
# self.update_text()
self.TxReport_file_PATH_txt.delete("1.0", "end")
self.TxReport_file_PATH_txt.insert(END, tx_report_path)
self.merge_condition_3 = True
if self.check_merge_condition():
self.merge_button.config(state=NORMAL)
else:
showerror("Error", "No file selected")
def open_PHICH(self):
filename = askopenfilename(initialdir='/',
title="Select file",
filetypes=(("csv file", "*.csv"),
("all files", "*.*")))
if filename:
global phich_path
phich_path = filename
print(phich_path)
# self.update_text()
self.PHICH_file_PATH_txt.delete("1.0", "end")
self.PHICH_file_PATH_txt.insert(END, phich_path)
self.merge_condition_4 = True
if self.check_merge_condition():
self.merge_button.config(state=NORMAL)
else:
showerror("Error", "No file selected")
def set_dir(self):
dir = askdirectory()
if dir:
global output_path
output_path = dir
print(output_path)
self.Output_dir_txt.delete("1.0", "end")
self.Output_dir_txt.insert(END, output_path)
else:
showerror("Error", "No directory selected")
def call_merge(self):
global pw_ctrl_path, dci_path, tx_report_path, phich_path, output_path
try:
Execute(pw_ctrl_path, dci_path, tx_report_path, phich_path,
output_path)
except:
showerror("Error", "Check files or directory")
def client_exit(self):
exit()
def show_about(self):
pass
def show_instruction(self):
pass
def displayBoard(self, playing=True):
self.destroyButtons()
self.resetDist()
if playing:
self.lbl.config(
text=
"Click on a location to prepare a move. If a tank is available and you are surfaced then you can purchase it.",
fg="black")
if self.state.isOver():
self.lbl.config(text="GAMEOVER", fg="red")
tanks = [tank for tank in self.state.tanks]
self.cash = Label(self.master,
text=" Cash: " + str(self.state.cash) + " ",
font=("Helvetica", 15))
self.cash.grid(row=15, column=15)
self.time = Label(self.master,
text=" Time: " + str(self.state.timeLeft) +
" ",
font=("Helvetica", 15))
self.time.grid(row=16, column=15)
self.oxygen = Label(self.master,
text=" Oxygen Left: " +
str(self.state.oxygenLeft) + " / " +
str(self.state.tankSize),
font=("Helvetica", 15))
self.oxygen.grid(row=17, column=15)
self.holding = Label(self.master,
text=" Holding: " +
str(sum((self.state.holding))) + " ",
font=("Helvetica", 15))
self.holding.grid(row=18, column=15)
self.buttons['cash'] = self.cash
self.buttons['time'] = self.time
self.buttons['oxygen'] = self.oxygen
self.buttons['holding'] = self.holding
if playing:
def clickTank(action):
def executeMove():
def do():
self.move = action
if self.move in self.state.getLegalActions():
self.var.set(1)
if not self.showing:
if (self.state.playerLoc == (0, 0)
or self.state.playerLoc
== (0, 9)) and self.state.cash >= action[0]:
self.lbl.config(text="Tank | Cost: " +
str(action[0]) + " | Size: " +
str(action[1]))
if hasattr(self, 'next'):
self.next.destroy()
self.next = Button(self.master,
text="Execute Move",
font=("Helvetica", 15),
command=do)
self.next.grid(row=5, column=15)
self.buttons['next'] = self.next
else:
print(self.state.cash, action[1])
self.lbl.config(text="Cannot Buy Tank")
if self.prevButton:
prevbutton = self.buttons[self.prevButton]
if self.prevButton != self.state.playerLoc:
if self.prevButton == (
0, 0) or self.prevButton == (0, 9):
prevbutton.config(background="Green")
elif len(self.prevButton) == 3:
prevbutton.config(background="white")
else:
prevbutton.config(background="Light Gray")
self.buttons[action].config(background="orange")
self.prevButton = action
return do
return executeMove
else:
def clickTank(action):
pass
c = 0
if playing:
enabled = "normal"
else:
enabled = "disabled"
self.tanks = []
for tank in tanks:
if tank in self.state.getLegalActions():
t = Button(self.master,
text="Tank | Cost: " + str(tank[0]) + " | Size: " +
str(tank[1]),
font=("Helvetica", 15),
command=clickTank(tank),
state=enabled)
t.grid(row=10 + c, column=15)
self.tanks.append(t)
self.buttons[tank] = t
c += 1
else:
t = Button(self.master,
text="Tank | Cost: " + str(tank[0]) + " | Size: " +
str(tank[1]),
font=("Helvetica", 15),
command=clickTank(tank),
state=enabled)
t.config(state="disabled")
t.grid(row=10 + c, column=15)
self.tanks.append(t)
self.buttons[tank] = t
c += 1
if self.state.playerLoc == (
0, 0) or self.state.playerLoc == (0, 9) and playing:
def exit():
self.move = (None, None, 'exit')
self.var.set(1)
print("EXIT")
if (self.state.playerLoc == (0, 0)
or self.state.playerLoc == (0, 9)):
self.exit = Button(self.master,
text="EXIT with all your current cash! ",
font=("Helvetica", 15),
command=exit,
state=enabled)
self.buttons['exit'] = self.exit
self.exit.grid(row=19, column=15)
for i in range(0, 20):
for j in range(0, 10):
if not (i == 0 and (j < 9 and j > 0)):
bg = None
fg = "black"
color = "white"
font = ("Helvetica", 11)
if i > 0:
color = "navy"
if self.state.board[i][j]:
color = "Light Gray"
text = str(self.state.board[i][j])
elif (i, j) == (0, 0) or (i, j) == (0, 9):
text = ""
color = "Green"
else:
text = ""
if self.state.playerLoc == (i, j):
text = "P"
color = "Yellow"
fg = "brown4"
font = ("Helvetica", 10, "bold")
if self.state.playerLoc == (
i, j) and self.state.playerLoc[0] != 0:
color = "Yellow"
b = Button(self.master)
b.grid(row=i, column=j)
b.row = i
b.column = j
self.buttons[(i, j)] = b
def click(action):
i = action[0]
j = action[1]
def do():
valid = False
def executeMove(action):
def do():
self.move = action
self.prevButton = None
if self.move in self.state.getLegalActions(
):
self.var.set(1)
return do
if not self.showing:
if ((i, j) == (0, 0) or (i, j) ==
(0, 9)) and (i, j) != self.state.playerLoc:
valid = True
text = "Surface Location: " + str(
(i, j)
) # + "| distance is " + str(manDist((i, j), self.state.playerLoc))
if self.state.board[i][j]:
valid = True
text = "Pick up " + str(
self.state.board[i][j]
) + " at location " + str(
(i, j)
) # + " | distance is " + str(manDist((i, j), self.state.playerLoc))
if valid:
if self.prevButton:
prevbutton = self.buttons[
self.prevButton]
if self.prevButton != self.state.playerLoc:
if self.prevButton == (
0, 0
) or self.prevButton == (0, 9):
prevbutton.config(
background="Green")
else:
prevbutton.config(
background="Light Gray")
self.buttons[(i, j)].config(
background="orange")
self.prevButton = (i, j)
if not self.locations:
self.distance += manDist(
(i, j), self.state.playerLoc)
else:
self.distance += manDist(
(i, j), self.locations[-1])
self.locations += [(i, j)]
self.distanceLabel.config(
text=str(self.locations) + ": " +
str(self.distance))
self.lbl.config(text=text)
if hasattr(self, 'next'):
self.next.destroy()
self.next = Button(
self.master,
text="Execute Move",
font=("Helvetica", 15),
command=executeMove(action),
state=enabled)
self.next.grid(row=5, column=15)
self.buttons['next'] = self.next
return do
b.config(highlightthickness=0,
text=text,
width="3",
height="2",
font=font,
fg=fg,
command=click((i, j, "move")),
background=color)
class BioInfo(Tk):
def __init__(self):
Tk.__init__(self)
self.wm_title("BioInfo : comparaison des listes")
self.resizable(width=FALSE, height=FALSE)
self.SortDir = False
# Lists Types
self.typeList1 = None
self.typeList2 = None
# Frame content
self.frameContent = Frame(self)
self.frameContent.pack(side=TOP, fill=X)
# ScrollBar
scrollbar = Scrollbar(self.frameContent, orient=VERTICAL)
scrollbar.pack(side=RIGHT, fill=Y)
# Result Content
self.dataCols = ('microArn_A', 'microArn_B', 'FoldC', 'p-Value', 'Note')
self.tree = Treeview(self.frameContent, columns=self.dataCols, show = 'headings', yscrollcommand=scrollbar.set)
# configure column headings
for c in self.dataCols:
self.tree.heading(c, text=c, command=lambda c=c: self.columnSort(c, self.SortDir))
self.tree.column(c, width=10)
self.tree.pack(side=LEFT, fill=X, expand="yes")
scrollbar.config(command=self.tree.yview)
# Frame Lists
self.frameLists = Frame(self)
self.frameLists.pack(side=LEFT)
# Frame Forms
self.frameForms = Frame(self)
self.frameForms.pack(side=LEFT, padx=20)
#Liste n°1 selection
self.frameList1 = Frame(self.frameLists)
self.frameList1.pack()
self.typeListStr1 = StringVar(self.frameList1)
self.typeListStr1.set(str(ListBioType.TypeA))
self.buttonTypeList1 = OptionMenu(self.frameList1, self.typeListStr1, str(ListBioType.TypeA), str(ListBioType.TypeB)).pack(side=LEFT)
self.entrylist1 = Entry(self.frameList1, width=30)
self.entrylist1.pack(side=LEFT)
self.buttonBrowseList1 = Button(self.frameList1, text="Parcourir", command=self.load_fileList1, width=10)
self.buttonBrowseList1.pack(side=LEFT, padx=5)
# List n°2 selection
self.frameList2 = Frame(self.frameLists)
self.frameList2.pack(side=BOTTOM)
self.typeListStr2 = StringVar(self.frameList2)
self.typeListStr2.set(str(ListBioType.TypeB))
self.buttonTypeList2 = OptionMenu(self.frameList2, self.typeListStr2, str(ListBioType.TypeA), str(ListBioType.TypeB)).pack(side=LEFT)
self.entrylist2 = Entry(self.frameList2, width=30)
self.entrylist2.pack(side=LEFT)
self.buttonBrowseList2 = Button(self.frameList2, text="Parcourir", command=self.load_fileList2, width=10)
self.buttonBrowseList2.pack(side=LEFT, padx=5)
# Form pValue
self.framePVal = Frame(self.frameForms)
self.framePVal.pack()
Label(self.framePVal, text="pValue").pack(side=LEFT)
self.entryPVal = Entry(self.framePVal, width=6)
self.entryPVal.pack(side=LEFT)
# Form foldC
self.frameFoldC = Frame(self.frameForms)
self.frameFoldC.pack()
Label(self.frameFoldC, text="foldCh").pack(side=LEFT)
self.entryFoldC = Entry(self.frameFoldC, width=6)
self.entryFoldC.pack(side=LEFT)
# Form note
self.frameNote = Frame(self.frameForms)
self.frameNote.pack()
Label(self.frameNote, text="note ").pack(side=LEFT)
self.entryNote = Entry(self.frameNote, width=6)
self.entryNote.pack(side=LEFT)
# Bouton comparer
self.buttonComparer = Button(self, text="Comparer", command=self.compare, width=10, state=DISABLED)
self.buttonComparer.pack(fill= X, expand="yes", padx=20, pady=(10,0))
#Bouton exporter
self.buttonExport = Button(self, text="Exporter", command=self.export, width=10, state=DISABLED)
self.buttonExport.pack(fill= X, expand="yes", padx=20)
# Réinitialiser
self.buttonReset = Button(self, text="Réinitialiser", command=self.reset, width=10)
self.buttonReset.pack(fill= X, expand="yes", padx=20, pady=(0,10))
# file members
self.list1 = None
self.list2 = None
def load_fileList1(self):
fname = askopenfilename(filetypes=(("CSV files", "*.csv"),
("All files", "*.*") ))
if fname:
self.entrylist1.delete(0, END)
self.list1 = fname
self.entrylist1.insert(0,fname)
self.buttonComparer.config(state=NORMAL)
def load_fileList2(self):
fname = askopenfilename(filetypes=(("CSV files", "*.csv"),
("All files", "*.*") ))
if fname:
self.entrylist2.delete(0, END)
self.list2 = fname
self.entrylist2.insert(0,fname)
self.buttonComparer.config(state=NORMAL)
else:
showerror("Erreur : fichier B", "La liste B est introuvable")
def resetTree (self):
for i in self.tree.get_children():
self.tree.delete(i)
def reset(self):
self.list1 = None
self.entrylist1.delete(0, END)
self.list2 = None
self.entrylist2.delete(0, END)
self.entryPVal.delete(0,END)
self.entryFoldC.delete(0, END)
self.entryNote.delete(0, END)
self.typeList1 = None
self.typeList2 = None
self.buttonExport.config(state=DISABLED)
self.buttonComparer.config(state=DISABLED)
self.resetTree()
def isValidfoldC(self, s):
try:
float(s)
return True
except ValueError:
return False
def isValidPValue(self, s):
try:
f = float(s)
if f >= 0 and f <= 1:
return True
else:
return False
except:
return False
def isValidNote (self, s):
try:
f = int(s)
return True
except:
return False
def compare(self):
self.buttonExport.config(state=NORMAL)
# Détermination type Listes
# List 1
if self.typeListStr1.get() == str(ListBioType.TypeA):
self.typeList1 = ListBioType.TypeA
elif self.typeListStr1.get() == str(ListBioType.TypeB):
self.typeList1 = ListBioType.TypeB
else:
self.typeList1 = None
# List 2
if self.typeListStr2.get() == str(ListBioType.TypeA):
self.typeList2 = ListBioType.TypeA
elif self.typeListStr2.get() == str(ListBioType.TypeB):
self.typeList2 = ListBioType.TypeB
else:
self.typeList2 = None
if not self.isValidfoldC(self.entryFoldC.get()) and not self.entryFoldC.get() == "":
showerror("Erreur : foldC","La valeur fold Change n'est pas un nombre")
elif not self.isValidPValue(self.entryPVal.get()) and not self.entryPVal.get() == "":
showerror("Erreur : pValue","La valeur pValue n'est pas un nombre compris entre 0 et 1")
elif not self.isValidNote(self.entryNote.get()) and not self.entryNote.get() == "":
showerror("Erreur : note", "La valeur note n'est pas un nombre entier")
# (List A and No List) or (No List and List A)
elif ((self.list1 is not None and self.typeList1 == ListBioType.TypeA) and (self.list2 is None)) or\
((self.list2 is not None and self.typeList2 == ListBioType.TypeA) and (self.list1 is None)):
self.resetTree()
try:
listComp = ListComparator(self.list1, self.list2, self.entryPVal.get(), self.entryFoldC.get(), self.entryNote.get())
for e in listComp.getFilterListA():
self.tree.insert('', 'end', values=e)
except IndexError:
showerror("Erreur : liste A invalide", "Le fichier liste A n'est pas un fichier valide")
# (List B and No List) or (No List and List B)
elif ((self.list1 is not None and self.typeList1 == ListBioType.TypeB) and (self.list2 is None)) or\
((self.list2 is not None and self.typeList2 == ListBioType.TypeB) and (self.list1 is None)):
self.resetTree()
try:
listComp = ListComparator(self.list1, self.list2, self.entryPVal.get(), self.entryFoldC.get())
for e in listComp.getFilterListB():
self.tree.insert('', 'end', values=e)
except IndexError:
showerror("Erreur : liste A invalide", "Le fichier liste A n'est pas un fichier valide")
# (List A and List B) or (List B and List A)
elif ((self.list1 is not None and self.typeList1 == ListBioType.TypeA) and \
(self.list2 is not None and self.typeList2 == ListBioType.TypeB)) or \
((self.list1 is not None and self.typeList1 == ListBioType.TypeB) and \
(self.list2 is not None and self.typeList2 == ListBioType.TypeA)):
self.resetTree()
listA = ""
listB = ""
if self.typeList1 == ListBioType.TypeA:
listA = self.list1
else:
listA = self.list2
if self.typeList1 == ListBioType.TypeB:
listB = self.list1
else:
listB = self.list2
try:
listComp = ListComparator(listA, listB, self.entryPVal.get(), self.entryFoldC.get(), self.entryNote.get())
for e in listComp.getDiffAandB():
self.tree.insert('', 'end', values=e)
except IndexError:
showerror("Erreur : liste A ou B invalide", "Le fichier liste A ou B n'est pas un fichier valide")
# (List A and List A)
elif ((self.list1 is not None and self.typeList1 == ListBioType.TypeA) and \
(self.list2 is not None and self.typeList2 == ListBioType.TypeA)):
self.resetTree()
try:
listComp = ListComparator(self.list1, self.list2, self.entryPVal.get(), self.entryFoldC.get(), self.entryNote.get())
for e in listComp.getDiffAandA():
self.tree.insert('', 'end', values=e)
except IndexError:
showerror("Erreur : liste A ou B invalide", "Le fichier liste A ou B n'est pas un fichier valide")
# (List B and List B)
elif ((self.list1 is not None and self.typeList1 == ListBioType.TypeB) and \
(self.list2 is not None and self.typeList2 == ListBioType.TypeB)):
self.resetTree()
try:
listComp = ListComparator(self.list1, self.list2, self.entryPVal.get(), self.entryFoldC.get())
for e in listComp.getDiffBandB():
self.tree.insert('', 'end', values=e)
except IndexError:
showerror("Erreur : liste A ou B invalide", "Le fichier liste A ou B n'est pas un fichier valide")
else:
showerror("Erreur : Combinaisons de listes invalides", "Votre choix de types de listes ne correspond à aucune combinaison possible, contacter le developpeur")
def export(self):
if len(self.tree.get_children()) == 0:
showinfo("Export", "Il n'y a rien à exporter")
return
fname = asksaveasfilename(filetypes=(("CSV files", "*.csv"),
("All files", "*.*") ))
if fname:
resExp = []
for it in self.tree.get_children():
resExp.append(self.tree.item(it)["values"])
expTabToCSV = TreeExportator(resExp, fname)
expTabToCSV.export()
showinfo("Export", "Exportation au format CSV réussi")
def columnSort (self, col, descending=False):
data = [(self.tree.set(child, col), child) for child in self.tree.get_children('')]
data.sort(reverse=descending)
for indx, item in enumerate(data):
self.tree.move(item[1], '', indx)
# reverse sort direction for next sort operation
self.SortDir = not descending
def showPlotTools(self):
f2= Frame(self.selectPlotFrame, relief=FLAT,bg='#FADC46')
f2.grid(row=1,column=0,sticky=N+S+E+W,padx=10,pady =10)
b1 = Button(f2,text='3D K',relief=RAISED,command= lambda:self.plotButtonPressed(1))
b1.grid(row=0, column=0,sticky=N+S+E+W,padx=5,pady =5)
b2 = Button(f2,text='3D Dist',relief=RAISED,command=lambda:self.plotButtonPressed(2))
b2.grid(row=0, column=1,sticky=N+S+E+W,padx=5,pady =5)
b3 = Button(f2,text='3D DP',relief=RAISED,command=lambda:self.plotButtonPressed(3))
b3.grid(row=0, column=2,sticky=N+S+E+W,padx=5,pady =5)
b4 = Button(f2,text='2D K',relief=RAISED,command=lambda:self.plotButtonPressed(4))
b4.grid(row=1, column=0,sticky=N+S+E+W,padx=5,pady =5)
b5 = Button(f2,text='2D Dist',relief=RAISED,command=lambda:self.plotButtonPressed(5))
b5.grid(row=1, column=1,sticky=N+S+E+W,padx=5,pady =5)
b6 = Button(f2,text='2D DP',relief=RAISED,command=lambda:self.plotButtonPressed(6))
b6.grid(row=1, column=2,sticky=N+S+E+W,padx=5,pady =5)
b1.config(state=EguanaModel().machine.plot3DKButtonState)
b2.config(state=EguanaModel().machine.plot3DDstButtonState)
b3.config(state=EguanaModel().machine.plot3DDpButtonState)
b4.config(state=EguanaModel().machine.plot2DKButtonState)
b5.config(state=EguanaModel().machine.plot2DDstButtonState)
b6.config(state=EguanaModel().machine.plot2DDpButtonState)
f2.columnconfigure(0, weight=1)
f2.columnconfigure(1, weight=1)
f2.columnconfigure(2, weight=1)
f2.rowconfigure(0, weight=1)
f2.rowconfigure(1, weight=1)
class LucteriosMainForm(Tk):
def __init__(self):
Tk.__init__(self)
try:
img = Image("photo", file=join(
dirname(import_module('lucterios.install').__file__), "lucterios.png"))
self.tk.call('wm', 'iconphoto', self._w, img)
except:
pass
self.has_checked = False
self.title(ugettext("Lucterios installer"))
self.minsize(475, 260)
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
self.running_instance = {}
self.resizable(True, True)
self.protocol("WM_DELETE_WINDOW", self.on_closing)
self.ntbk = ttk.Notebook(self)
self.ntbk.grid(row=0, column=0, columnspan=1, sticky=(N, S, E, W))
self.create_instance_panel()
self.create_module_panel()
stl = ttk.Style()
stl.theme_use("default")
stl.configure("TProgressbar", thickness=5)
self.progress = ttk.Progressbar(
self, style="TProgressbar", orient='horizontal', mode='indeterminate')
self.progress.grid(row=1, column=0, sticky=(E, W))
self.btnframe = Frame(self, bd=1)
self.btnframe.grid(row=2, column=0, columnspan=1)
Button(self.btnframe, text=ugettext("Refresh"), width=20, command=self.refresh).grid(
row=0, column=0, padx=3, pady=3, sticky=(N, S))
self.btnupgrade = Button(
self.btnframe, text=ugettext("Search upgrade"), width=20, command=self.upgrade)
self.btnupgrade.config(state=DISABLED)
self.btnupgrade.grid(row=0, column=1, padx=3, pady=3, sticky=(N, S))
Button(self.btnframe, text=ugettext("Close"), width=20, command=self.on_closing).grid(
row=0, column=2, padx=3, pady=3, sticky=(N, S))
def on_closing(self):
all_stop = True
instance_names = list(self.running_instance.keys())
for old_item in instance_names:
if (self.running_instance[old_item] is not None) and self.running_instance[old_item].is_running():
all_stop = False
if all_stop or askokcancel(None, ugettext("An instance is always running.\nDo you want to close?")):
self.destroy()
else:
self.refresh()
def destroy(self):
instance_names = list(self.running_instance.keys())
for old_item in instance_names:
if self.running_instance[old_item] is not None:
self.running_instance[old_item].stop()
del self.running_instance[old_item]
Tk.destroy(self)
def create_instance_panel(self):
frm_inst = Frame(self.ntbk)
frm_inst.grid_columnconfigure(0, weight=1)
frm_inst.grid_rowconfigure(0, weight=1)
frm_inst.grid_columnconfigure(1, weight=3)
frm_inst.grid_rowconfigure(1, weight=0)
self.instance_list = Listbox(frm_inst, width=20)
self.instance_list.bind('<<ListboxSelect>>', self.select_instance)
self.instance_list.pack()
self.instance_list.grid(row=0, column=0, sticky=(N, S, W, E))
self.instance_txt = Text(frm_inst, width=75)
self.instance_txt.grid(row=0, column=1, rowspan=2, sticky=(N, S, W, E))
self.instance_txt.config(state=DISABLED)
self.btninstframe = Frame(frm_inst, bd=1)
self.btninstframe.grid(row=1, column=0, columnspan=1)
self.btninstframe.grid_columnconfigure(0, weight=1)
Button(self.btninstframe, text=ugettext("Launch"), width=25, command=self.open_inst).grid(
row=0, column=0, columnspan=2, sticky=(N, S))
Button(self.btninstframe, text=ugettext("Modify"), width=10,
command=self.modify_inst).grid(row=1, column=0, sticky=(N, S))
Button(self.btninstframe, text=ugettext("Delete"), width=10,
command=self.delete_inst).grid(row=1, column=1, sticky=(N, S))
Button(self.btninstframe, text=ugettext("Save"), width=10,
command=self.save_inst).grid(row=2, column=0, sticky=(N, S))
Button(self.btninstframe, text=ugettext("Restore"), width=10,
command=self.restore_inst).grid(row=2, column=1, sticky=(N, S))
Button(self.btninstframe, text=ugettext("Add"), width=25, command=self.add_inst).grid(
row=3, column=0, columnspan=2, sticky=(N, S))
self.ntbk.add(frm_inst, text=ugettext('Instances'))
def create_module_panel(self):
frm_mod = Frame(self.ntbk)
frm_mod.grid_columnconfigure(0, weight=1)
frm_mod.grid_rowconfigure(0, weight=1)
self.module_txt = Text(frm_mod)
self.module_txt.grid(row=0, column=0, sticky=(N, S, W, E))
self.module_txt.config(state=DISABLED)
self.ntbk.add(frm_mod, text=ugettext('Modules'))
def do_progress(self, progressing):
if not progressing:
self.progress.stop()
self.progress.grid_remove()
else:
self.progress.start(25)
self.progress.grid(row=1, column=0, sticky=(E, W))
def enabled(self, is_enabled, widget=None):
if widget is None:
widget = self
self.do_progress(not is_enabled)
if is_enabled:
widget.config(cursor="")
else:
widget.config(cursor="watch")
if isinstance(widget, Button) and (widget != self.btnupgrade):
if is_enabled and (not hasattr(widget, 'disabled') or not widget.disabled):
widget.config(state=NORMAL)
else:
widget.config(state=DISABLED)
else:
for child_cmp in widget.winfo_children():
self.enabled(is_enabled, child_cmp)
@ThreadRun
def refresh(self, instance_name=None):
if instance_name is None:
instance_name = self.get_selected_instance_name()
self.instance_txt.delete("1.0", END)
self._refresh_instance_list()
self.set_select_instance_name(instance_name)
if not self.has_checked:
self._refresh_modules()
if self.instance_list.size() == 0:
sleep(.3)
self._refresh_modules()
sleep(.3)
self.after_idle(self.add_inst)
def _refresh_modules(self):
self.btnupgrade.config(state=DISABLED)
self.module_txt.config(state=NORMAL)
self.module_txt.delete("1.0", END)
lct_glob = LucteriosGlobal()
mod_lucterios, mod_applis, mod_modules = lct_glob.installed()
self.module_txt.insert(
END, ugettext("Lucterios core\t\t%s\n") % mod_lucterios[1])
self.module_txt.insert(END, '\n')
self.module_txt.insert(END, ugettext("Application\n"))
for appli_item in mod_applis:
self.module_txt.insert(
END, "\t%s\t%s\n" % (appli_item[0].ljust(30), appli_item[1]))
self.module_txt.insert(END, ugettext("Modules\n"))
for module_item in mod_modules:
self.module_txt.insert(
END, "\t%s\t%s\n" % (module_item[0].ljust(30), module_item[1]))
extra_urls = lct_glob.get_extra_urls()
if len(extra_urls) > 0:
self.module_txt.insert(END, "\n")
self.module_txt.insert(END, ugettext("Pypi servers\n"))
for extra_url in extra_urls:
self.module_txt.insert(END, "\t%s\n" % extra_url)
self.module_txt.config(state=DISABLED)
self.has_checked = True
self.after(1000, lambda: Thread(target=self.check).start())
def _refresh_instance_list(self):
self.instance_list.delete(0, END)
luct_glo = LucteriosGlobal()
instance_list = luct_glo.listing()
for item in instance_list:
self.instance_list.insert(END, item)
if item not in self.running_instance.keys():
self.running_instance[item] = None
instance_names = list(self.running_instance.keys())
for old_item in instance_names:
if old_item not in instance_list:
if self.running_instance[old_item] is not None:
self.running_instance[old_item].stop()
del self.running_instance[old_item]
def set_select_instance_name(self, instance_name):
cur_sel = 0
for sel_iter in range(self.instance_list.size()):
if self.instance_list.get(sel_iter) == instance_name:
cur_sel = sel_iter
break
self.instance_list.selection_set(cur_sel)
self.select_instance(None)
def get_selected_instance_name(self):
if len(self.instance_list.curselection()) > 0:
return self.instance_list.get(int(self.instance_list.curselection()[0]))
else:
return ""
def set_ugrade_state(self, must_upgrade):
if must_upgrade:
self.btnupgrade.config(state=NORMAL)
self.btnupgrade["text"] = ugettext("Upgrade needs")
else:
self.btnupgrade["text"] = ugettext("No upgrade")
self.btnupgrade.config(state=DISABLED)
def check(self):
must_upgrade = False
try:
lct_glob = LucteriosGlobal()
_, must_upgrade = lct_glob.check()
finally:
self.after(300, self.set_ugrade_state, must_upgrade)
@ThreadRun
def upgrade(self):
self.btnupgrade.config(state=DISABLED)
self.instance_list.config(state=DISABLED)
try:
from logging import getLogger
admin_path = import_module(
"lucterios.install.lucterios_admin").__file__
proc = Popen(
[sys.executable, admin_path, "update"], stderr=STDOUT, stdout=PIPE)
value = proc.communicate()[0]
try:
value = value.decode('ascii')
except:
pass
six.print_(value)
if proc.returncode != 0:
getLogger("lucterios.admin").error(value)
else:
getLogger("lucterios.admin").info(value)
showinfo(ugettext("Lucterios installer"), ugettext(
"The application must restart"))
python = sys.executable
os.execl(python, python, *sys.argv)
finally:
self._refresh_modules()
self.btnupgrade.config(state=NORMAL)
self.instance_list.config(state=NORMAL)
@ThreadRun
def select_instance(self, evt):
if self.instance_list['state'] == NORMAL:
self.instance_list.config(state=DISABLED)
try:
instance_name = self.get_selected_instance_name()
self.instance_txt.configure(state=NORMAL)
self.instance_txt.delete("1.0", END)
if instance_name != '':
if instance_name not in self.running_instance.keys():
self.running_instance[instance_name] = None
inst = LucteriosInstance(instance_name)
inst.read()
self.instance_txt.insert(END, "\t\t\t%s\n\n" % inst.name)
self.instance_txt.insert(
END, ugettext("Database\t\t%s\n") % inst.get_database_txt())
self.instance_txt.insert(
END, ugettext("Appli\t\t%s\n") % inst.get_appli_txt())
self.instance_txt.insert(
END, ugettext("Modules\t\t%s\n") % inst.get_module_txt())
self.instance_txt.insert(
END, ugettext("Extra\t\t%s\n") % inst.get_extra_txt())
self.instance_txt.insert(END, '\n')
if self.running_instance[instance_name] is not None and self.running_instance[instance_name].is_running():
self.instance_txt.insert(END, ugettext(
"=> Running in http://%(ip)s:%(port)d\n") % {'ip': self.running_instance[instance_name].lan_ip, 'port': self.running_instance[instance_name].port})
self.btninstframe.winfo_children()[0]["text"] = ugettext(
"Stop")
else:
self.running_instance[instance_name] = None
self.instance_txt.insert(END, ugettext("=> Stopped\n"))
self.btninstframe.winfo_children()[0]["text"] = ugettext(
"Launch")
else:
self.btninstframe.winfo_children()[0]["text"] = ugettext(
"Launch")
self.btninstframe.winfo_children()[0].disabled = (
instance_name == '')
self.btninstframe.winfo_children()[1].disabled = (
instance_name == '')
self.btninstframe.winfo_children()[2].disabled = (
instance_name == '')
self.btninstframe.winfo_children()[3].disabled = (
instance_name == '')
self.btninstframe.winfo_children()[4].disabled = (
instance_name == '')
self.instance_txt.configure(state=DISABLED)
finally:
setup_from_none()
self.instance_list.config(state=NORMAL)
@ThreadRun
def add_modif_inst_result(self, result, to_create):
inst = LucteriosInstance(result[0])
inst.set_extra("LANGUAGE_CODE='%s'" % result[5])
inst.set_appli(result[1])
inst.set_module(result[2])
inst.set_database(result[4])
if to_create:
inst.add()
else:
inst.modif()
inst = LucteriosInstance(result[0])
inst.set_extra(result[3])
inst.security()
self.refresh(result[0])
def add_inst(self):
self.enabled(False)
try:
self.do_progress(False)
ist_edt = InstanceEditor()
ist_edt.execute()
ist_edt.transient(self)
self.wait_window(ist_edt)
finally:
self.enabled(True)
if ist_edt.result is not None:
self.add_modif_inst_result(ist_edt.result, True)
def modify_inst(self):
self.enabled(False)
try:
self.do_progress(False)
ist_edt = InstanceEditor()
ist_edt.execute(self.get_selected_instance_name())
ist_edt.transient(self)
self.wait_window(ist_edt)
finally:
self.enabled(True)
if ist_edt.result is not None:
self.add_modif_inst_result(ist_edt.result, False)
@ThreadRun
def delete_inst_name(self, instance_name):
inst = LucteriosInstance(instance_name)
inst.delete()
self.refresh()
def delete_inst(self):
setup_from_none()
instance_name = self.get_selected_instance_name()
if askokcancel(None, ugettext("Do you want to delete '%s'?") % instance_name):
self.delete_inst_name(instance_name)
else:
self.refresh()
@ThreadRun
def open_inst(self):
instance_name = self.get_selected_instance_name()
if instance_name != '':
try:
if instance_name not in self.running_instance.keys():
self.running_instance[instance_name] = None
if self.running_instance[instance_name] is None:
port = FIRST_HTTP_PORT
for inst_obj in self.running_instance.values():
if (inst_obj is not None) and (inst_obj.port >= port):
port = inst_obj.port + 1
self.running_instance[instance_name] = RunServer(
instance_name, port)
self.running_instance[instance_name].start()
else:
self.running_instance[instance_name].stop()
self.running_instance[instance_name] = None
finally:
self.set_select_instance_name(instance_name)
@ThreadRun
def save_instance(self, instance_name, file_name):
inst = LucteriosInstance(instance_name)
inst.filename = file_name
if inst.archive():
showinfo(ugettext("Lucterios installer"), ugettext(
"Instance saved to %s") % file_name)
else:
showerror(
ugettext("Lucterios installer"), ugettext("Instance not saved!"))
self.refresh(instance_name)
def save_inst(self):
instance_name = self.get_selected_instance_name()
if instance_name != '':
file_name = asksaveasfilename(
parent=self, filetypes=[('lbk', '.lbk'), ('*', '.*')])
if file_name != '':
self.save_instance(instance_name, file_name)
@ThreadRun
def restore_instance(self, instance_name, file_name):
if file_name[-4:] == '.bkf':
rest_inst = MigrateFromV1(instance_name, withlog=True)
else:
rest_inst = LucteriosInstance(instance_name)
rest_inst.filename = file_name
if rest_inst.restore():
showinfo(ugettext("Lucterios installer"), ugettext(
"Instance restore from %s") % file_name)
else:
showerror(
ugettext("Lucterios installer"), ugettext("Instance not restored!"))
self.refresh(instance_name)
def restore_inst(self):
instance_name = self.get_selected_instance_name()
if instance_name != '':
file_name = askopenfilename(
parent=self, filetypes=[('lbk', '.lbk'), ('bkf', '.bkf'), ('*', '.*')])
if file_name != '':
self.restore_instance(instance_name, file_name)
def execute(self):
self.refresh()
center(self, (700, 300))
self.mainloop()
class TimeClock(Frame):
def __init__(self, parent, *args, **kwargs):
Frame.__init__(self,parent, *args, **kwargs)
self.e=Entry(self,text='Message')
self.e.delete(0,"end")
self.e.pack()
self.makebuttons()
self.pack( expand='true', fill='x')
def makebuttons(self):
self.b1 = Button(self, text="Tock" ,
bg='BLUE', activebackground="Blue",
activeforeground='White',fg='white',
height='2', width='8' , command = self.write )
self.b2 = Button(self, text="Tick",
activebackground='red', bg='red',
activeforeground='White',fg='white',
command = self.quit )
self.b1.pack(side='right', fill='both')
self.b2.pack(side='left', fill='both')
self.lastTime = ""
self.start_timer()
def start_timer(self):
def callback():
#self.message=self.e.delete(0,"end")
self.message=self.e.get()
print ("input text is equal to->",self.message)
root.title(self.message+":TIMER")
self.e.destroy()
self.B.destroy()
self.B= Button(self,text='start', command=callback)
self.B.pack()
t=time.localtime()
self.zeroTime = dt.timedelta(hours=t[3], minutes=t[4], seconds=t[5])
self.tick()
def tick(self):
self.now = dt.datetime(1, 1, 1).now()
elapsedTime = self.now - self.zeroTime
time2 = elapsedTime.strftime('%H:%M:%S')
if time2 != self.lastTime:
self.lastTime = time2
self.b1.config(text=time2)
self.b2.config(text=self.now.strftime('%I:%M:%S'))
self.after(20, self.tick)
def write(self):
g=time.localtime()
Datename = dt.datetime(1,1,1).now().strftime('%Y%m%d')
my_Time = dt.timedelta(hours=g[3], minutes=g[4], seconds=g[5])
#filename="C:\Users\jpeters\Timer.log\\"+Datename+"_demo.csv"
filename="/home/jeff/Desktop/"+Datename+"_demo.csv"
file =open(filename, 'a' )
file.write(str(Datename))
file.write(', ')
file.write(str(my_Time))
file.write(', ')
file.write((self.lastTime))
file.write(', ')
file.write(str(self.message))
file.write('\n')
file.close()
self.start_timer()
def quit(self):
self.write()
root.destroy()
class TrendProg(Frame):
def __init__(self, parent):
Frame.__init__(self, parent, background='white')
# saved reference to parent widget. "Tk root window"
self.parent = parent
self._workbook = None
self._file_path = None
self._folder_path = None
# set properties of buttons
self.frame_1 = Frame(self, relief=RAISED)
self.run_button = Button(self, text='Run', width=10,
command=self.run_program)
self.file_button = Button(self.frame_1, text='Select File',
width=15, command=self.get_file)
self.folder_button = Button(self.frame_1, text='Select Folder',
width=15, command=self.get_folder)
self.close_button = Button(self, text='Close', width=10,
command=self.quit)
self.init_gui()
def init_gui(self):
self.parent.title('Trending Analysis')
# fill frame to take up whole of root window
self.pack(fill=BOTH, expand=True)
self.frame_1.pack(fill=BOTH, expand=True)
# put buttons on GUI
self.folder_button.pack(side=RIGHT, padx=5)
self.file_button.pack(side=LEFT, padx=5, pady=5)
self.close_button.pack(side=RIGHT, padx=5, pady=5)
self.run_button.pack(side=RIGHT, pady=5)
def get_file(self):
self._file_path = filedialog.askopenfilename()
if self._file_path != '':
self.file_button.config(text='File Selected!')
self.file_button.pack(fill=BOTH, expand=True, padx=5, pady=5)
self.folder_button.destroy()
def get_folder(self):
self._folder_path = filedialog.askdirectory()
if self._folder_path != '':
self.folder_button.config(text='Folder Selected!')
self.folder_button.pack(fill=BOTH, expand=True, padx=5, pady=5)
self.file_button.destroy()
def run_program(self):
workbook = 'Draft_Detail_Findings.xlsx'
worksheet = 'Template'
# user selected one CAPA
print('=' * 75)
if self._folder_path == '' or self._folder_path is None:
self._file_path = self.convert_to_docx(self._file_path)
docx_to_xlsx.main(self._file_path, workbook, worksheet)
print('=' * 75)
# user selected a folder of CAPA's
elif self._file_path == '' or self._file_path is None:
for f in os.listdir(self._folder_path):
# get full path name
file_name = str(self._folder_path + '/' + f)
file_name = self.convert_to_docx(file_name)
docx_to_xlsx.main(file_name, workbook, worksheet)
print('=' * 75)
# get ready to end the program
# pd = project_data.TrendData(workbook, worksheet)
print('Done.')
self.frame_1.destroy()
self.run_button.destroy()
self.close_button.config(text='Done.')
self.close_button.pack(fill=BOTH, expand=True, padx=10, pady=10)
@classmethod
def convert_to_docx(cls, file_selected):
""" Check that file(s) selected is .docx NOT .doc and convert if needed. """
if str(file_selected).endswith('.docx'):
return file_selected
else:
new_file_name = re.sub('.doc', '.docx', file_selected)
# full path to wordconv.exe
word_conv = r'C:\Program Files (x86)\Microsoft Office\Office12\wordconv.exe'
commands = ['wordconv.exe', '-oice', '-nme', file_selected, new_file_name]
try:
print('CONVERTING {}'.format(file_selected))
subprocess.Popen(commands, executable=word_conv)
# wait for converted file to be created
while not os.path.exists(new_file_name):
time.sleep(1.5)
print('REMOVING old .doc file ...')
os.remove(file_selected)
return new_file_name
except OSError:
print('FAILED to convert file. Check to see if it exists.')
class Experiment:
def __init__(self, master):
print("Ask")
self.filename = "playdata/" + str(input())
master.maxsize(1600, 900)
master.minsize(1600, 900)
self.state = diveGame()
self.master = master
master.title("Calculator")
self.topLabel = Label(master, text="", font=("Helvetica", 25))
self.topLabel.grid(row=0, column=15)
self.lbl = Label(
master,
text=
"Click on a location to prepare a move. If a tank is available and you are surfaced then you can purchase it.",
font=("Helvetica", 15))
self.lbl.grid(row=4, column=15)
self.var = tkinter.IntVar()
self.showing = False
self.distance = 0
self.locations = []
self.prevButton = None
self.buttons = {}
self.reset = Button(self.master,
text="Reset Distance Counter",
font=("Helvetica", 15),
command=self.resetDist)
self.reset.grid(row=7, column=15)
self.distanceLabel = Label(self.master,
text="",
font=("Helvetica", 14))
self.distanceLabel.grid(row=8, column=15)
self.file = {}
# f = open('store.pckl', 'rb')
# rR, rS, hR, hS, rA, hA = pickle.load(f)
#self.showRollout(rR)
self.experiment()
#self.playGame()
f = open(self.filename, "wb")
pickle.dump(self.file, f)
f.close()
def resetDist(self):
self.distance = 0
self.locations = []
self.distanceLabel.config(text=" ")
def destroyButtons(self):
for key, button in self.buttons.items():
button.destroy()
self.prevButton = None
def displayBoard(self, playing=True):
self.destroyButtons()
self.resetDist()
if playing:
self.lbl.config(
text=
"Click on a location to prepare a move. If a tank is available and you are surfaced then you can purchase it.",
fg="black")
if self.state.isOver():
self.lbl.config(text="GAMEOVER", fg="red")
tanks = [tank for tank in self.state.tanks]
self.cash = Label(self.master,
text=" Cash: " + str(self.state.cash) + " ",
font=("Helvetica", 15))
self.cash.grid(row=15, column=15)
self.time = Label(self.master,
text=" Time: " + str(self.state.timeLeft) +
" ",
font=("Helvetica", 15))
self.time.grid(row=16, column=15)
self.oxygen = Label(self.master,
text=" Oxygen Left: " +
str(self.state.oxygenLeft) + " / " +
str(self.state.tankSize),
font=("Helvetica", 15))
self.oxygen.grid(row=17, column=15)
self.holding = Label(self.master,
text=" Holding: " +
str(sum((self.state.holding))) + " ",
font=("Helvetica", 15))
self.holding.grid(row=18, column=15)
self.buttons['cash'] = self.cash
self.buttons['time'] = self.time
self.buttons['oxygen'] = self.oxygen
self.buttons['holding'] = self.holding
if playing:
def clickTank(action):
def executeMove():
def do():
self.move = action
if self.move in self.state.getLegalActions():
self.var.set(1)
if not self.showing:
if (self.state.playerLoc == (0, 0)
or self.state.playerLoc
== (0, 9)) and self.state.cash >= action[0]:
self.lbl.config(text="Tank | Cost: " +
str(action[0]) + " | Size: " +
str(action[1]))
if hasattr(self, 'next'):
self.next.destroy()
self.next = Button(self.master,
text="Execute Move",
font=("Helvetica", 15),
command=do)
self.next.grid(row=5, column=15)
self.buttons['next'] = self.next
else:
print(self.state.cash, action[1])
self.lbl.config(text="Cannot Buy Tank")
if self.prevButton:
prevbutton = self.buttons[self.prevButton]
if self.prevButton != self.state.playerLoc:
if self.prevButton == (
0, 0) or self.prevButton == (0, 9):
prevbutton.config(background="Green")
elif len(self.prevButton) == 3:
prevbutton.config(background="white")
else:
prevbutton.config(background="Light Gray")
self.buttons[action].config(background="orange")
self.prevButton = action
return do
return executeMove
else:
def clickTank(action):
pass
c = 0
if playing:
enabled = "normal"
else:
enabled = "disabled"
self.tanks = []
for tank in tanks:
if tank in self.state.getLegalActions():
t = Button(self.master,
text="Tank | Cost: " + str(tank[0]) + " | Size: " +
str(tank[1]),
font=("Helvetica", 15),
command=clickTank(tank),
state=enabled)
t.grid(row=10 + c, column=15)
self.tanks.append(t)
self.buttons[tank] = t
c += 1
else:
t = Button(self.master,
text="Tank | Cost: " + str(tank[0]) + " | Size: " +
str(tank[1]),
font=("Helvetica", 15),
command=clickTank(tank),
state=enabled)
t.config(state="disabled")
t.grid(row=10 + c, column=15)
self.tanks.append(t)
self.buttons[tank] = t
c += 1
if self.state.playerLoc == (
0, 0) or self.state.playerLoc == (0, 9) and playing:
def exit():
self.move = (None, None, 'exit')
self.var.set(1)
print("EXIT")
if (self.state.playerLoc == (0, 0)
or self.state.playerLoc == (0, 9)):
self.exit = Button(self.master,
text="EXIT with all your current cash! ",
font=("Helvetica", 15),
command=exit,
state=enabled)
self.buttons['exit'] = self.exit
self.exit.grid(row=19, column=15)
for i in range(0, 20):
for j in range(0, 10):
if not (i == 0 and (j < 9 and j > 0)):
bg = None
fg = "black"
color = "white"
font = ("Helvetica", 11)
if i > 0:
color = "navy"
if self.state.board[i][j]:
color = "Light Gray"
text = str(self.state.board[i][j])
elif (i, j) == (0, 0) or (i, j) == (0, 9):
text = ""
color = "Green"
else:
text = ""
if self.state.playerLoc == (i, j):
text = "P"
color = "Yellow"
fg = "brown4"
font = ("Helvetica", 10, "bold")
if self.state.playerLoc == (
i, j) and self.state.playerLoc[0] != 0:
color = "Yellow"
b = Button(self.master)
b.grid(row=i, column=j)
b.row = i
b.column = j
self.buttons[(i, j)] = b
def click(action):
i = action[0]
j = action[1]
def do():
valid = False
def executeMove(action):
def do():
self.move = action
self.prevButton = None
if self.move in self.state.getLegalActions(
):
self.var.set(1)
return do
if not self.showing:
if ((i, j) == (0, 0) or (i, j) ==
(0, 9)) and (i, j) != self.state.playerLoc:
valid = True
text = "Surface Location: " + str(
(i, j)
) # + "| distance is " + str(manDist((i, j), self.state.playerLoc))
if self.state.board[i][j]:
valid = True
text = "Pick up " + str(
self.state.board[i][j]
) + " at location " + str(
(i, j)
) # + " | distance is " + str(manDist((i, j), self.state.playerLoc))
if valid:
if self.prevButton:
prevbutton = self.buttons[
self.prevButton]
if self.prevButton != self.state.playerLoc:
if self.prevButton == (
0, 0
) or self.prevButton == (0, 9):
prevbutton.config(
background="Green")
else:
prevbutton.config(
background="Light Gray")
self.buttons[(i, j)].config(
background="orange")
self.prevButton = (i, j)
if not self.locations:
self.distance += manDist(
(i, j), self.state.playerLoc)
else:
self.distance += manDist(
(i, j), self.locations[-1])
self.locations += [(i, j)]
self.distanceLabel.config(
text=str(self.locations) + ": " +
str(self.distance))
self.lbl.config(text=text)
if hasattr(self, 'next'):
self.next.destroy()
self.next = Button(
self.master,
text="Execute Move",
font=("Helvetica", 15),
command=executeMove(action),
state=enabled)
self.next.grid(row=5, column=15)
self.buttons['next'] = self.next
return do
b.config(highlightthickness=0,
text=text,
width="3",
height="2",
font=font,
fg=fg,
command=click((i, j, "move")),
background=color)
def playGame(self):
self.showing = False
self.topLabel.config(
text=
" YOU ARE PLAYING THE GAME "
)
stateActions = []
states = []
states.append(self.state)
actions = []
times = []
self.displayBoard()
self.move = None
while (not self.state.isOver()):
now = datetime.now()
self.displayBoard()
root.wait_variable(self.var)
if self.move not in self.state.getLegalActions():
print(self.move, self.state.getLegalActions())
raise Exception
stateActions.append((self.state, self.move))
actions.append(self.move)
self.state = self.state.getSuccessor(self.move)[0]
self.move = None
self.var.set(0)
states.append(self.state)
then = datetime.now()
times.append(then - now)
self.lbl.config(text="Game Over, Your Score: " + str(self.state.cash))
self.topLabel.config(text="")
if 'playthrough' not in self.file:
self.file["playthrough"] = []
self.file["playthroughTimes"] = []
self.file['playthrough'].append((states, actions))
self.file['playthroughTimes'].append(times)
return actions, states
def playStates(self, states):
self.showing = False
self.topLabel.config(
text=
" Choose the next move in the state "
)
stateActions = []
times = []
for state in states:
now = datetime.now()
self.state = state
self.displayBoard()
root.wait_variable(self.var)
if self.move not in self.state.getLegalActions():
raise Exception
stateActions.append((self.state, self.move))
self.move = None
self.var.set(0)
for tank in self.tanks:
print("GI")
tank.destroy()
then = datetime.now()
times.append(then - now)
self.file['testStates'] = stateActions
self.file['testStatesTimes'] = times
return stateActions
def showRollout(self, states):
self.next.config(state="disabled")
self.exit.config(state="disabled")
self.showing = True
self.topLabel.config(
text="YOU ARE OBSERVING A SERIES OF STATES IN A PLAN")
self.nextState = tkinter.IntVar()
def nextState():
self.nextState.set(1)
for index, state in states:
self.lbl.config(text="STATE NUMBER: " + str(index), fg="green")
self.state = state
self.displayBoard(playing=False)
self.nextStateButton = Button(self.master,
text="Next State",
font=("Helvetica", 15),
command=nextState)
self.nextStateButton.grid(row=5, column=16)
root.wait_variable(self.nextState)
self.nextState.set(0)
self.nextStateButton.destroy()
self.topLabel.config(text="")
def showRolloutWithBack(self, states, ff=False):
self.destroyButtons()
times = []
actions = []
self.showing = True
if ff:
self.topLabel.config(
text="YOU ARE VIEWING A SUPERIOR ALTERNATE PLAN")
else:
self.topLabel.config(
text="YOU ARE OBSERVING A SERIES OF STATES IN A PLAN")
self.nextState = tkinter.IntVar()
def nextState():
self.nextState.set(1)
self.prev = False
actions.append("next")
def prevState():
self.nextState.set(1)
self.prev = True
actions.append("prev")
i = 0
while i < len(states):
if ff:
if i == len(states) - 2:
self.topLabel.config(
text=
" Right before your Fatal Flaw",
fg="red")
elif i == len(states) - 1:
self.topLabel.config(
text=
" Result of your Fatal Flaw",
fg="red")
else:
self.topLabel.config(
text=" YOU ARE OBSERVING A SERIES OF STATES IN A PLAN",
fg="black")
index, state = states[i]
self.lbl.config(text="STATE NUMBER: " + str(index), fg="green")
self.state = state
self.displayBoard(playing=False)
if hasattr(self, 'prevStateButton'):
self.prevStateButton.destroy()
self.nextStateButton.destroy()
self.nextStateButton = Button(self.master,
text="Next State",
font=("Helvetica", 15),
command=nextState)
self.nextStateButton.grid(row=6, column=17)
self.prevStateButton = Button(self.master,
text="Prev State",
font=("Helvetica", 15),
command=prevState)
self.prevStateButton.grid(row=6, column=16)
self.buttons['prevStateButton'] = self.prevStateButton
self.buttons['nextStateButton'] = self.nextStateButton
now = datetime.now()
root.wait_variable(self.nextState)
after = datetime.now()
times.append(after - now)
if self.prev:
if i > 0:
i -= 1
else:
i += 1
self.nextState.set(0)
self.topLabel.config(text="")
self.file["ShowRolloutActions"] = actions
self.file["ShowRolloutTimes"] = times
def experiment(self):
f = open("General Test States", "rb")
tStates = reconstructStates(pickle.load(f))
random.shuffle(tStates)
stateActions = self.playStates(tStates)
class BorrowDetails(ItemDetails):
def __init__(self, item, frame, row, maxDays, maxExtend):
self.frame = frame
self.maxDays = maxDays
self.maxExtend = maxExtend
self.item = item
self.row = row
self.reader = None
self.entries = {}
self.buttons = []
self.entries['period'] = StringVar()
self.heading(row=row, text='Kölcsönzés')
self.borrowerField(row=self.row + 1)
self.selectPeriod()
if self.get():
self.extendButton()
else:
self.borrowButton()
def selectPeriod(self):
self.optionMenu(row=self.row + 2,
key='period',
label='Kölcsönzési napok',
options=range(1, self.maxDays + 1))
def buttonReset(self):
# RESET BUTTONS
[button.grid_forget() for button in self.buttons]
self.buttons.clear()
def borrowButton(self):
self.buttonReset()
# Create and Place Borrow Button
self.buttons.append(
self.button(self.row + 3, 'Kölcsönzés', command=self.borrow))
def extendButton(self):
self.buttonReset()
# Create and Place Extend Button
self.buttons.append(
self.button(self.row + 3, 'Hosszabbítás', command=self.extend))
# Create and Place Return Button
self.buttons.append(
self.button(self.row + 4, 'Visszatérítés',
command=self.returnItem))
def borrowerField(self, row):
# Create and Place Label
self.label('Olvasó', row=row)
# Fetch Borrower's Name
try:
borrower = self.get().readers.name
except:
borrower = '...'
# CHOOSE BORROWER FIELD
# Create Borrower Field
self.borrower = Button(master=self.frame,
text=borrower,
command=self.select)
# Place Borrower Field
self.borrower.grid(row=row, column=1, sticky=W + E)
def get(self):
# Return Current Item's Borrow Record
table = getattr(Borrow, self.item.__tablename__)
return session.query(Borrow).filter(
table.has(id=self.item.id)).join(Reader).first()
def getDeadline(self):
# RETURN DEADLINE DATE:
# Current Date + Days to Borrow
# If Extending: Date = Deadline on Record
days = int(self.entries['period'].get() or 0)
date = self.get().deadline if self.get() else datetime.now().date()
return date + timedelta(days=days)
def extend(self):
# CURRENT ITEM'S BORROW RECORD
borrow = self.get()
period = self.entries['period']
# UPDATE BORROW RECORD
# Increase Extended Counter
# Update BorrowDeadline
update = Borrow(id=borrow.id,
deadline=self.getDeadline(),
extended=Borrow.extended + 1)
# Check If Maximum Number of Extensions Has Been Reached
if borrow.extended <= self.maxExtend + 1:
# Check If Lending Period Has Been Set
if period.get():
# Insert Data To DB
session.merge(update)
session.commit()
messagebox.showinfo('Hosszabbítás',
'Sikeresen meghosszabbítva')
else:
messagebox.showwarning('Hosszabbítás',
'A kölcsönzés többet nem hosszabbítható.')
# RESET SELECT PERIOD FIELD
period.set('')
def returnItem(self):
# Remove Returned Item from Borrows List
self.delete()
# Reset Fields
self.borrowButton()
self.borrowerField(self.row + 1)
self.entries['period'].set('')
def delete(self):
# Remove Returned Item from Borrows List
item = self.get()
item and session.delete(item)
session.commit()
def borrow(self):
# Delete Old Borrow
self.delete()
# Create New Borrow Record
borrow = Borrow(readers=self.reader, deadline=self.getDeadline())
# Set Borrowed Item
setattr(borrow, self.item.__tablename__, self.item)
# Number of Borrowed Items
count = session.query(Borrow).filter_by(
reader_id=self.reader.id).count()
# Check If Number of Borrowed Items Less Than 5
if count < 5:
if self.reader:
# Insert Data To DB
session.merge(borrow)
session.commit()
self.extendButton() # Reset
messagebox.showinfo('Kölcsönzés', 'Kikölcsönözve.')
else:
messagebox.showerror(
'Kölcsönzés',
'A maxiumum kölcsönözhető dokumentumok meghaladva.')
# RESET SELECT PERIOD FIELD
self.entries['period'].set('')
def select(self):
# Fetch Reader ID From Dialog
readerId = ReadersDialog(self.frame).show()
# Fetch Reader By ID
self.reader = session.query(Reader).get(readerId)
# Set Reader Name On Button
self.borrower.config(text=self.reader.name)
# Reset
self.borrowButton()
class Gui:
def __init__(self, root):
self.root = root
self.path = StringVar()
self.outpath = StringVar()
self.file_dir = ''
self.save_dir = ''
Label(self.root, text="").grid(row=0, column=0)
Label(self.root, text="原始文件:").grid(row=1, column=0)
Entry(self.root, textvariable=self.path, width=40).grid(row=1,
column=1)
Button(self.root, text="打开", command=self.selectPath).grid(row=1,
column=3)
Label(self.root, text="保存文件:").grid(row=2, column=0)
Entry(self.root, textvariable=self.outpath, width=40).grid(row=2,
column=1)
Button(self.root, text="保存",
command=self.select_outPath).grid(row=2, column=3)
self.lb = Label(self.root, text='欢迎 !')
self.lb.grid(row=3, column=1)
self.bt = Button(self.root, text="生成报告", command=self.run)
self.bt.grid(row=4, column=1)
self.write_ok = False
self.err = False
def selectPath(self):
self.file_dir = askdirectory()
self.save_dir = self.file_dir
self.path.set(self.file_dir)
self.outpath.set(self.file_dir)
self.err = False
def select_outPath(self):
self.save_dir = askdirectory()
self.outpath.set(self.save_dir)
def run(self):
self.lb.config(text="运行...")
th = threading.Thread(target=self.write)
th.start()
th2 = threading.Thread(target=self.ui)
th2.start()
def ui(self):
if not self.write_ok:
self.bt.config(state='disabled')
while not self.write_ok:
time.sleep(3)
self.bt.config(state='normal')
if not self.err:
self.lb.config(text="完成！")
def write(self):
self.write_ok = False
try:
writer = Writer(self.file_dir, self.save_dir)
writer.write_doc()
writer.write_pdf()
self.write_ok = True
except Exception as e:
print(e)
self.err = True
self.lb.config(text="路径或文件错误！")
self.write_ok = True
class App():
global minutesEnd, secondsEnd, mode
mode = -1 # -1 = timer off; 0 = workout (timer on); 1 = relax (timer on)
def __init__(self):
# main-window
self.window = Tk()
self.window.resizable(False, False)
self.window.wm_geometry(
"+%d+%d" %
((self.window.winfo_screenwidth() - self.window.winfo_reqwidth()) /
3,
(self.window.winfo_screenheight() - self.window.winfo_reqheight())
/ 3))
self.window.geometry("490x280")
self.window.title("Workouts")
# label with current time
self.labelCurrentTime = Label(font=("", 25), pady=5)
self.labelCurrentTime.grid(row=0, column=0, columnspan=4)
self.label1 = Label(self.window,
text="Number of minutes for workout:",
anchor='w',
width=23)
self.label1.grid(row=1, column=0)
self.entryMinutesForWork = Entry(self.window, width=2)
self.entryMinutesForWork.insert(0, "5")
self.entryMinutesForWork.grid(row=1, column=1)
self.label2 = Label(self.window,
text="Number of seconds for workout:",
anchor='w',
width=23)
self.label2.grid(row=1, column=2)
self.entrySecondsForWork = Entry(self.window, width=2)
self.entrySecondsForWork.insert(0, "0")
self.entrySecondsForWork.grid(row=1, column=3)
self.label3 = Label(self.window,
text="Number of minutes for relax:",
anchor='w',
width=23)
self.label3.grid(row=2, column=0)
self.entryMinutesForRelax = Entry(self.window, width=2)
self.entryMinutesForRelax.insert(0, "5")
self.entryMinutesForRelax.grid(row=2, column=1)
self.label4 = Label(self.window,
text="Number of seconds for relax:",
anchor='w',
width=23)
self.label4.grid(row=2, column=2)
self.entrySecondsForRelax = Entry(self.window, width=2)
self.entrySecondsForRelax.insert(0, "0")
self.entrySecondsForRelax.grid(row=2, column=3)
# start/stop
self.buttonStart = Button(self.window,
text="Start",
font=("", 20),
pady=10)
self.buttonStart.grid(row=3, column=0, columnspan=4)
self.buttonStart.bind("<Button-1>", self.startStop)
# timer
self.labelTimer = Label(text="Press Start", font=("", 70), pady=15)
self.labelTimer.grid(row=4, column=0, columnspan=4)
# settings menu bar
menubar = Menu()
self.window.config(menu=menubar)
fileMenu = Menu(menubar, tearoff=0)
menubar.add_cascade(label="File", menu=fileMenu)
fileMenu.add_command(label="About Minesweeper", command=self.aboutApp)
fileMenu.add_separator()
fileMenu.add_command(label="Exit", command=exit)
self.startTimer()
self.window.mainloop()
# about-window
def aboutApp(self):
# creation about-window if there is not
if self.window.winfo_children().__len__() == 12:
aboutWindow = Toplevel(self.window)
aboutWindow.title("About Workouts")
aboutWindow.geometry("260x120")
aboutWindow.resizable(False, False)
aboutWindow.wm_geometry("+%d+%d" %
((aboutWindow.winfo_screenwidth() / 2 -
aboutWindow.winfo_reqwidth()),
(aboutWindow.winfo_screenheight() / 2 -
aboutWindow.winfo_reqheight())))
_ = Label(aboutWindow,
text="Workouts by Andrew Jeus",
font=("", 18)).grid(row=0, column=0, padx=10, pady=10)
_ = Label(aboutWindow,
text="Version 1.0 (14 July 2019)",
font=("", 18)).grid(row=1, column=0)
labelInfo3 = Label(aboutWindow,
text="View code in GitHub",
font=("", 14))
labelInfo3.grid(row=2, column=0, padx=5, pady=5)
# my font for link to GitHub
myfont = font.Font(labelInfo3, labelInfo3.cget("font"))
myfont.configure(underline=True)
labelInfo3.configure(font=myfont)
labelInfo3.bind(
"<Button-1>", lambda _: webbrowser.open_new(
"https://github.com/MickeyMouseMouse/Workouts"))
def startTimer(self):
global minutesEnd, secondsEnd, mode
# update current time
self.labelCurrentTime.config(
text=time.strftime("%H:%M:%S", time.localtime()))
if mode != -1:
tmpSeconds = secondsEnd - int(time.strftime(
"%S", time.localtime()))
tmpMinutes = minutesEnd - int(time.strftime(
"%M", time.localtime()))
if tmpSeconds == 0 and tmpMinutes == 0:
if mode == 0:
mode = 1
else:
mode = 0
self.setEndTime()
if tmpSeconds < 0:
tmpSeconds = secondsEnd + (
60 - int(time.strftime("%S", time.localtime())))
tmpMinutes -= 1
if tmpMinutes < 0:
tmpMinutes = minutesEnd + (
60 - int(time.strftime("%M", time.localtime())))
self.labelTimer.config(text=tmpMinutes.__str__() + " : " +
tmpSeconds.__str__())
# repeat this function after 1 second
self.window.after(1000, self.startTimer)
def setEndTime(self):
global secondsEnd, minutesEnd, mode
secondsEnd = int(time.strftime("%S", time.localtime()))
minutesEnd = int(time.strftime("%M", time.localtime()))
if mode == 0:
secondsEnd += int(self.entrySecondsForWork.get())
minutesEnd += int(self.entryMinutesForWork.get())
self.labelTimer.config(fg="red")
else:
secondsEnd += int(self.entrySecondsForRelax.get())
minutesEnd += int(self.entryMinutesForRelax.get())
self.labelTimer.config(fg="green")
if secondsEnd >= 60:
secondsEnd %= 60
minutesEnd += 1
if minutesEnd >= 60:
minutesEnd %= 60
# checking the correctness of the input values
def isInputCorrect(self):
if not (self.entryMinutesForWork.get().isdigit()
and int(self.entryMinutesForWork.get()) in range(60)):
return False
if not (self.entrySecondsForWork.get().isdigit()
and int(self.entrySecondsForWork.get()) in range(60)):
return False
if not (self.entryMinutesForRelax.get().isdigit()
and int(self.entryMinutesForRelax.get()) in range(60)):
return False
if not (self.entrySecondsForRelax.get().isdigit()
and int(self.entrySecondsForRelax.get()) in range(60)):
return False
if (self.entryMinutesForWork.get() == "0"
and self.entrySecondsForWork.get() == "0"
and self.entryMinutesForRelax.get() == "0"
and self.entrySecondsForRelax.get() == "0"):
return False
return True
# start/stop timer
def startStop(self, _):
global mode
if mode == -1:
if self.isInputCorrect():
mode = 0
self.buttonStart.config(text="Stop")
self.labelTimer.config(text="")
self.setEndTime()
else:
self.entryMinutesForWork.delete(0, 'end')
self.entrySecondsForWork.delete(0, 'end')
self.entryMinutesForRelax.delete(0, 'end')
self.entrySecondsForRelax.delete(0, 'end')
self.labelTimer.config(text="Incorrect Input")
else:
mode = -1
self.buttonStart.config(text="Start")
self.labelTimer.config(fg="black")
self.labelTimer.config(text="Press Start")
class _Tk_Nosy(object):
"""This class is the tkinter GUI object"""
def __init__(self, master):
self.dirname = os.path.abspath( os.curdir )
self.initComplete = 0
self.master = master
self.x, self.y, self.w, self.h = -1,-1,-1,-1
# bind master to <Configure> in order to handle any resizing, etc.
# postpone self.master.bind("<Configure>", self.Master_Configure)
self.master.bind('<Enter>', self.bindConfigure)
self.menuBar = Menu(master, relief = "raised", bd=2)
top_Directory = Menu(self.menuBar, tearoff=0)
top_Directory.add("command", label = "Change Dir", command = self.menu_Directory_Change_Dir)
self.menuBar.add("cascade", label="Directory", menu=top_Directory)
#top_Snippet = Menu(self.menuBar, tearoff=0)
self.menuBar.add("command", label = "Run", command = self.menu_Run)
master.config(menu=self.menuBar)
# make a Status Bar
self.statusMessage = StringVar()
self.statusMessage.set(self.dirname)
self.statusbar = Label(self.master, textvariable=self.statusMessage, bd=1, relief=SUNKEN)
self.statusbar.pack(anchor=SW, fill=X, side=BOTTOM)
self.statusbar_bg = self.statusbar.cget('bg') # save bg for restore
myFont = tkinter.font.Font(family="Arial", size=12, weight=tkinter.font.BOLD)
self.statusbar.config( font=myFont )
frame = Frame(master)
frame.pack(anchor=NE, fill=BOTH, side=TOP)
self.Pass_Fail_Button = Button(frame,text="Pass/Fail Will Be Shown Here",
image="", width="15", background="green",
anchor=W, justify=LEFT, padx=2)
self.Pass_Fail_Button.pack(anchor=NE, fill=X, side=TOP)
self.Pass_Fail_Button.bind("<ButtonRelease-1>", self.Pass_Fail_Button_Click)
#self.master.title("tk_nosy")
self.master.title('Python %s.%s.%s '%sys.version_info[:3])
self.oscillator = 1 # animates character on title
self.oscillator_B = 0 # used to return statusbar to statusbar_bg
self.lbframe = Frame( frame )
self.lbframe.pack(anchor=SE, side=LEFT, fill=BOTH, expand=1)
scrollbar = Scrollbar(self.lbframe, orient=VERTICAL)
self.Text_1 = Text(self.lbframe, width="80", height="24", yscrollcommand=scrollbar.set)
scrollbar.config(command=self.Text_1.yview)
scrollbar.pack(side=RIGHT, fill=Y)
self.Text_1.pack(side=LEFT, fill=BOTH, expand=1)
self.master.resizable(1,1) # Linux may not respect this
self.numNosyCalls = 0
self.need_to_pick_dir = 1
if len(sys.argv)>1:
# I don't care what the exception is, if there's a problem, bail
# pylint: disable=W0702
try:
dirname = os.path.abspath( sys.argv[1] )
self.try_change_to_new_dir( dirname )
except:
pass # let Alarm force dir selection
else:
try:
if os.path.isdir(os.path.join( self.dirname, 'tests' )):
self.try_change_to_new_dir( self.dirname )
except:
pass # let Alarm force dir selection
print(LICENSE)
self.Alarm()
def try_change_to_new_dir(self, dirname):
"""A legal abspath will switch to dirname."""
# I don't care what the exception is, if there's a problem, bail
# pylint: disable=W0702
if dirname:
try:
dirname = os.path.abspath( dirname )
except:
return # let Alarm force dir selection
else:
return
self.dirname = dirname
print('Selected dirname =',dirname)
fileD.clear()
os.chdir( self.dirname )
self.reset_statusbar_bg()
self.need_to_pick_dir = 0
#with open(NOSY_USER_DATA_FILE, 'w') as text_file:
# text_file.write( self.dirname )
self.numNosyCalls = 0
def reset_statusbar_bg(self):
"""Return status bar to default state"""
self.statusbar.config(bg=self.statusbar_bg)
self.statusMessage.set(self.dirname)
def set_statusbar_bg(self, c):
"""Set status bar to show new color and message"""
self.statusbar.config(bg=c)
self.oscillator_B = 1 # will return to initial color after a few cycles
def menu_Directory_Change_Dir(self):
"""Menu selection to set directory in which to run nosetests"""
dirname = self.AskDirectory( title='Choose Directory For Nose Tests', initialdir=".")
if dirname:
self.try_change_to_new_dir( dirname )
# >>>>>>insert any user code below this comment for section "menu_Directory_Change_Dir"
# replace, delete, or comment-out the following
print("called menu_Directory_Change_Dir")
def menu_Run(self):
"""User initiates a nosetests run, not file change detection."""
print("called menu_Run")
self.callNosy()
def callNosy(self):
"""Run nosetests and display results"""
self.numNosyCalls += 1
self.Text_1.delete(1.0, END)
# turn indicator button gray while running the tests
myFont = tkinter.font.Font(family="Arial", size=12, weight=tkinter.font.BOLD)
self.Pass_Fail_Button.config(background="#999999", text='TESTING...', font=myFont)
self.master.update()
self.master.update_idletasks()
# pylint: disable=W0201
self.passedAllTests, numPassed, numFailed, numErrors, numSkipped, outputTextL = \
run_nosetests(self.numNosyCalls)
max_len_s = 42
num_lines = 1
for s in outputTextL:
self.Text_1.insert(END, s)
sL = s.split('\n')
for ss in sL:
max_len_s = max(max_len_s, len(ss))
num_lines += 1
if self.numNosyCalls % 2:
myFont = tkinter.font.Font(family="Arial", size=12, weight=tkinter.font.BOLD)
else:
myFont = tkinter.font.Font(family="Arial", size=12)
if self.passedAllTests:
s = 'PASSED'
if numPassed > 1:
s = 'PASSED ALL %i TESTS'%numPassed
elif numPassed == 1:
s = 'PASSED ONE TEST'
bg="#00ff00"
if numSkipped==1:
s = 'passed with 1 SKIP'
bg = "#00cc00"
elif numSkipped > 1:
s = 'passed with %i SKIPS'%numSkipped
bg = "#00cc00"
elif numPassed==0:
s = 'No Tests Found'
bg="#ff8000"
self.Pass_Fail_Button.config(background=bg, text=s, font=myFont)
#self.master.geometry('200x50')
else:
s = 'FAILED %i, ERRORS %i, SKIP %i, PASSED %i'%(numFailed,
numErrors, numSkipped, numPassed)
self.Pass_Fail_Button.config(background="#ff0000", text=s, font=myFont)
#self.master.geometry('516x385')
# Show list of files being watched.
#self.Text_1.insert(END, '_'*40+'\n')
self.Text_1.insert(END, 'WATCHED *.py FILES'.center(40,'_') + '\n' )
self.Text_1.insert(END, '%s%s..\n\n'%(self.dirname,os.path.sep) )
num_lines += 3
len_dirname = len( self.dirname )
keyL = list(fileD.keys())
keyL.sort()
lastdir = ''
for key in keyL:
dn = os.path.dirname( key )
if dn != lastdir:
self.Text_1.insert(END, '..'+dn[len_dirname:] + '\n')
max_len_s = max(max_len_s, len(dn)+1)
lastdir = dn
num_lines += 1
s = ' ' +os.path.basename( key )
self.Text_1.insert(END, s + '\n')
max_len_s = max(max_len_s, len(s)+1)
num_lines += 1
self.Text_1.config(width=max_len_s)
self.Text_1.config(height=min(40, num_lines))
self.master.winfo_toplevel().wm_geometry("")
def bindConfigure(self, event):
"""Part of goofy main window setup in tkinter."""
# tkinter requires arguments, but I don't use them
# pylint: disable=W0613
if not self.initComplete:
self.master.bind("<Configure>", self.Master_Configure)
self.initComplete = 1
# return a string containing directory name
def AskDirectory(self, title='Choose Directory', initialdir="."):
"""Run pop-up menu for user to select directory."""
# This is not an error
# pylint: disable=E1101
if sys.version_info < (3,):
dirname = tkFileDialog.askdirectory(parent=self.master,
initialdir=initialdir,title=title)
else:
dirname = tkinter.filedialog.askdirectory(parent=self.master,
initialdir=initialdir,title=title)
return dirname # <-- string
def Master_Configure(self, event):
"""Part of tkinter main window initialization"""
if event.widget != self.master:
if self.w != -1:
return
x = int(self.master.winfo_x())
y = int(self.master.winfo_y())
w = int(self.master.winfo_width())
h = int(self.master.winfo_height())
if (self.x, self.y, self.w, self.h) == (-1,-1,-1,-1):
self.x, self.y, self.w, self.h = x,y,w,h
if self.w!=w or self.h!=h:
#print "Master reconfigured... make resize adjustments"
self.w=w
self.h=h
def Pass_Fail_Button_Click(self, event):
"""Place-holder routine for user clicking Pass/Fail Button"""
pass
# alarm function is called after specified number of milliseconds
def SetAlarm(self, milliseconds=1000):
"""Reinitialize tkinter alarm mechanism as well as update seconds
counter in main window title bar.
"""
self.master.after( milliseconds, self.Alarm )
self.oscillator += 1
if self.oscillator > 5:
self.oscillator = 0
if self.oscillator_B>0:
self.oscillator_B += 1
if self.oscillator_B>5:
self.oscillator_B = 0
self.reset_statusbar_bg()
pad = '|'*self.oscillator
#self.master.title("%i) tk_nosy "%self.numNosyCalls + pad )
s = '%s.%s.%s '%sys.version_info[:3]
self.master.title('%i) Python %s '%(self.numNosyCalls , s + pad ))
def Alarm(self):
"""Look for changed files every second, then reset alarm"""
if self.need_to_pick_dir:
dirname = self.AskDirectory( title='Choose Directory For Nose Tests', initialdir=".")
self.try_change_to_new_dir( dirname )
#first call to numberOfChangedFiles will be > 0 if any .py files are found
elif numberOfChangedFiles( self.dirname ) > 0: # or self.numNosyCalls==0
self.callNosy()
self.SetAlarm()
class CurrencyConverterUI(Tk):
"""This display text field and button to interact with to change money"""
def __init__(self, converter):
"""Creates a window to convert currency
:param converter: the model of a currency converter
"""
Tk.__init__(self)
self.title = 'Currency Converter'
self.currency_converter = converter
self.geometry("500x200")
# Label
self.intro_label = Label(self,
text='Welcome to Real Time Currency Convertor',
fg='blue', relief=RAISED, borderwidth=3)
self.intro_label.config(font=('Courier', 15, 'bold'))
self.date_label = Label(
self,
text=f"1 Canadian Dollar = "
f"{self.currency_converter.convert('CAD', 'USD', 1)}"
f" USD \n Date : {self.currency_converter.data['date']}",
relief=GROOVE, borderwidth=5)
self.intro_label.place(x=10, y=5)
self.date_label.place(x=170, y=50)
# Entry box
valid = (self.register(self.restrict_number_only), '%P')
# restric NumberOnly function will restrict this user to enter
# invavalid number in Amount field. We will define it later in code
self.amount_field = Entry(self, bd=3, relief=RIDGE,
justify=CENTER, validate='key',
validatecommand=valid)
self.converted_amount_field_label = Label(self, text='', fg='black',
bg='white', relief=RIDGE,
justify=CENTER, width=17,
borderwidth=3)
# dropdown
self.from_currency_variable = StringVar(self)
self.from_currency_variable.set("CAD") # default value
self.to_currency_variable = StringVar(self)
self.to_currency_variable.set("USD") # default value
font = ("Courier", 12, "bold")
self.option_add('*TCombobox*Listbox.font', font)
self.from_currency_dropdown = Combobox(
self,
textvariable=self.from_currency_variable,
values=list(self.currency_converter.currencies.keys()),
font=font, state='readonly',
width=12, justify=CENTER)
self.to_currency_dropdown = Combobox(
self,
textvariable=self.to_currency_variable,
values=list(
self.currency_converter.currencies.keys()),
font=font, state='readonly',
width=12, justify=CENTER)
# placing
self.from_currency_dropdown.place(x=30, y=120)
self.amount_field.place(x=36, y=150)
self.to_currency_dropdown.place(x=340, y=120)
# self.converted_amount_field.place(x = 346, y = 150)
self.converted_amount_field_label.place(x=346, y=150)
# Convert button
self.convert_button = Button(self, text="Convert", fg="black",
command=self.perform)
self.convert_button.config(font=('Courier', 10, 'bold'))
self.convert_button.place(x=225, y=135)
def perform(self):
"""Performs the conversion of a currency to another using the model
:return: None
"""
amount = float(self.amount_field.get())
from_curr = self.from_currency_variable.get()
to_curr = self.to_currency_variable.get()
converted_amount = self.currency_converter.convert(from_curr,
to_curr, amount)
converted_amount = round(converted_amount, 2)
self.converted_amount_field_label.config(text=str(converted_amount))
def restrict_number_only(self, string):
"""Restrict the uses of numbers only in text fields
:param string: the input to validate
:return: True if the input is number only, False otherwise
"""
regex = re.compile(r"[0-9,]*?(\.)?[0-9,]*$")
result = regex.match(string)
return string == "" or (string.count('.') <= 1 and result is not None)
class Vaisseaux(object):
'''
classdocs
'''
def __init__(self,grille,canvas,logo):
self.grille = grille
self.canvas = canvas
self.logo= logo
self.B = Button(self.canvas, text ="Commencer",command = self.ouvrirDialogue1)
self.B.pack(side = tk.BOTTOM,pady=80)
self.posX = 0
self.posY = 0
# Cette fonction est appelee pour placer les vaisseaux au debut du jeux
def placer_vaisseaux1(self):
self.grille.canvas.bind("<Button-1>", self.jouer1)
self.B.config(state=DISABLED)
# Cette fonction permet au joueur 1 de palcer ses vaisseaux
def jouer1(self,event):
if (self.grille.nbVaisseauxPlaces(self.grille.pos) < 5):
if(self.grille.getCasePos(event.x//40,event.y//40,1).getcouleur() == "green" or self.grille.nbVaisseauxPlaces(self.grille.pos) == 0):
self.effacerGreen(1)
self.grille.getCasePos(event.x//40,event.y//40,1).setsituation(2)
self.guider(event.x//40,event.y//40,1)
self.grille._dessiner_grille()
self.posX = event.x//40
self.posY = event.y//40
if(self.grille.nbVaisseauxPlaces(self.grille.pos) == 5):
self.posX = 0
self.posY = 0
self.ouvrirDialogue2()
#self.placer_vaisseaux2()
# Cette fonction permet au joueur 2 de palcer ses vaisseaux
def placer_vaisseaux2(self):
self.grille.canvas1.bind("<Button-1>", self.jouer2)
# Cette fonction permet au joueur 2 de palcer ses vaisseaux
def jouer2(self,event):
if (self.grille.nbVaisseauxPlaces(self.grille.pos2) < 5):
if(self.grille.getCasePos(event.x//40,event.y//40,2).getcouleur() == "green" or self.grille.nbVaisseauxPlaces(self.grille.pos2) == 0):
self.effacerGreen(2)
self.grille.getCasePos(event.x//40,event.y//40,2).setsituation(2)
self.guider(event.x//40,event.y//40,2)
self.grille._dessiner_grille()
self.posX = event.x//40
self.posY = event.y//40
if(self.grille.nbVaisseauxPlaces(self.grille.pos2) == 5):
self.grille.commencer()
self.grille._dessiner_grille()
showinfo("Au joueur 1 de jouer", "Essayez de trouvez le vaisseau du joueur 2 !!")
self.grille.permuterGrilles(self.grille.pos,self.grille.pos2)
Jouer(self.grille,self.B)
def guider(self,pos1,pos2,num):
if(num == 1):
tableau = self.grille.pos
else:
tableau = self.grille.pos2
if (self.posX == 0 and self.posY == 0):
self.grille.getCasePos(pos1+1,pos2,num).setcouleur("green")
self.grille.getCasePos(pos1-1,pos2,num).setcouleur("green")
self.grille.getCasePos(pos1,pos2+1,num).setcouleur("green")
self.grille.getCasePos(pos1,pos2-1,num).setcouleur("green")
elif(pos1 > self.posX and self.grille.nbVaisseauxPlaces(tableau) < 5 ):
if(pos1 == self.grille.width - 1):
pos1 = pos1 - self.grille.nbVaisseauxPlaces(tableau)
self.grille.getCasePos(pos1,pos2,num).setcouleur("green")
else:
self.grille.getCasePos(pos1+1,pos2,num).setcouleur("green")
elif(pos1 < self.posX and self.grille.nbVaisseauxPlaces(tableau) < 5):
if(pos1 == 0):
pos1 = pos1 + self.grille.nbVaisseauxPlaces(tableau)
self.grille.getCasePos(pos1,pos2,num).setcouleur("green")
else:
self.grille.getCasePos(pos1-1,pos2,num).setcouleur("green")
elif(pos2 > self.posY and self.grille.nbVaisseauxPlaces(tableau) < 5 ):
if(pos2 == self.grille.height - 1):
pos2 = pos2 - self.grille.nbVaisseauxPlaces(tableau)
self.grille.getCasePos(pos1,pos2,num).setcouleur("green")
else:
self.grille.getCasePos(pos1,pos2+1,num).setcouleur("green")
elif(pos2 < self.posY and self.grille.nbVaisseauxPlaces(tableau) < 5 ):
if(pos2 == 0):
pos2 = pos2 + self.grille.nbVaisseauxPlaces(tableau)
self.grille.getCasePos(pos1,pos2,num).setcouleur("green")
else:
self.grille.getCasePos(pos1,pos2-1,num).setcouleur("green")
def effacerGreen(self,num):
for i in range(self.grille.width):
for j in range(self.grille.height):
if(self.grille.getCasePos(i,j,num).getcouleur() == "green"):
self.grille.getCasePos(i,j,num).setcouleur("black")
self.grille._dessiner_grille()
def placerVaisseauAleatoire(self):
r = random.randint(1,10)
for i in range(1,6):
self.grille.getCasePos(r,i,1).setsituation(2)
self.grille._dessiner_grille()
self.ouvrirDialogue2()
def placerVaisseauAleatoire2(self):
r = random.randint(1,10)
for i in range(1,6):
self.grille.getCasePos(r,i,2).setsituation(2)
self.grille._dessiner_grille()
showinfo("Joueur 1", "Au joueur 1 de jouer !!")
self.grille.commencer()
self.grille._dessiner_grille()
self.grille.permuterGrilles(self.grille.pos,self.grille.pos2)
Jouer(self.grille,self.B)
def ouvrirDialogue1(self):
if messagebox.askquestion("Joueur 1", "Voulez vous placez les vaisseausx aléatoirement?")=="no":
showinfo("Joueur 1", "Placez votre vaisseau en cliquant sur 5 cases de votre grille !!")
self.placer_vaisseaux1()
else:
self.B.config(state=DISABLED)
self.placerVaisseauAleatoire()
def ouvrirDialogue2(self):
if messagebox.askquestion("Joueur 2", "Voulez vous placez les vaisseausx aléatoirement?")=="no":
showinfo("Joueur 2", "Placez votre vaisseau en cliquant sur 5 cases de votre grille !!")
self.placer_vaisseaux2()
else:
self.placerVaisseauAleatoire2()
class AnalysisToolsManager:
def __init__(self, controller):
self.tab = None
self.controller = controller
self.tk_format = utils.TkFormat(self.controller.config_info)
self.analysis_dialog = None
self.exclude_artifacts = IntVar()
self.abs_val = IntVar()
self.use_max_for_centers = IntVar()
self.use_delta = IntVar()
self.neg_depth = IntVar()
self.normalize_entry = None
self.right_zoom_entry = None
self.right_zoom_entry2 = None
self.left_zoom_entry = None
self.left_zoom_entry2 = None
self.left_slope_entry = None
self.right_slope_entry = None
self.slopes_listbox = None
self.abs_val_check = None
self.use_max_for_centers_check = None
self.use_delta_check = None
self.neg_depth_check = None
self.exclude_artifacts_check = None
self.extra_analysis_check_frame = None
self.plot_slope_var = None
self.offset_entry = None
self.offset_sample_var = None
self.plot_slope_menu = None
self.plot_slope_button = None
self.analyze_var = None
self.outer_slope_frame = None
self.slope_results_frame = None
def show(self, tab):
self.tab = tab
self.tab.freeze(
) # You have to finish dealing with this before, say, opening another analysis box.
buttons = {
"reset": {
self.select_tab: [],
self.tab.reset: [],
self.uncheck_exclude_artifacts: [],
self.disable_plot: [],
# utils.thread_lift_widget: [],
},
"close": {},
}
self.analysis_dialog = VerticalScrolledDialog(self.controller,
"Analyze Data",
"",
buttons=buttons,
button_width=13)
self.analysis_dialog.top.attributes("-topmost", True)
outer_normalize_frame = Frame(self.analysis_dialog.interior,
bg=self.tk_format.bg,
padx=self.tk_format.padx,
pady=15,
highlightthickness=1)
outer_normalize_frame.pack(expand=True, fill=BOTH)
slope_title_label = Label(outer_normalize_frame,
text="Normalize:",
bg=self.tk_format.bg,
fg=self.tk_format.textcolor)
slope_title_label.pack()
normalize_frame = Frame(outer_normalize_frame,
bg=self.tk_format.bg,
padx=self.tk_format.padx,
pady=15)
normalize_frame.pack()
normalize_label = Label(normalize_frame,
text="Wavelength (nm):",
bg=self.tk_format.bg,
fg=self.tk_format.textcolor)
self.normalize_entry = Entry(
normalize_frame,
width=7,
bd=self.tk_format.bd,
bg=self.tk_format.entry_background,
selectbackground=self.tk_format.selectbackground,
selectforeground=self.tk_format.selectforeground,
)
normalize_button = Button(
normalize_frame,
text="Apply",
command=self.normalize,
width=6,
fg=self.tk_format.buttontextcolor,
bg=self.tk_format.buttonbackgroundcolor,
bd=self.tk_format.bd,
)
normalize_button.config(
fg=self.tk_format.buttontextcolor,
highlightbackground=self.tk_format.highlightbackgroundcolor,
bg=self.tk_format.buttonbackgroundcolor,
)
normalize_button.pack(side=RIGHT, padx=(10, 10))
self.normalize_entry.pack(side=RIGHT, padx=self.tk_format.padx)
normalize_label.pack(side=RIGHT, padx=self.tk_format.padx)
outer_offset_frame = Frame(self.analysis_dialog.interior,
bg=self.tk_format.bg,
padx=self.tk_format.padx,
pady=15,
highlightthickness=1)
outer_offset_frame.pack(expand=True, fill=BOTH)
slope_title_label = Label(outer_offset_frame,
text="Add offset to sample:",
bg=self.tk_format.bg,
fg=self.tk_format.textcolor)
slope_title_label.pack(pady=(0, 15))
offset_sample_frame = Frame(outer_offset_frame,
bg=self.tk_format.bg,
padx=self.tk_format.padx,
pady=self.tk_format.pady)
offset_sample_frame.pack()
offset_sample_label = Label(offset_sample_frame,
text="Sample: ",
bg=self.tk_format.bg,
fg=self.tk_format.textcolor)
offset_sample_label.pack(side=LEFT)
self.offset_sample_var = StringVar()
sample_names = []
repeats = False
max_len = 0
for sample in self.tab.samples:
if sample.name in sample_names:
repeats = True
else:
sample_names.append(sample.name)
max_len = np.max([max_len, len(sample.name)])
if repeats:
sample_names = []
for sample in self.tab.samples:
sample_names.append(sample.title + ": " + sample.name)
max_len = np.max([max_len, len(sample_names[-1])])
self.offset_sample_var.set(sample_names[0])
# pylint: disable = no-value-for-parameter
offset_menu = OptionMenu(offset_sample_frame, self.offset_sample_var,
*sample_names)
offset_menu.configure(
width=max_len,
highlightbackground=self.tk_format.highlightbackgroundcolor)
offset_menu.pack(side=LEFT)
offset_frame = Frame(outer_offset_frame,
bg=self.tk_format.bg,
padx=self.tk_format.padx,
pady=15)
offset_frame.pack()
offset_label = Label(offset_frame,
text="Offset:",
bg=self.tk_format.bg,
fg=self.tk_format.textcolor)
self.offset_entry = Entry(
offset_frame,
width=7,
bd=self.tk_format.bd,
bg=self.tk_format.entry_background,
selectbackground=self.tk_format.selectbackground,
selectforeground=self.tk_format.selectforeground,
)
offset_button = Button(
offset_frame,
text="Apply",
command=self.offset,
width=6,
fg=self.tk_format.buttontextcolor,
bg=self.tk_format.buttonbackgroundcolor,
bd=self.tk_format.bd,
)
offset_button.config(
fg=self.tk_format.buttontextcolor,
highlightbackground=self.tk_format.highlightbackgroundcolor,
bg=self.tk_format.buttonbackgroundcolor,
)
offset_button.pack(side=RIGHT, padx=(10, 10))
self.offset_entry.pack(side=RIGHT, padx=self.tk_format.padx)
offset_label.pack(side=RIGHT, padx=self.tk_format.padx)
outer_outer_zoom_frame = Frame(self.analysis_dialog.interior,
bg=self.tk_format.bg,
padx=self.tk_format.padx,
pady=15,
highlightthickness=1)
outer_outer_zoom_frame.pack(expand=True, fill=BOTH)
zoom_title_frame = Frame(outer_outer_zoom_frame, bg=self.tk_format.bg)
zoom_title_frame.pack(pady=(5, 10))
zoom_title_label = Label(zoom_title_frame,
text="Adjust plot x and y limits:",
bg=self.tk_format.bg,
fg=self.tk_format.textcolor)
zoom_title_label.pack(side=LEFT, pady=(0, 4))
outer_zoom_frame = Frame(outer_outer_zoom_frame,
bg=self.tk_format.bg,
padx=self.tk_format.padx)
outer_zoom_frame.pack(expand=True, fill=BOTH, pady=(0, 10))
zoom_frame = Frame(outer_zoom_frame,
bg=self.tk_format.bg,
padx=self.tk_format.padx)
zoom_frame.pack()
zoom_label = Label(zoom_frame,
text="x1:",
bg=self.tk_format.bg,
fg=self.tk_format.textcolor)
self.left_zoom_entry = Entry(
zoom_frame,
width=7,
bd=self.tk_format.bd,
bg=self.tk_format.entry_background,
selectbackground=self.tk_format.selectbackground,
selectforeground=self.tk_format.selectforeground,
)
zoom_label2 = Label(zoom_frame,
text="x2:",
bg=self.tk_format.bg,
fg=self.tk_format.textcolor)
self.right_zoom_entry = Entry(
zoom_frame,
width=7,
bd=self.tk_format.bd,
bg=self.tk_format.entry_background,
selectbackground=self.tk_format.selectbackground,
selectforeground=self.tk_format.selectforeground,
)
zoom_button = Button(
zoom_frame,
text="Apply",
command=self.apply_x,
width=7,
fg=self.tk_format.buttontextcolor,
bg=self.tk_format.buttonbackgroundcolor,
bd=self.tk_format.bd,
)
zoom_button.config(
fg=self.tk_format.buttontextcolor,
highlightbackground=self.tk_format.highlightbackgroundcolor,
bg=self.tk_format.buttonbackgroundcolor,
)
zoom_button.pack(side=RIGHT, padx=(10, 10))
self.right_zoom_entry.pack(side=RIGHT, padx=self.tk_format.padx)
zoom_label2.pack(side=RIGHT, padx=self.tk_format.padx)
self.left_zoom_entry.pack(side=RIGHT, padx=self.tk_format.padx)
zoom_label.pack(side=RIGHT, padx=self.tk_format.padx)
outer_zoom_frame2 = Frame(outer_outer_zoom_frame,
bg=self.tk_format.bg,
padx=self.tk_format.padx)
outer_zoom_frame2.pack(expand=True, fill=BOTH, pady=(0, 10))
zoom_frame2 = Frame(outer_zoom_frame2,
bg=self.tk_format.bg,
padx=self.tk_format.padx)
zoom_frame2.pack()
zoom_label3 = Label(zoom_frame2,
text="y1:",
bg=self.tk_format.bg,
fg=self.tk_format.textcolor)
self.left_zoom_entry2 = Entry(
zoom_frame2,
width=7,
bd=self.tk_format.bd,
bg=self.tk_format.entry_background,
selectbackground=self.tk_format.selectbackground,
selectforeground=self.tk_format.selectforeground,
)
zoom_label4 = Label(zoom_frame2,
text="y2:",
bg=self.tk_format.bg,
fg=self.tk_format.textcolor)
self.right_zoom_entry2 = Entry(
zoom_frame2,
width=7,
bd=self.tk_format.bd,
bg=self.tk_format.entry_background,
selectbackground=self.tk_format.selectbackground,
selectforeground=self.tk_format.selectforeground,
)
zoom_button2 = Button(
zoom_frame2,
text="Apply",
command=self.apply_y,
width=7,
fg=self.tk_format.buttontextcolor,
bg=self.tk_format.buttonbackgroundcolor,
bd=self.tk_format.bd,
)
zoom_button2.config(
fg=self.tk_format.buttontextcolor,
highlightbackground=self.tk_format.highlightbackgroundcolor,
bg=self.tk_format.buttonbackgroundcolor,
)
zoom_button2.pack(side=RIGHT, padx=(10, 10))
self.right_zoom_entry2.pack(side=RIGHT, padx=self.tk_format.padx)
zoom_label4.pack(side=RIGHT, padx=self.tk_format.padx)
self.left_zoom_entry2.pack(side=RIGHT, padx=self.tk_format.padx)
zoom_label3.pack(side=RIGHT, padx=self.tk_format.padx)
outer_outer_slope_frame = Frame(self.analysis_dialog.interior,
bg=self.tk_format.bg,
padx=self.tk_format.padx,
pady=15,
highlightthickness=1)
outer_outer_slope_frame.pack(expand=True, fill=BOTH)
self.outer_slope_frame = Frame(outer_outer_slope_frame,
bg=self.tk_format.bg,
padx=self.tk_format.padx)
self.outer_slope_frame.pack(expand=True, fill=BOTH, pady=(0, 10))
slope_title_frame = Frame(self.outer_slope_frame, bg=self.tk_format.bg)
slope_title_frame.pack(pady=(5, 5))
slope_title_label = Label(slope_title_frame,
text="Analyze ",
bg=self.tk_format.bg,
fg=self.tk_format.textcolor)
slope_title_label.pack(side=LEFT, pady=(0, 4))
self.analyze_var = StringVar()
self.analyze_var.set("slope")
analyze_menu = OptionMenu(
slope_title_frame,
self.analyze_var,
"slope",
"band depth",
"band center",
"reflectance",
# "reciprocity",
"difference",
command=self.disable_plot,
)
analyze_menu.configure(
width=10,
highlightbackground=self.tk_format.highlightbackgroundcolor)
analyze_menu.pack(side=LEFT)
# We'll put checkboxes for additional options into this frame at the time the user selects a given option (e.g.
# select 'difference' from menu, add option to calculate differences based on absolute value
self.extra_analysis_check_frame = Frame(self.outer_slope_frame,
bg=self.tk_format.bg,
padx=self.tk_format.padx)
self.extra_analysis_check_frame.pack()
# Note that we are not packing this checkbutton yet.
self.abs_val_check = Checkbutton(
self.extra_analysis_check_frame,
selectcolor=self.tk_format.check_bg,
fg=self.tk_format.textcolor,
text=" Use absolute values for average differences",
bg=self.tk_format.bg,
pady=self.tk_format.pady,
highlightthickness=0,
variable=self.abs_val,
)
self.use_max_for_centers_check = Checkbutton(
self.extra_analysis_check_frame,
selectcolor=self.tk_format.check_bg,
fg=self.tk_format.textcolor,
text=
" If band max is more prominent than\nband min, use to find center.",
bg=self.tk_format.bg,
pady=self.tk_format.pady,
highlightthickness=0,
variable=self.use_max_for_centers,
)
self.use_max_for_centers_check.select()
self.use_delta_check = Checkbutton(
self.extra_analysis_check_frame,
selectcolor=self.tk_format.check_bg,
fg=self.tk_format.textcolor,
text=" Center at max \u0394" +
"R from continuum \nrather than spectral min/max. ",
bg=self.tk_format.bg,
pady=self.tk_format.pady,
highlightthickness=0,
variable=self.use_delta,
)
self.use_delta_check.select()
self.neg_depth_check = Checkbutton(
self.extra_analysis_check_frame,
selectcolor=self.tk_format.check_bg,
fg=self.tk_format.textcolor,
text=
" If band max is more prominent than \nband min, report negative depth.",
bg=self.tk_format.bg,
pady=self.tk_format.pady,
highlightthickness=0,
variable=self.neg_depth,
)
self.neg_depth_check.select()
slope_frame = Frame(self.outer_slope_frame,
bg=self.tk_format.bg,
padx=self.tk_format.padx,
highlightthickness=0)
slope_frame.pack(pady=(15, 0))
slope_label = Label(slope_frame,
text="x1:",
bg=self.tk_format.bg,
fg=self.tk_format.textcolor)
self.left_slope_entry = Entry(
slope_frame,
width=7,
bd=self.tk_format.bd,
bg=self.tk_format.entry_background,
selectbackground=self.tk_format.selectbackground,
selectforeground=self.tk_format.selectforeground,
)
slope_label_2 = Label(slope_frame,
text="x2:",
bg=self.tk_format.bg,
fg=self.tk_format.textcolor)
self.right_slope_entry = Entry(
slope_frame,
width=7,
bd=self.tk_format.bd,
bg=self.tk_format.entry_background,
selectbackground=self.tk_format.selectbackground,
selectforeground=self.tk_format.selectforeground,
)
slope_button = Button(
slope_frame,
text="Calculate",
command=self.calculate,
width=7,
fg=self.tk_format.buttontextcolor,
bg=self.tk_format.buttonbackgroundcolor,
bd=self.tk_format.bd,
)
slope_button.config(
fg=self.tk_format.buttontextcolor,
highlightbackground=self.tk_format.highlightbackgroundcolor,
bg=self.tk_format.buttonbackgroundcolor,
)
slope_button.pack(side=RIGHT, padx=(10, 10))
self.right_slope_entry.pack(side=RIGHT, padx=self.tk_format.padx)
slope_label_2.pack(side=RIGHT, padx=self.tk_format.padx)
self.left_slope_entry.pack(side=RIGHT, padx=self.tk_format.padx)
slope_label.pack(side=RIGHT, padx=self.tk_format.padx)
self.slope_results_frame = Frame(self.outer_slope_frame,
bg=self.tk_format.bg)
self.slope_results_frame.pack(
fill=BOTH, expand=True
) # We'll put a listbox with slope info in here later after calculating.
outer_plot_slope_frame = Frame(outer_outer_slope_frame,
bg=self.tk_format.bg,
padx=self.tk_format.padx,
pady=10)
outer_plot_slope_frame.pack(expand=True, fill=BOTH)
plot_slope_frame = Frame(outer_plot_slope_frame,
bg=self.tk_format.bg,
padx=self.tk_format.padx)
plot_slope_frame.pack(side=RIGHT)
plot_slope_label = Label(plot_slope_frame,
text="Plot as a function of",
bg=self.tk_format.bg,
fg=self.tk_format.textcolor)
self.plot_slope_var = StringVar()
self.plot_slope_var.set("e")
self.plot_slope_menu = OptionMenu(plot_slope_frame,
self.plot_slope_var, "e", "i", "g",
"e,i", "theta", "az, e")
self.plot_slope_menu.configure(
width=2,
highlightbackground=self.tk_format.highlightbackgroundcolor)
self.plot_slope_button = Button(
plot_slope_frame,
text="Plot",
command=self.plot,
width=7,
fg=self.tk_format.buttontextcolor,
bg=self.tk_format.buttonbackgroundcolor,
bd=self.tk_format.bd,
)
self.plot_slope_button.config(
fg=self.tk_format.buttontextcolor,
highlightbackground=self.tk_format.highlightbackgroundcolor,
bg=self.tk_format.buttonbackgroundcolor,
state=DISABLED,
)
self.plot_slope_button.pack(side=RIGHT, padx=(10, 10))
self.plot_slope_menu.pack(side=RIGHT, padx=self.tk_format.padx)
plot_slope_label.pack(side=RIGHT, padx=self.tk_format.padx)
exclude_artifacts_frame = Frame(self.analysis_dialog.interior,
bg=self.tk_format.bg,
padx=self.tk_format.padx,
pady=15,
highlightthickness=1)
exclude_artifacts_frame.pack(fill=BOTH, expand=True)
self.exclude_artifacts_check = Checkbutton(
exclude_artifacts_frame,
selectcolor=self.tk_format.check_bg,
fg=self.tk_format.textcolor,
text=
" Exclude data susceptible to artifacts\n (high g, 1000-1400 nm) ",
bg=self.tk_format.bg,
pady=self.tk_format.pady,
highlightthickness=0,
variable=self.exclude_artifacts,
# TODO: check if the comma is meant to be there in the lambda definition
command=lambda x="foo", : self.tab.set_exclude_artifacts(
self.exclude_artifacts.get()),
)
self.exclude_artifacts_check.pack()
if self.tab.exclude_artifacts:
self.exclude_artifacts_check.select()
self.analysis_dialog.interior.configure(highlightthickness=1,
highlightcolor="white")
def calculate(self):
try:
self.controller.view_notebook.select(self.tab.top)
except TclError:
print("Error selecting tab in analysis_tools_manager.calculate().")
print(self.tab)
pass
artifact_warning = False
if self.analyze_var.get() == "slope":
left, right, slopes, artifact_warning = self.tab.calculate_slopes(
self.left_slope_entry.get(), self.right_slope_entry.get())
self.update_entries(left, right)
self.populate_listbox(slopes)
self.update_plot_menu(["e", "i", "g", "e,i", "theta", "az, e"])
elif self.analyze_var.get() == "band depth":
left, right, depths, artifact_warning = self.tab.calculate_band_depths(
self.left_slope_entry.get(),
self.right_slope_entry.get(),
self.neg_depth.get(),
self.use_delta.get(),
)
self.update_entries(left, right)
self.populate_listbox(depths)
self.update_plot_menu(["e", "i", "g", "e,i", "theta", "az, e"])
elif self.analyze_var.get() == "band center":
left, right, centers, artifact_warning = self.tab.calculate_band_centers(
self.left_slope_entry.get(),
self.right_slope_entry.get(),
self.use_max_for_centers.get(),
self.use_delta.get(),
)
self.update_entries(left, right)
self.populate_listbox(centers)
self.update_plot_menu(["e", "i", "g", "e,i", "theta", "az, e"])
elif self.analyze_var.get() == "reflectance":
left, right, reflectance, artifact_warning = self.tab.calculate_avg_reflectance(
self.left_slope_entry.get(), self.right_slope_entry.get())
self.update_entries(left, right)
self.populate_listbox(reflectance)
self.update_plot_menu(["e", "i", "g", "e,i", "theta", "az, e"])
elif self.analyze_var.get() == "reciprocity":
left, right, reciprocity, artifact_warning = self.tab.calculate_reciprocity(
self.left_slope_entry.get(), self.right_slope_entry.get())
self.update_entries(left, right)
self.populate_listbox(reciprocity)
self.update_plot_menu(["e", "i", "g", "e,i"])
elif self.analyze_var.get() == "difference":
left, right, error, artifact_warning = self.tab.calculate_error(
self.left_slope_entry.get(), self.right_slope_entry.get(),
self.abs_val.get())
# Tab validates left and right values. If they are no good, put in min and max wavelengths available.
self.update_entries(left, right)
self.populate_listbox(error)
self.update_plot_menu(["\u03bb", "e,i"])
if artifact_warning:
ErrorDialog(
self, "Warning",
"Warning: Excluding data potentially\ninfluenced by artifacts from 1000-1400 nm."
)
self.analysis_dialog.min_height = 1000
self.analysis_dialog.update()
def update_plot_menu(self, plot_options):
self.plot_slope_var.set(plot_options[0])
self.plot_slope_menu["menu"].delete(0, "end")
# Insert list of new options (tk._setit hooks them up to var)
max_len = len(plot_options[0])
for option in plot_options:
max_len = np.max([max_len, len(option)])
# pylint: disable = protected-access
self.plot_slope_menu["menu"].add_command(label=option,
command=tkinter._setit(
self.plot_slope_var,
option))
self.plot_slope_menu.configure(width=max_len)
def update_entries(self, left, right):
self.left_slope_entry.delete(0, "end")
self.left_slope_entry.insert(0, str(left))
self.right_slope_entry.delete(0, "end")
self.right_slope_entry.insert(0, str(right))
def populate_listbox(self, results):
if len(results) > 0:
self.slope_results_frame.pack(fill=BOTH,
expand=True,
pady=(10, 10))
try:
self.slopes_listbox.delete(0, "end")
except (AttributeError, TclError):
self.slopes_listbox = utils.ScrollableListbox(
self.slope_results_frame,
self.tk_format.bg,
self.tk_format.entry_background,
self.tk_format.listboxhighlightcolor,
selectmode=EXTENDED,
)
self.slopes_listbox.configure(height=8)
for result in results:
self.slopes_listbox.insert("end", result)
self.slopes_listbox.pack(fill=BOTH, expand=True)
self.plot_slope_button.configure(state=NORMAL)
def plot(self):
if self.analyze_var.get() == "slope":
self.tab.plot_slopes(self.plot_slope_var.get())
elif self.analyze_var.get() == "band depth":
self.tab.plot_band_depths(self.plot_slope_var.get())
elif self.analyze_var.get() == "band center":
self.tab.plot_band_centers(self.plot_slope_var.get())
elif self.analyze_var.get() == "reflectance":
self.tab.plot_avg_reflectance(self.plot_slope_var.get())
elif self.analyze_var.get() == "reciprocity":
self.tab.plot_reciprocity(self.plot_slope_var.get())
elif self.analyze_var.get() == "difference":
new = self.tab.plot_error(self.plot_slope_var.get())
if self.plot_slope_var.get() == "\u03bb":
x1 = float(self.left_slope_entry.get())
x2 = float(self.right_slope_entry.get())
new.adjust_x(x1, x2)
# TODO: plots not always fully updating
# (e.g. contour plot labels not showing up until you do a screen wiggle.
# utils.thread_lift_widget(self.analysis_dialog.top)
def normalize(self):
self.select_tab()
try:
self.slopes_listbox.delete(0, "end")
self.plot_slope_button.configure(state="disabled")
except (AttributeError, TclError):
pass
self.tab.normalize(self.normalize_entry.get())
# thread = Thread(target=utils.lift_widget, args=(self.analysis_dialog.top,))
# thread.start()
def offset(self):
self.tab.offset(self.offset_sample_var.get(), self.offset_entry.get())
# This doesn't work - it hangs between thread.start() and thread.join(). Likely because of calls to canvas.draw()
# thread = Thread(target=self.tab.offset, args=(self.offset_sample_var.get(), self.offset_entry.get()))
# thread.start()
# thread.join()
# utils.lift_widget(self.analysis_dialog.top)
def remove_topmost(self):
print("removing!!")
self.analysis_dialog.top.attributes("-topmost", False)
def apply_x(self):
self.controller.view_notebook.select(self.tab.top)
try:
x1 = float(self.left_zoom_entry.get())
x2 = float(self.right_zoom_entry.get())
self.tab.adjust_x(x1, x2)
# utils.lift_widget(self.analysis_dialog.top)
except ValueError:
# utils.lift_widget(self.analysis_dialog.top)
ErrorDialog(
self,
title="Invalid Zoom Range",
label="Error! Invalid x limits: " +
self.left_zoom_entry.get() + ", " +
self.right_zoom_entry.get(),
)
def apply_y(self):
self.controller.view_notebook.select(self.tab.top)
try:
y1 = float(self.left_zoom_entry2.get())
y2 = float(self.right_zoom_entry2.get())
self.tab.adjust_y(y1, y2)
# utils.lift_widget(self.analysis_dialog.top)
except ValueError:
# utils.lift_widget(self.analysis_dialog.top)
ErrorDialog(
self,
title="Invalid Zoom Range",
label="Error! Invalid y limits: " +
self.left_zoom_entry2.get() + ", " +
self.right_zoom_entry2.get(),
)
def uncheck_exclude_artifacts(self):
self.exclude_artifacts.set(0)
self.exclude_artifacts_check.deselect()
# utils.lift_widget(self.analysis_dialog.top)
def disable_plot(self, analyze_var="None"):
try:
self.slopes_listbox.delete(0, "end")
except (AttributeError, TclError):
pass
self.plot_slope_button.configure(state="disabled")
if analyze_var == "difference":
self.analysis_dialog.frame.min_height = 850
self.neg_depth_check.pack_forget()
self.use_max_for_centers_check.pack_forget()
self.use_delta_check.pack_forget()
self.abs_val_check.pack()
self.extra_analysis_check_frame.pack()
elif analyze_var == "band center":
self.analysis_dialog.frame.min_height = 1000
self.neg_depth_check.pack_forget()
self.abs_val_check.pack_forget()
self.use_delta_check.pack_forget()
self.use_max_for_centers_check.pack()
self.use_delta_check.pack()
self.extra_analysis_check_frame.pack()
elif analyze_var == "band depth":
self.analysis_dialog.frame.min_height = 1000
self.abs_val_check.pack_forget()
self.use_max_for_centers_check.pack_forget()
self.use_delta_check.pack_forget()
self.neg_depth_check.pack()
self.use_delta_check.pack()
self.extra_analysis_check_frame.pack()
else:
self.analysis_dialog.frame.min_height = 850
self.abs_val_check.pack_forget()
self.neg_depth_check.pack_forget()
self.use_max_for_centers_check.pack_forget()
self.use_delta_check.pack_forget()
self.extra_analysis_check_frame.grid_propagate(0)
self.extra_analysis_check_frame.configure(
height=1) # for some reason 0 doesn't work.
self.extra_analysis_check_frame.pack()
self.outer_slope_frame.pack()
# utils.lift_widget(self.analysis_dialog.top)
# def calculate_photometric_variability(self):
# photo_var = self.tab.calculate_photometric_variability(
# self.right_photo_var_entry.get(), self.left_photo_var_entry.get()
# )
# try:
# self.photo_var_listbox.delete(0, "end")
# except:
# self.photo_var_listbox = utils.ScrollableListbox(
# self.photo_var_results_frame,
# self.tk_format.bg,
# self.tk_format.entry_background,
# self.tk_format.listboxhighlightcolor,
# selectmode=EXTENDED,
# )
# for var in photo_var:
# self.photo_var_listbox.insert("end", var)
# self.photo_var_listbox.pack(fill=BOTH, expand=True)
def select_tab(self):
self.controller.view_notebook.select(self.tab.top)
class GUI:
def __init__(self, master):
self.valves = self.get_valves()
self.master = master
self.master.configure(bg='sky blue')
self.password = '******'
self.momentary = Momentary(self.master, self.valves)
self.edit = Edit(self.master, self.valves)
self.summary = Summary(self.master, self.valves)
self.preferences = Preferences(self.master, self.valves)
self.run_screen = RunScreen(self.master, self.valves)
self.header = self.make_header(self.master)
self.home = self.home_page(self.master)
self.frame = self.home
def make_header(self, master):
header = Frame(master, bg='sky blue')
self.label = StringVar()
self.label.set('NONE')
self.start_label = StringVar()
self.start_label.set('START')
self.lock_label = StringVar()
self.lock_label.set('LOCKED')
self.title = Label(header, textvariable=self.label, pady=20, font=('Lucida Console', 50))
self.title.config(bg='sky blue', fg='RoyalBlue4')
self.run_image = PhotoImage(file="img/animate.png").subsample(x=5, y=5)
self.run_button = Button(header, image=self.run_image, command=self.run, bg='SkyBlue4', activebackground='midnight blue', border=5)
self.start_button = Button(header, textvariable=self.start_label, font=('Lucida Console', 30), command=self.start_stop, height=5)
self.start_button.config(bg='brown3', activebackground='brown4', fg='white', activeforeground='white', width=10, border=5)
self.save_image = PhotoImage(file="img/save.png").subsample(x=5, y=5)
self.save_button = Button(header, image=self.save_image, command=self.save, bg='SkyBlue4', activebackground='midnight blue', border=5)
self.save_button.config(state='disabled')
self.reset_image = PhotoImage(file="img/reset.png").subsample(x=5, y=5)
self.reset_button = Button(header, image=self.reset_image, command=self.reset, bg='SkyBlue4', activebackground='midnight blue', border=5)
self.home_image = PhotoImage(file="img/home.png").subsample(x=5, y=5)
self.home_button = Button(header, image=self.home_image, command=self.to_home, bg='SkyBlue4', activebackground='midnight blue', border=5)
self.locked_image = PhotoImage(file="img/lock.png").subsample(x=5, y=5)
self.unlocked_image = PhotoImage(file="img/unlock.png").subsample(x=5, y=5)
self.lock_button = Button(header, image=self.locked_image, command=self.lock, bg='SkyBlue4', activebackground='midnight blue', border=5, textvariable=self.lock_label)
return header
def home_page(self, master):
frame = Frame(master)
frame.grid(row=0, column=0)
image = PhotoImage(file="img/guido.gif")
bg = Label(frame, image=image)
bg.image = image
bg.grid(row=0, column=0, rowspan=4, columnspan=2)
index = 0
while index < 3:
frame.grid_columnconfigure(index, minsize=200)
frame.grid_rowconfigure(index, minsize=80)
index += 1
summary_button = HomeButton(frame, self.to_summary, 'img/summary.png')
summary_button.grid(row=0, column=0, sticky='w')
edit_button = HomeButton(frame, self.to_edit, 'img/edit.png')
edit_button.grid(row=0, column=1, sticky='e')
momentary_button = HomeButton(frame, self.to_momentary, 'img/momentary.png')
momentary_button.grid(row=1, column=0, sticky='w')
preferences_button = HomeButton(frame, self.to_pref, 'img/preferences.png')
preferences_button.grid(row=1, column=1, sticky='e')
music = HomeButton(frame, self.to_summary, 'img/music.png')
music.grid(row=2, column=0, sticky='w')
info = HomeButton(frame, self.to_summary, 'img/info.png')
info.grid(row=2, column=1, sticky='e')
return frame
# CSV file input
def get_valves(self):
valves = [Valve('VALVE 1', 'DEFAULT', 'Action A', 'Action B', [0, 0]),
Valve('VALVE 2', 'DEFAULT', 'Action A', 'Action B', [0, 0]),
Valve('VALVE 3', 'DEFAULT', 'Action A', 'Action B', [0, 0]),
Valve('VALVE 4', 'DEFAULT', 'Action A', 'Action B', [0, 0]),
Valve('VALVE 5', 'DEFAULT', 'Action A', 'Action B', [0, 0]),
Valve('VALVE 6', 'DEFAULT', 'Action A', 'Action B', [0, 0]),
Valve('VALVE 7', 'DEFAULT', 'Action A', 'Action B', [0, 0]),
Valve('VALVE 8', 'DEFAULT', 'Action A', 'Action B', [0, 0])]
file = open('data.csv', 'rt', newline='')
try:
reader = csv.reader(file, lineterminator='\n')
index = 0
for row in reader:
if index == 0:
index += 1
continue
else:
run = int(row[4])
delay = int(row[5])
interval = [run, delay]
valves[index - 1] = Valve(row[0], row[1], row[2], row[3], interval)
index += 1
finally:
file.close()
return valves
def lock(self):
if self.lock_label.get() == 'LOCKED':
window = Toplevel()
window.geometry('318x550')
self.keypad = Keypad(window, self, self.password)
else:
self.save_button.config(state='disabled')
self.edit.lock()
self.preferences.lock()
self.lock_label.set('LOCKED')
self.lock_button.config(image=self.locked_image)
def save(self):
self.save_pref()
self.save_edit()
def save_edit(self):
file = open('data.csv', 'w')
interval = self.edit.get_intervals()
try:
writer = csv.writer(file, lineterminator='\n')
writer.writerow(('Name', 'Setting', 'Action A', 'Action B', 'Runtime', 'Delaytime'))
index = 0
for i in self.valves:
i.set_interval([interval[index].get(), interval[index + 8].get()])
valve_interval = i.get_interval()
if self.edit.plusInterval[index].cget('state') == 'disabled' and self.edit.motor[index].cget('state') != 'disabled':
i.set_setting('MOTOR')
writer.writerow((i.get_name().get(), i.get_setting(), i.get_action_a().get(), i.get_action_b().get(), 0, 0))
elif interval[index].get() is 0:
i.set_setting('INACTIVE')
writer.writerow((i.get_name().get(), i.get_setting(), 'NONE', 'NONE', 0, 0))
else:
i.set_setting('DEFAULT')
writer.writerow((i.get_name().get(), i.get_setting(), i.get_action_a().get(), i.get_action_b().get(), valve_interval[0], valve_interval[1]))
index += 1
finally:
file.close()
# must fix
def save_pref(self):
index = 0
for i in self.valves:
num = index * 3
if self.preferences.entry_field[num].get():
i.set_name(self.preferences.entry_field[num].get())
self.preferences.entry_field[num].delete(0, 'end')
if self.preferences.entry_field[num + 1].get():
i.set_action_a(self.preferences.entry_field[num + 1].get())
self.preferences.entry_field[num + 1].delete(0, 'end')
if self.preferences.entry_field[num + 2].get():
i.set_action_b(self.preferences.entry_field[num + 2].get())
self.preferences.entry_field[num + 2].delete(0, 'end')
index += 1
def start_stop(self):
if self.start_label.get() == 'START':
self.start_label.set('STOP')
self.master.update()
self.run_screen.run_all(True)
self.home_button.config(state='disabled')
else:
self.start_label.set('START')
self.run_screen.run_all(False)
self.home_button.config(state='normal')
def run(self):
self.summary.grid_remove()
self.run_button.pack_forget()
self.run_screen.make_frame()
self.frame = self.run_screen
self.frame.grid(row=0, column=0)
self.header.grid(row=0, column=1)
self.label.set('RUN')
self.title.pack(side='top')
self.start_button.pack()
self.home_button.pack(side='bottom')
def to_home(self):
self.momentary.end_all()
self.momentary.delete_frame()
self.lock_button.pack_forget()
self.run_button.pack_forget()
self.save_button.pack_forget()
self.reset_button.pack_forget()
self.home_button.pack_forget()
self.start_button.pack_forget()
self.preferences.grid_remove()
self.frame.grid_remove()
self.header.grid_remove()
self.frame = self.home
self.frame.grid(row=0, column=0)
def to_summary(self):
self.frame.grid_remove()
self.label.set('SUMMARY')
self.home_button.pack(side='right')
self.run_button.pack(side='right')
self.header.grid(row=0, column=0, columnspan=1, sticky='nsew')
self.title.pack(side='left')
self.summary = Summary(self.master, self.valves)
self.frame = self.summary
self.frame.grid(row=1, column=0)
def to_edit(self):
self.frame.grid_remove()
self.label.set('EDIT PROGRAM')
self.header.grid(row=0, column=0, columnspan=1, sticky='nsew')
self.home_button.pack(side='right')
self.save_button.pack(side='right')
self.lock_button.pack(side='right')
self.reset_button.pack(side='right')
self.title.pack(side='left')
self.frame = self.edit
self.frame.grid(row=1, column=0)
def to_momentary(self):
self.frame.grid_forget()
self.label.set('MOMENTARY')
self.header.grid(row=0, column=0, columnspan=12, sticky='ew')
self.title.pack(side='left')
self.home_button.pack(side='right')
self.momentary.make_frame()
def to_pref(self):
self.frame.grid_remove()
self.label.set('PREFERENCES')
self.header.grid(row=0, column=0, columnspan=1, sticky='nsew')
self.home_button.pack(side='right')
self.save_button.pack(side='right')
self.lock_button.pack(side='right')
self.reset_button.pack(side='right')
self.title.pack(side='left')
self.frame = self.preferences
self.frame.grid(row=1, column=0)
def reset(self):
self.master.quit()
def access_granted(self):
self.lock_label.set('UNLOCKED')
self.lock_button.config(image=self.unlocked_image)
self.save_button.config(state='normal')
index = 0
while index < 8:
self.edit.minusInterval[index].config(state='normal')
self.edit.minusDelay[index].config(state='normal')
self.edit.plusInterval[index].config(state='normal')
self.edit.plusDelay[index].config(state='normal')
self.edit.motor[index].config(state='normal')
self.edit.adv[index].config(state='normal')
index += 1
for each in self.preferences.entry_field:
each.config(state='normal')
self.edit.set_seconds()
self.save_button.config(state='normal')
Gender_Label = Label(framem,
text=" Enter your height in meters \n to the right:")
Gender_Label.grid(column=0, row=6, columnspan=2, pady=padding)
Gender_Label.config(width=26,
height=2,
bg="#EDF7FD",
fg="black",
font=("Calibri bold", 14),
justify="center")
PressMe = Button(framem, text="Press to find \n your BMI", command=add)
PressMe.grid(row=8, column=1, columnspan=2, pady=padding, sticky="w")
PressMe.config(width=19,
height=2,
bg="dark blue",
fg="white",
bd=3,
relief="ridge",
font=("Calibri bold", 14, "bold"))
v = IntVar()
Gender_Male = Radiobutton(framem, text="Male", variable=v, value=1)
Gender_Female = Radiobutton(framem, text="Female", variable=v, value=2)
Gender_Male.grid(column=2, row=6)
Gender_Male.config(width=5,
bg="White",
fg="black",
justify="center",
font=("Calibri", 12))
